From 9b35ab2d7b203f20377a6e7da01118a88539919b Mon Sep 17 00:00:00 2001
From: Victor Goff <keeperotphones@gmail.com>
Date: Wed, 22 Jun 2016 13:15:15 -0400
Subject: [PATCH 1/3] Generated Custom Set

The custom-set exercise is generated using data from x-common
repository.

fixes #365
fixes #348
references exercism/x-common#257
---
 bin/generate-custom-set                 |   7 +
 exercises/custom-set/.version           |   1 +
 exercises/custom-set/custom_set_test.rb | 321 +++++++++++++++++++-----
 exercises/custom-set/example.rb         |  13 +-
 exercises/custom-set/example.tt         |  19 ++
 lib/custom_set_cases.rb                 |  86 +++++++
 6 files changed, 376 insertions(+), 71 deletions(-)
 create mode 100755 bin/generate-custom-set
 create mode 100644 exercises/custom-set/.version
 create mode 100644 exercises/custom-set/example.tt
 create mode 100644 lib/custom_set_cases.rb

diff --git a/bin/generate-custom-set b/bin/generate-custom-set
new file mode 100755
index 0000000000..885e39fb4d
--- /dev/null
+++ b/bin/generate-custom-set
@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/helper'
+require 'generator'
+require 'custom_set_cases'
+
+Generator.new('custom-set', CustomSetCases).generate
diff --git a/exercises/custom-set/.version b/exercises/custom-set/.version
new file mode 100644
index 0000000000..56a6051ca2
--- /dev/null
+++ b/exercises/custom-set/.version
@@ -0,0 +1 @@
+1
\ No newline at end of file
diff --git a/exercises/custom-set/custom_set_test.rb b/exercises/custom-set/custom_set_test.rb
index e5f5b27e1e..ba89640a1b 100755
--- a/exercises/custom-set/custom_set_test.rb
+++ b/exercises/custom-set/custom_set_test.rb
@@ -3,114 +3,299 @@
 require 'minitest/autorun'
 require_relative 'custom_set'
 
+# Test data version:
+# cdfb4a2
 class CustomSetTest < Minitest::Test
-  def test_equal
-    assert_equal CustomSet.new([1, 3]), CustomSet.new([3, 1])
-    refute_equal CustomSet.new([1, 3]), CustomSet.new([3, 1, 5])
-    refute_equal CustomSet.new([1, 3, 5]), CustomSet.new([3, 1])
-    refute_equal CustomSet.new([1, 3]), CustomSet.new([2, 1])
+  def test_sets_with_no_elements_are_empty
+    # skip
+    set = CustomSet.new []
+    assert_empty set
   end
 
-  def test_no_duplicates
-    assert_equal CustomSet.new([1, 1]), CustomSet.new([1])
+  def test_sets_with_elements_are_not_empty
+    skip
+    set = CustomSet.new [1]
+    refute_empty set
+  end
+
+  def test_nothing_is_contained_in_an_empty_set
+    skip
+    set = CustomSet.new []
+    element = 1
+    refute set.member? element
+  end
+
+  def test_when_the_element_is_in_the_set
+    skip
+    set = CustomSet.new [1, 2, 3]
+    element = 1
+    assert set.member? element
   end
 
-  def test_delete
+  def test_when_the_element_is_not_in_the_set
     skip
-    assert_equal CustomSet.new([1, 3]), CustomSet.new([3, 2, 1]).delete(2)
-    assert_equal CustomSet.new([1, 2, 3]), CustomSet.new([3, 2, 1]).delete(4)
-    assert_equal CustomSet.new([1, 2, 3]), CustomSet.new([3, 2, 1]).delete(2.0)
-    assert_equal CustomSet.new([1, 3]), CustomSet.new([3, 2.0, 1]).delete(2.0)
+    set = CustomSet.new [1, 2, 3]
+    element = 4
+    refute set.member? element
   end
 
-  def test_difference
+  def test_empty_set_is_a_subset_of_another_empty_set
     skip
-    assert_equal CustomSet.new([1, 3]),
-                 CustomSet.new([1, 2, 3]).difference(CustomSet.new([2, 4]))
+    set1 = CustomSet.new []
+    set2 = CustomSet.new []
+    assert set1.subset? set2
+  end
 
-    assert_equal CustomSet.new([1, 2.0, 3]),
-                 CustomSet.new([1, 2.0, 3]).difference(CustomSet.new([2, 4]))
+  def test_empty_set_is_a_subset_of_non_empty_set
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new [1]
+    assert set1.subset? set2
   end
 
-  def test_disjoint?
+  def test_non_empty_set_is_not_a_subset_of_empty_set
     skip
-    assert CustomSet.new([1, 2]).disjoint?(CustomSet.new([3, 4]))
-    refute CustomSet.new([1, 2]).disjoint?(CustomSet.new([2, 3]))
-    assert CustomSet.new([1.0, 2.0]).disjoint?(CustomSet.new([2, 3]))
-    assert CustomSet.new.disjoint?(CustomSet.new)
+    set1 = CustomSet.new [1]
+    set2 = CustomSet.new []
+    refute set1.subset? set2
   end
 
-  def test_empty
+  def test_set_is_a_subset_of_set_with_exact_same_elements
     skip
-    assert_equal CustomSet.new, CustomSet.new([1, 2]).empty
-    assert_equal CustomSet.new, CustomSet.new.empty
+    set1 = CustomSet.new [1, 2, 3]
+    set2 = CustomSet.new [1, 2, 3]
+    assert set1.subset? set2
+  end
+
+  def test_set_is_a_subset_of_larger_set_with_same_elements
+    skip
+    set1 = CustomSet.new [1, 2, 3]
+    set2 = CustomSet.new [4, 1, 2, 3]
+    assert set1.subset? set2
+  end
+
+  def test_set_is_not_a_subset_of_set_that_does_not_contain_its_elements
+    skip
+    set1 = CustomSet.new [1, 2, 3]
+    set2 = CustomSet.new [4, 1, 3]
+    refute set1.subset? set2
+  end
+
+  def test_the_empty_set_is_disjoint_with_itself
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new []
+    assert set1.disjoint? set2
+  end
+
+  def test_empty_set_is_disjoint_with_non_empty_set
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new [1]
+    assert set1.disjoint? set2
+  end
+
+  def test_non_empty_set_is_disjoint_with_empty_set
+    skip
+    set1 = CustomSet.new [1]
+    set2 = CustomSet.new []
+    assert set1.disjoint? set2
+  end
+
+  def test_sets_are_not_disjoint_if_they_share_an_element
+    skip
+    set1 = CustomSet.new [1, 2]
+    set2 = CustomSet.new [2, 3]
+    refute set1.disjoint? set2
+  end
+
+  def test_sets_are_disjoint_if_they_share_no_elements
+    skip
+    set1 = CustomSet.new [1, 2]
+    set2 = CustomSet.new [3, 4]
+    assert set1.disjoint? set2
+  end
+
+  def test_empty_sets_are_equal
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new []
+    assert_equal set1, set2
+  end
+
+  def test_empty_set_is_not_equal_to_non_empty_set
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new [1, 2, 3]
+    refute_equal set1, set2
+  end
+
+  def test_non_empty_set_is_not_equal_to_empty_set
+    skip
+    set1 = CustomSet.new [1, 2, 3]
+    set2 = CustomSet.new []
+    refute_equal set1, set2
+  end
+
+  def test_sets_with_the_same_elements_are_equal
+    skip
+    set1 = CustomSet.new [1, 2]
+    set2 = CustomSet.new [2, 1]
+    assert_equal set1, set2
+  end
+
+  def test_sets_with_different_elements_are_not_equal
+    skip
+    set1 = CustomSet.new [1, 2, 3]
+    set2 = CustomSet.new [1, 2, 4]
+    refute_equal set1, set2
+  end
+
+  def test_add_to_empty_set
+    skip
+    set = CustomSet.new []
+    expected = CustomSet.new [3]
+    assert_equal expected, set.add(3)
+  end
+
+  def test_add_to_non_empty_set
+    skip
+    set = CustomSet.new [1, 2, 4]
+    expected = CustomSet.new [1, 2, 3, 4]
+    assert_equal expected, set.add(3)
+  end
+
+  def test_adding_an_existing_element_does_not_change_the_set
+    skip
+    set = CustomSet.new [1, 2, 3]
+    expected = CustomSet.new [1, 2, 3]
+    assert_equal expected, set.add(3)
+  end
+
+  def test_intersection_of_two_empty_sets_is_an_empty_set
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new []
+    expected = CustomSet.new []
+    assert_equal expected, set2.intersection(set1)
+  end
+
+  def test_intersection_of_an_empty_set_and_non_empty_set_is_an_empty_set
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new [3, 2, 5]
+    expected = CustomSet.new []
+    assert_equal expected, set2.intersection(set1)
+  end
+
+  def test_intersection_of_a_non_empty_set_and_an_empty_set_is_an_empty_set
+    skip
+    set1 = CustomSet.new [1, 2, 3, 4]
+    set2 = CustomSet.new []
+    expected = CustomSet.new []
+    assert_equal expected, set2.intersection(set1)
+  end
+
+  def test_intersection_of_two_sets_with_no_shared_elements_is_an_empty_set
+    skip
+    set1 = CustomSet.new [1, 2, 3]
+    set2 = CustomSet.new [4, 5, 6]
+    expected = CustomSet.new []
+    assert_equal expected, set2.intersection(set1)
   end
 
   # rubocop:disable Metrics/LineLength
-  def test_intersection
+  def test_intersection_of_two_sets_with_shared_elements_is_a_set_of_the_shared_elements
     skip
-    assert_equal CustomSet.new([:a, :c]),
-                 CustomSet.new([:a, :b, :c]).intersection(CustomSet.new([:a, :c, :d]))
+    set1 = CustomSet.new [1, 2, 3, 4]
+    set2 = CustomSet.new [3, 2, 5]
+    expected = CustomSet.new [2, 3]
+    assert_equal expected, set2.intersection(set1)
+  end
 
-    assert_equal CustomSet.new([3]),
-                 CustomSet.new([1, 2, 3]).intersection(CustomSet.new([1.0, 2.0, 3]))
+  def test_difference_of_two_empty_sets_is_an_empty_set
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new []
+    expected = CustomSet.new []
+    assert_equal expected, set1.difference(set2)
   end
 
-  def test_member?
+  def test_difference_of_empty_set_and_non_empty_set_is_an_empty_set
     skip
-    assert CustomSet.new([1, 2, 3]).member?(2)
-    assert CustomSet.new(1..3).member?(2)
-    refute CustomSet.new(1..3).member?(2.0)
-    refute CustomSet.new(1..3).member?(4)
+    set1 = CustomSet.new []
+    set2 = CustomSet.new [3, 2, 5]
+    expected = CustomSet.new []
+    assert_equal expected, set1.difference(set2)
   end
 
-  def test_put
+  def test_difference_of_a_non_empty_set_and_an_empty_set_is_the_non_empty_set
     skip
-    assert_equal CustomSet.new([1, 2, 3, 4]),
-                 CustomSet.new([1, 2, 4]).put(3)
+    set1 = CustomSet.new [1, 2, 3, 4]
+    set2 = CustomSet.new []
+    expected = CustomSet.new [1, 2, 3, 4]
+    assert_equal expected, set1.difference(set2)
+  end
 
-    assert_equal CustomSet.new([1, 2, 3]),
-                 CustomSet.new([1, 2, 3]).put(3)
+  def test_difference_of_two_non_empty_sets_is_a_set_of_elements_that_are_only_in_the_first_set
+    skip
+    set1 = CustomSet.new [3, 2, 1]
+    set2 = CustomSet.new [2, 4]
+    expected = CustomSet.new [1, 3]
+    assert_equal expected, set1.difference(set2)
+  end
 
-    assert_equal CustomSet.new([1, 2, 3, 3.0]),
-                 CustomSet.new([1, 2, 3]).put(3.0)
+  def test_union_of_empty_sets_is_an_empty_set
+    skip
+    set1 = CustomSet.new []
+    set2 = CustomSet.new []
+    expected = CustomSet.new []
+    assert_equal expected, set1.union(set2)
   end
 
-  def test_size
+  def test_union_of_an_empty_set_and_non_empty_set_is_the_non_empty_set
     skip
-    assert_equal 0, CustomSet.new.size
-    assert_equal 3, CustomSet.new([1, 2, 3]).size
-    assert_equal 3, CustomSet.new([1, 2, 3, 2]).size
+    set1 = CustomSet.new []
+    set2 = CustomSet.new [2]
+    expected = CustomSet.new [2]
+    assert_equal expected, set1.union(set2)
   end
 
-  def test_subset?
+  def test_union_of_a_non_empty_set_and_empty_set_is_the_non_empty_set
     skip
-    assert CustomSet.new([1, 2, 3]).subset?(CustomSet.new([1, 2, 3]))
-    assert CustomSet.new([4, 1, 2, 3]).subset?(CustomSet.new([1, 2, 3]))
-    refute CustomSet.new([4, 1, 3]).subset?(CustomSet.new([1, 2, 3]))
-    refute CustomSet.new([1, 2, 3, 4]).subset?(CustomSet.new([1, 2, 3.0]))
-    assert CustomSet.new([4, 1, 3]).subset?(CustomSet.new)
-    assert CustomSet.new.subset?(CustomSet.new)
+    set1 = CustomSet.new [1, 3]
+    set2 = CustomSet.new []
+    expected = CustomSet.new [1, 3]
+    assert_equal expected, set1.union(set2)
   end
 
-  def test_to_a
+  def test_union_of_non_empty_sets_contains_all_unique_elements
     skip
-    assert_equal [], CustomSet.new.to_a.sort
-    assert_equal [1, 2, 3], CustomSet.new([3, 1, 2]).to_a.sort
-    assert_equal [1, 2, 3], CustomSet.new([3, 1, 2, 1]).to_a.sort
+    set1 = CustomSet.new [1, 3]
+    set2 = CustomSet.new [2, 3]
+    expected = CustomSet.new [3, 2, 1]
+    assert_equal expected, set1.union(set2)
   end
 
-  def test_union # rubocop:disable Metrics/MethodLength
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
+  # The version number refers to the version of the problem you solved,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # If you are curious, read more about constants on RubyDoc:
+  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+
+  def test_bookkeeping
     skip
-    assert_equal CustomSet.new([3, 2, 1]),
-                 CustomSet.new([1, 3]).union(CustomSet.new([2]))
-    assert_equal CustomSet.new([3.0, 3, 2, 1]),
-                 CustomSet.new([1, 3]).union(CustomSet.new([2, 3.0]))
-    assert_equal CustomSet.new([3, 1]),
-                 CustomSet.new([1, 3]).union(CustomSet.new)
-    assert_equal CustomSet.new([2]),
-                 CustomSet.new([2]).union(CustomSet.new)
-    assert_equal CustomSet.new([]),
-                 CustomSet.new.union(CustomSet.new)
+    assert_equal 1, BookKeeping::VERSION
   end
 end
diff --git a/exercises/custom-set/example.rb b/exercises/custom-set/example.rb
index f6d5e23b37..f19ba0ee08 100644
--- a/exercises/custom-set/example.rb
+++ b/exercises/custom-set/example.rb
@@ -26,6 +26,10 @@ def empty
     CustomSet.new
   end
 
+  def empty?
+    size == 0
+  end
+
   def intersection(other)
     intersection = nodes.select do |node|
       other.nodes.any? { |other_node| other_node.eql?(node) }
@@ -37,7 +41,7 @@ def member?(datum)
     data.any? { |node| node.datum.eql?(datum) }
   end
 
-  def put(datum)
+  def add(datum)
     unless data.any? { |node| node.datum.eql?(datum) }
       add_datum(datum)
     end
@@ -49,8 +53,7 @@ def size
   end
 
   def subset?(other)
-    return true if other.data.empty?
-    other.nodes.all? { |other_node| nodes.any? { |node| node.eql?(other_node) } }
+    nodes.all? { |other_node| other.nodes.any? { |node| node.eql?(other_node) } }
   end
 
   def to_a
@@ -90,3 +93,7 @@ def initialize(input_datum)
     @datum = input_datum
   end
 end
+
+module BookKeeping
+  VERSION = 1
+end
diff --git a/exercises/custom-set/example.tt b/exercises/custom-set/example.tt
new file mode 100644
index 0000000000..2c2e3e6065
--- /dev/null
+++ b/exercises/custom-set/example.tt
@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'custom_set'
+
+# Test data version:
+# <%= sha1 %>
+class CustomSetTest < Minitest::Test<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
+    <%= test_case.skipped %>
+    <%= test_case.test_body %>
+  end
+<% end %>
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+  def test_bookkeeping
+    skip
+    assert_equal <%= version.next %>, BookKeeping::VERSION
+  end
+end
diff --git a/lib/custom_set_cases.rb b/lib/custom_set_cases.rb
new file mode 100644
index 0000000000..3bd47c9688
--- /dev/null
+++ b/lib/custom_set_cases.rb
@@ -0,0 +1,86 @@
+class CustomSetCase < OpenStruct
+  def name
+    'test_%s' % description.gsub(/ |-/, '_')
+  end
+
+  def test_body
+    send section
+  end
+
+  def union
+    "set1 = CustomSet.new #{set1}
+    set2 = CustomSet.new #{set2}
+    expected = CustomSet.new #{expected}
+    #{assert_or_refute}_equal expected, set1.union(set2)"
+  end
+
+  def difference
+    "set1 = CustomSet.new #{set1}
+    set2 = CustomSet.new #{set2}
+    expected = CustomSet.new #{expected}
+    #{assert_or_refute}_equal expected, set1.difference(set2)"
+  end
+
+  def intersection
+    "set1 = CustomSet.new #{set1}
+    set2 = CustomSet.new #{set2}
+    expected = CustomSet.new #{expected}
+    #{assert_or_refute}_equal expected, set2.intersection(set1)"
+  end
+
+  def add
+    "set = CustomSet.new #{set}
+    expected = CustomSet.new #{expected}
+    #{assert_or_refute}_equal expected, set.add(#{element})"
+  end
+
+  def equal
+    "set1 = CustomSet.new #{set1}
+    set2 = CustomSet.new #{set2}
+    #{assert_or_refute}_equal set1, set2"
+  end
+
+  def disjoint
+    "set1 = CustomSet.new #{set1}
+    set2 = CustomSet.new #{set2}
+    #{assert_or_refute} set1.disjoint? set2"
+  end
+
+  def subset
+    "set1 = CustomSet.new #{set1}
+    set2 = CustomSet.new #{set2}
+    #{assert_or_refute} set1.subset? set2"
+  end
+
+  def empty
+    "set = CustomSet.new #{set}
+    #{assert_or_refute}_empty set"
+  end
+
+  def contains
+    "set = CustomSet.new #{set}
+    element = #{element}
+    #{assert_or_refute} set.member? element"
+  end
+
+  def assert_or_refute
+    expected ? 'assert' : 'refute'
+  end
+
+  def skipped
+    index.zero? ? '# skip' : 'skip'
+  end
+end
+
+CustomSetCases = proc do |data|
+  json = JSON.parse(data)
+  cases = []
+  i = 0
+  (json.keys - ['#']).each do |section|
+    json[section]['cases'].each do |row|
+      cases << CustomSetCase.new(row.merge('index' => i, 'section' => section))
+      i += 1
+    end
+  end
+  cases
+end

From 673ae9fc74e98bb11056a9d63ba1f671b226c741 Mon Sep 17 00:00:00 2001
From: Cohen Carlisle <cohen.carlisle@gmail.com>
Date: Thu, 30 Jun 2016 15:09:51 -0400
Subject: [PATCH 2/3] change CustomSet#member? to #include?

Use #include? over #member? as #include? is more idiomatic.
For example, while Enumerable defines both, Array only
implements #include? in a more efficient manner.
---
 exercises/custom-set/custom_set_test.rb | 8 ++++----
 exercises/custom-set/example.rb         | 2 +-
 lib/custom_set_cases.rb                 | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/exercises/custom-set/custom_set_test.rb b/exercises/custom-set/custom_set_test.rb
index ba89640a1b..4e96cff4b7 100755
--- a/exercises/custom-set/custom_set_test.rb
+++ b/exercises/custom-set/custom_set_test.rb
@@ -4,7 +4,7 @@
 require_relative 'custom_set'
 
 # Test data version:
-# cdfb4a2
+# 2d6e205
 class CustomSetTest < Minitest::Test
   def test_sets_with_no_elements_are_empty
     # skip
@@ -22,21 +22,21 @@ def test_nothing_is_contained_in_an_empty_set
     skip
     set = CustomSet.new []
     element = 1
-    refute set.member? element
+    refute set.include? element
   end
 
   def test_when_the_element_is_in_the_set
     skip
     set = CustomSet.new [1, 2, 3]
     element = 1
-    assert set.member? element
+    assert set.include? element
   end
 
   def test_when_the_element_is_not_in_the_set
     skip
     set = CustomSet.new [1, 2, 3]
     element = 4
-    refute set.member? element
+    refute set.include? element
   end
 
   def test_empty_set_is_a_subset_of_another_empty_set
diff --git a/exercises/custom-set/example.rb b/exercises/custom-set/example.rb
index f19ba0ee08..2b566eb5db 100644
--- a/exercises/custom-set/example.rb
+++ b/exercises/custom-set/example.rb
@@ -37,7 +37,7 @@ def intersection(other)
     CustomSet.new(intersection)
   end
 
-  def member?(datum)
+  def include?(datum)
     data.any? { |node| node.datum.eql?(datum) }
   end
 
diff --git a/lib/custom_set_cases.rb b/lib/custom_set_cases.rb
index 3bd47c9688..3e430cade5 100644
--- a/lib/custom_set_cases.rb
+++ b/lib/custom_set_cases.rb
@@ -60,7 +60,7 @@ def empty
   def contains
     "set = CustomSet.new #{set}
     element = #{element}
-    #{assert_or_refute} set.member? element"
+    #{assert_or_refute} set.include? element"
   end
 
   def assert_or_refute

From e80522aee9c2ef646d7ceaac7da96f0f1e6cb6f7 Mon Sep 17 00:00:00 2001
From: Cohen Carlisle <cohen.carlisle@gmail.com>
Date: Thu, 30 Jun 2016 16:22:56 -0400
Subject: [PATCH 3/3] add failure msgs to plain old asserts/refutes

---
 exercises/custom-set/custom_set_test.rb | 28 ++++++++++++-------------
 lib/custom_set_cases.rb                 | 22 ++++++++++++++++---
 2 files changed, 33 insertions(+), 17 deletions(-)

diff --git a/exercises/custom-set/custom_set_test.rb b/exercises/custom-set/custom_set_test.rb
index 4e96cff4b7..2c12d29864 100755
--- a/exercises/custom-set/custom_set_test.rb
+++ b/exercises/custom-set/custom_set_test.rb
@@ -22,98 +22,98 @@ def test_nothing_is_contained_in_an_empty_set
     skip
     set = CustomSet.new []
     element = 1
-    refute set.include? element
+    refute set.include?(element), '[] does NOT include 1'
   end
 
   def test_when_the_element_is_in_the_set
     skip
     set = CustomSet.new [1, 2, 3]
     element = 1
-    assert set.include? element
+    assert set.include?(element), '[1, 2, 3] does include 1'
   end
 
   def test_when_the_element_is_not_in_the_set
     skip
     set = CustomSet.new [1, 2, 3]
     element = 4
-    refute set.include? element
+    refute set.include?(element), '[1, 2, 3] does NOT include 4'
   end
 
   def test_empty_set_is_a_subset_of_another_empty_set
     skip
     set1 = CustomSet.new []
     set2 = CustomSet.new []
-    assert set1.subset? set2
+    assert set1.subset?(set2), '[] is a subset of []'
   end
 
   def test_empty_set_is_a_subset_of_non_empty_set
     skip
     set1 = CustomSet.new []
     set2 = CustomSet.new [1]
-    assert set1.subset? set2
+    assert set1.subset?(set2), '[] is a subset of [1]'
   end
 
   def test_non_empty_set_is_not_a_subset_of_empty_set
     skip
     set1 = CustomSet.new [1]
     set2 = CustomSet.new []
-    refute set1.subset? set2
+    refute set1.subset?(set2), '[1] is NOT a subset of []'
   end
 
   def test_set_is_a_subset_of_set_with_exact_same_elements
     skip
     set1 = CustomSet.new [1, 2, 3]
     set2 = CustomSet.new [1, 2, 3]
-    assert set1.subset? set2
+    assert set1.subset?(set2), '[1, 2, 3] is a subset of [1, 2, 3]'
   end
 
   def test_set_is_a_subset_of_larger_set_with_same_elements
     skip
     set1 = CustomSet.new [1, 2, 3]
     set2 = CustomSet.new [4, 1, 2, 3]
-    assert set1.subset? set2
+    assert set1.subset?(set2), '[1, 2, 3] is a subset of [4, 1, 2, 3]'
   end
 
   def test_set_is_not_a_subset_of_set_that_does_not_contain_its_elements
     skip
     set1 = CustomSet.new [1, 2, 3]
     set2 = CustomSet.new [4, 1, 3]
-    refute set1.subset? set2
+    refute set1.subset?(set2), '[1, 2, 3] is NOT a subset of [4, 1, 3]'
   end
 
   def test_the_empty_set_is_disjoint_with_itself
     skip
     set1 = CustomSet.new []
     set2 = CustomSet.new []
-    assert set1.disjoint? set2
+    assert set1.disjoint?(set2), '[] and [] are disjoint'
   end
 
   def test_empty_set_is_disjoint_with_non_empty_set
     skip
     set1 = CustomSet.new []
     set2 = CustomSet.new [1]
-    assert set1.disjoint? set2
+    assert set1.disjoint?(set2), '[] and [1] are disjoint'
   end
 
   def test_non_empty_set_is_disjoint_with_empty_set
     skip
     set1 = CustomSet.new [1]
     set2 = CustomSet.new []
-    assert set1.disjoint? set2
+    assert set1.disjoint?(set2), '[1] and [] are disjoint'
   end
 
   def test_sets_are_not_disjoint_if_they_share_an_element
     skip
     set1 = CustomSet.new [1, 2]
     set2 = CustomSet.new [2, 3]
-    refute set1.disjoint? set2
+    refute set1.disjoint?(set2), '[1, 2] and [2, 3] are NOT disjoint'
   end
 
   def test_sets_are_disjoint_if_they_share_no_elements
     skip
     set1 = CustomSet.new [1, 2]
     set2 = CustomSet.new [3, 4]
-    assert set1.disjoint? set2
+    assert set1.disjoint?(set2), '[1, 2] and [3, 4] are disjoint'
   end
 
   def test_empty_sets_are_equal
diff --git a/lib/custom_set_cases.rb b/lib/custom_set_cases.rb
index 3e430cade5..a8fa9eb6ea 100644
--- a/lib/custom_set_cases.rb
+++ b/lib/custom_set_cases.rb
@@ -43,13 +43,13 @@ def equal
   def disjoint
     "set1 = CustomSet.new #{set1}
     set2 = CustomSet.new #{set2}
-    #{assert_or_refute} set1.disjoint? set2"
+    #{assert_or_refute} set1.disjoint?(set2), #{disjoint_failure_msg}"
   end
 
   def subset
     "set1 = CustomSet.new #{set1}
     set2 = CustomSet.new #{set2}
-    #{assert_or_refute} set1.subset? set2"
+    #{assert_or_refute} set1.subset?(set2), #{subset_failure_msg}"
   end
 
   def empty
@@ -60,13 +60,29 @@ def empty
   def contains
     "set = CustomSet.new #{set}
     element = #{element}
-    #{assert_or_refute} set.include? element"
+    #{assert_or_refute} set.include?(element), #{contains_failure_msg}"
   end
 
   def assert_or_refute
     expected ? 'assert' : 'refute'
   end
 
+  def disjoint_failure_msg
+    "'#{set1} and #{set2} are#{not?} disjoint'"
+  end
+
+  def subset_failure_msg
+    "'#{set1} is#{not?} a subset of #{set2}'"
+  end
+
+  def contains_failure_msg
+    "'#{set} does#{not?} include #{element}'"
+  end
+
+  def not?
+    expected ? '' : ' NOT'
+  end
+
   def skipped
     index.zero? ? '# skip' : 'skip'
   end