bit_set 0.1.0

data/lib/god_object/bit_set/configuration.rb

@@ -0,0 +1,213 @@
+# encoding: UTF-8
+=begin
+Copyright GodObject Team <dev@godobject.net>, 2012-2016
+
+This file is part of BitSet.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+=end
+
+module GodObject
+  module BitSet
+
+    # A Configuration defines the digits of a BitSet. Additionally it can hold
+    # information on how to represent the digits in a String representation.
+    class Configuration
+
+      # @return [String] the default String representation for enabled digits
+      UNNAMED_ENABLED  = '1'.freeze
+
+      # @return [String] the default String representation for disabled digits
+      UNNAMED_DISABLED = '0'.freeze
+
+      # @return [String] the default String representation for disabled digits
+      #   which have a custom enabled representation
+      NAMED_DISABLED   = '-'.freeze
+
+      class << self
+
+        # @overload build(configuration)
+        #   Returns an existing instance of GodObject::BitSet::Configuration.
+        #   @param [GodObject::BitSet::Configuration] configuration an already
+        #     existing Configuration
+        #   @return [GodObject::BitSet::Configuration] the same Configuration object
+        #
+        # @overload build(digits)
+        #   Returns a new Configuration object with given attributes.
+        #   @param [Array<Symbol>] digits a list of digit names
+        #   @return [GodObject::PosixMode::Mode] a new Configuration object
+        #
+        # @overload build(enabled_representations_by_digits)
+        #   Returns a new Configuration object with given attributes.
+        #   @param [Hash<Symbol => String>] enabled_representations_by_digits
+        #     digit names mapped to their enabled character representations
+        #   @return [GodObject::PosixMode::Mode] a new Configuration object
+        #
+        # @overload build(representations_by_digits)
+        #   Returns a new Configuration object with given attributes.
+        #   @param [Hash<Symbol => Array<String>>] representations_by_digits
+        #     digit names mapped to their enabled and disabled character
+        #     representations
+        #   @return [GodObject::PosixMode::Mode] a new Configuration object
+        def build(configuration)
+          if configuration.is_a?(Configuration)
+            configuration
+          else
+            new(configuration)
+          end
+        end
+
+      end
+
+      # @return [Range<Integer>] the Range in which an Integer representation of a
+      #   BitSet with this Configuration can be.
+      attr_reader :valid_range
+
+      # Initializes a new BitSet::Configuration
+      # 
+      # @overload initialize(digits)
+      #   @param [Array<Symbol>] digits a list of digit names
+      #
+      # @overload initialize(enabled_representations_by_digits)
+      #   @param [Hash<Symbol => String>] enabled_representations_by_digits
+      #     digit names mapped to their enabled character representations
+      #
+      # @overload initialize(representations_by_digits)
+      #   @param [Hash<Symbol => Array<String>>] representations_by_digits
+      #     digit names mapped to their enabled and disabled character
+      #     representations
+      def initialize(configuration)
+        @digits   = {}
+        @enabled  = {}
+        @disabled = {}
+
+        configuration.each do |digit, display|
+          digit = digit.to_sym
+
+          @digits[digit] = nil
+
+          case
+          when display.respond_to?(:all?) && display.all?{|s| s.respond_to?(:to_str) && s.to_str.length == 1}
+            @enabled[digit]  = display.first.to_str.dup.freeze
+            @disabled[digit] = display.last.to_str.dup.freeze
+          when display.respond_to?(:to_str) && display.to_str.length == 1
+            @enabled[digit]  = display.to_str.dup.freeze
+            @disabled[digit] = NAMED_DISABLED
+          when display.nil?
+            @enabled[digit]  = UNNAMED_ENABLED
+            @disabled[digit] = UNNAMED_DISABLED
+          else
+            raise ArgumentError, 'Invalid configuration'
+          end
+        end
+
+        raise ArgumentError, 'At least one digit must be configured' if digits.count < 1
+
+        @digits.keys.reverse.each_with_index{|digit, index| @digits[digit] = 2 ** index }
+
+        @valid_range = Range.new(0, (@digits.values.first * 2) - 1).freeze
+
+        @unique_characters = !@enabled.values.dup.uniq!
+      end
+
+      # Answers if all digits have unique enabled representations.
+      #
+      # @return [true, false] true if all digits have unique enabled
+      #   representations, false otherwise
+      def unique_characters?
+        @unique_characters
+      end
+
+      # @attribute digits [readonly]
+      # @return [Array<Symbol>] an ordered list of all configured digit names
+      def digits
+        @digits.keys
+      end
+
+      # @param [Integer, Array<Symbol>] state either the octal state of the
+      #   BitSet or a list of enabled digits
+      # @return [GodObject::BitSet] a new BitSet object with the current
+      #   configuration
+      def new(*state)
+        BitSet.new(*state, self)
+      end
+
+      # @return [Integer] the Integer representation of a BitSet where
+      #   only the given digit is enabled.
+      def binary_position(digit)
+        @digits[find_digit(digit)]
+      end
+
+      # @param [Symbol, Integer] digit the name or index of the digit
+      # @return [String] the String representation for the given digit when
+      #   it is disabled
+      def disabled_character(digit)
+        @disabled[find_digit(digit)]
+      end
+
+      # @param [Symbol, Integer] digit the name or index of the digit
+      # @return [String] the String representation for the given digit when
+      #   it is enabled
+      def enabled_character(digit)
+        @enabled[find_digit(digit)]
+      end
+
+      # @param [Symbol, Integer] index_or_digit the name or index of the digit
+      # @return [Symbol] the digit's name
+      def find_digit(index_or_digit)
+        case
+        when index_or_digit.respond_to?(:to_sym)
+          digit = index_or_digit.to_sym
+
+          raise ArgumentError, "Invalid digit name (#{index_or_digit})" unless @digits.keys.include?(digit)
+        else
+          digit = @digits.keys[index_or_digit.to_int]
+        end
+
+        raise ArgumentError, "Invalid index or digit (#{index_or_digit})" unless digit
+
+        digit
+      end
+
+      # Answers if another object is equal.
+      #
+      # Equality is defined as having the same ordered list of digits.
+      #
+      # @param [Object] other an object to be checked for equality
+      # @return [true, false] true if the object is considered equal, false
+      #   otherwise
+      def ==(other)
+        digits == other.digits
+      rescue NoMethodError
+        false
+      end
+
+      # Answers if another object is equal and of the same type family.
+      #
+      # @see GodObject::Configuration#==
+      # @param [Object] other an object to be checked for equality
+      # @return [true, false] true if the object is considered equal and of
+      #   the same type familiy, false otherwise
+      def eql?(other)
+        self == other && other.kind_of?(self.class)
+      end
+
+      # @return (see Hash#hash) identity hash for hash table usage
+      def hash
+        @digits.hash
+      end
+
+    end
+
+  end
+end

data/lib/god_object/bit_set/version.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+=begin
+Copyright GodObject Team <dev@godobject.net>, 2012-2016
+
+This file is part of BitSet.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+=end
+
+module GodObject
+  module BitSet
+
+    # The currently loaded version.
+    #
+    # Using Semantic Versioning (2.0.0) rules
+    # @see http://semver.org/spec/v2.0.0.html
+    VERSION = '0.1.0'.freeze
+
+  end
+end

data/spec/god_object/bit_set/bit_set_spec.rb

@@ -0,0 +1,487 @@
+# encoding: UTF-8
+=begin
+Copyright GodObject Team <dev@godobject.net>, 2012-2016
+
+This file is part of BitSet.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+=end
+
+module GodObject
+  module BitSet
+
+    describe BitSet do
+      let(:traffic_light_configuration) { Configuration.new(red: 'r', yellow: 'y', green: 'g') }
+      let(:generic_configuration) { Configuration.new([:a, :b, :c, :d, :e])}
+
+      describe ".new" do
+        it "should accept a configuration" do
+          result = BitSet.new(generic_configuration)
+
+          expect(result).to be_a(BitSet)
+          expect(result.to_i).to eql 0
+          expect(result.configuration).to eql generic_configuration
+        end
+
+        it "should accept an Integer as initial state and a configuration" do
+          result = BitSet.new(0b01010, generic_configuration)
+
+          expect(result).to be_a(BitSet)
+          expect(result.to_i).to eql 0b01010
+          expect(result.configuration).to eql generic_configuration
+        end
+
+        it "should accept multiple arguments of enabled digits as initial state and a configuration" do
+          result = BitSet.new(:red, :green, traffic_light_configuration)
+
+          expect(result).to be_a(BitSet)
+          expect(result.to_i).to eql 0b101
+          expect(result.configuration).to eql traffic_light_configuration
+        end
+
+        it "should accept a list of enabled digits as initial state and a configuration" do
+          result = BitSet.new(Set[:red, :green], traffic_light_configuration)
+
+          expect(result).to be_a(BitSet)
+          expect(result.to_i).to eql 0b101
+          expect(result.configuration).to eql traffic_light_configuration
+        end
+
+        it "should accept on-the-fly configurations" do
+          result = BitSet.new(Set[:symmetric, :transitive], symmetric: nil, transitive: 't', antisymmetric: ['a', 'x'])
+
+          configuration = Configuration.build(symmetric: nil, transitive: 't', antisymmetric: ['a', 'x'])
+
+          expect(result).to be_a(BitSet)
+          expect(result.to_i).to eql 0b110
+          expect(result.to_s).to eql "1tx"
+          expect(result.configuration).to eql configuration
+        end
+
+        it "should complain about invalid digits" do
+          expect {
+            BitSet.new(Set[:white, :blue, :green], traffic_light_configuration)
+          }.to raise_error(ArgumentError, "Invalid digit(s): :white, :blue")
+        end
+
+        it "should complain about invalid state" do
+          expect {
+            BitSet.new(:invalid, traffic_light_configuration)
+          }.to raise_error(ArgumentError, "Invalid digit(s): :invalid")
+        end
+
+        it "should complain about invalid configuration" do
+          expect {
+            BitSet.new(3, invalid: 12)
+          }.to raise_error(ArgumentError, 'Invalid configuration')
+        end
+      end
+
+      context "magic attributes" do
+        it "should allow accessing each digit's on/off state by name" do
+          bit_set = BitSet.new(0b001, traffic_light_configuration)
+
+          expect(bit_set.red).to eq false
+          expect(bit_set.yellow).to eq false
+          expect(bit_set.green).to eq true
+        end
+
+        it "should allow accessing each digit's on/off state by a question mark method" do
+          bit_set = BitSet.new(0b01101, generic_configuration)
+
+          expect(bit_set.a?).to eq false
+          expect(bit_set.b?).to eq true
+          expect(bit_set.c?).to eq true
+          expect(bit_set.d?).to eq false
+          expect(bit_set.e?).to eq true
+        end
+
+        it "should complain about invalid methods as usual" do
+          expect {
+            BitSet.new(0b101, traffic_light_configuration).fnord
+          }.to raise_error(NoMethodError, /^undefined method `fnord'/)
+        end
+      end
+
+      [:state, :attributes].each do |method_name|
+        describe "##{method_name}" do
+          it "should list all digits and their on/off state" do
+            bit_set = BitSet.new(0b10101, generic_configuration)
+    
+            expect(bit_set.public_send(method_name)).to eql(
+              a: true,
+              b: false,
+              c: true,
+              d: false,
+              e: true
+            )
+          end
+        end
+      end
+
+      describe "#to_i" do
+        it "should return the Integer state" do
+          bit_set = BitSet.new(6, traffic_light_configuration)
+
+          expect(bit_set.to_i).to eql 6
+        end
+      end
+
+      describe "#[]" do
+        it "should return true if the digit given by symbol is on" do
+          bit_set = BitSet.new(0b100, traffic_light_configuration)
+
+          expect(bit_set[:red]).to eq true
+        end
+
+        it "should return true if the digit given by index is on" do
+          bit_set = BitSet.new(0b100, traffic_light_configuration)
+
+          expect(bit_set[0]).to eq true
+        end
+
+        it "should return false if the digit given by symbol is off" do
+          bit_set = BitSet.new(0b11101, generic_configuration)
+
+          expect(bit_set[:d]).to eq false
+        end
+
+        it "should return false if the digit given by index is off" do
+          bit_set = BitSet.new(0b11101, generic_configuration)
+
+          expect(bit_set[3]).to eq false
+        end
+      end
+
+      describe "#enabled_digits" do
+        it "should return the set of digits which are on" do
+          bit_set = BitSet.new(0b10101, generic_configuration)
+
+          expect(bit_set.enabled_digits).to eql Set[:a, :c, :e]
+        end
+      end
+
+      describe "#disabled_digits" do
+        it "should return the set of digits which are off" do
+          bit_set = BitSet.new(0b001, traffic_light_configuration)
+
+          expect(bit_set.disabled_digits).to eql Set[:red, :yellow]
+        end
+      end
+
+      describe "#invert" do
+        it "should return a copy with every digit on/off state toggled" do
+          bit_set = BitSet.new(0b101, traffic_light_configuration)
+
+          result = bit_set.invert
+          expect(result).to be_a(BitSet)
+          expect(result.configuration).to eql traffic_light_configuration
+          expect(result.to_i).to eql 0b010
+          expect(result).not_to equal bit_set
+        end
+      end
+
+      describe "#+" do
+        it "should return a copy with all added digits switched to on (given a BitSet)" do
+          bit_set = BitSet.new(0b01000, generic_configuration)
+
+          result = bit_set + BitSet.new([:a, :d], generic_configuration)
+
+          expect(result).to be_a(BitSet)
+          expect(result.configuration).to eql generic_configuration
+          expect(result.to_i).to eql 0b11010
+          expect(result).not_to equal bit_set
+        end
+
+        it "should return a copy with all added digits switched to on (given an Enumerable)" do
+          bit_set = BitSet.new(0b01010, generic_configuration)
+
+          result = bit_set + Set[:a, :d]
+
+          expect(result).to be_a(BitSet)
+          expect(result.configuration).to eql generic_configuration
+          expect(result.to_i).to eql 0b11010
+          expect(result).not_to equal bit_set
+        end
+      end
+
+      describe "#-" do
+        it "should return a copy with all added digits switched to on (given a BitSet)" do
+          bit_set = BitSet.new(0b110, traffic_light_configuration)
+
+          result = bit_set - BitSet.new([:yellow, :green], traffic_light_configuration)
+
+          expect(result).to be_a(BitSet)
+          expect(result.configuration).to eql traffic_light_configuration
+          expect(result.to_i).to eql 0b100
+          expect(result).not_to equal bit_set
+        end
+
+        it "should return a copy with all added digits switched to on (given an Enumerable)" do
+          bit_set = BitSet.new(0b101, traffic_light_configuration)
+
+          result = bit_set - [:red, :yellow]
+
+          expect(result).to be_a(BitSet)
+          expect(result.configuration).to eql traffic_light_configuration
+          expect(result.to_i).to eql 0b001
+          expect(result).not_to equal bit_set
+        end
+      end
+
+      [:union, :|].each do |method_name|
+        describe "##{method_name}" do
+          it "should return a copy with all enabled digits of both operands switched to on (given a BitSet)" do
+            bit_set = BitSet.new(0b01101, generic_configuration)
+
+            result = bit_set.public_send(method_name,
+                       BitSet.new([:d, :e], generic_configuration))
+
+            expect(result).to be_a(BitSet)
+            expect(result.configuration).to eql generic_configuration
+            expect(result.to_i).to eql 0b01111
+            expect(result).not_to equal bit_set
+          end
+
+          it "should return a copy with all enabled digits of both operands switched to on (given an Integer)" do
+            bit_set = BitSet.new(0b01101, generic_configuration)
+
+            result = bit_set.public_send(method_name, 0b00011)
+
+            expect(result).to be_a(BitSet)
+            expect(result.configuration).to eql generic_configuration
+            expect(result.to_i).to eql 0b01111
+            expect(result).not_to equal bit_set
+          end
+        end
+      end
+
+      [:intersection, :&].each do |method_name|
+        describe "##{method_name}" do
+          it "should return a copy with only those digits switched to on which are on in both operands (given a BitSet)" do
+            bit_set = BitSet.new(0b110, traffic_light_configuration)
+
+            result = bit_set.public_send(method_name,
+                       BitSet.new([:yellow, :green], traffic_light_configuration))
+
+            expect(result).to be_a(BitSet)
+            expect(result.configuration).to eql traffic_light_configuration
+            expect(result.to_i).to eql 0b010
+            expect(result).not_to equal bit_set
+          end
+
+          it "should return a copy with only those digits switched to on which are on in both operands (given an Integer)" do
+            bit_set = BitSet.new(0b110, traffic_light_configuration)
+
+            result = bit_set.public_send(method_name, 0b011)
+
+            expect(result).to be_a(BitSet)
+            expect(result.configuration).to eql traffic_light_configuration
+            expect(result.to_i).to eql 0b010
+            expect(result).not_to equal bit_set
+          end
+        end
+      end
+
+      [:symmetric_difference, :^].each do |method_name|
+        describe "##{method_name}" do
+          it "should return a copy with only those digits switched to on which are uniquely enabled in both operands (given a BitSet)" do
+            bit_set = BitSet.new(0b01101, generic_configuration)
+
+            result = bit_set.public_send(method_name,
+                       BitSet.new([:d, :e], generic_configuration))
+
+            expect(result).to be_a(BitSet)
+            expect(result.configuration).to eql generic_configuration
+            expect(result.to_i).to eql 0b01110
+            expect(result).not_to equal bit_set
+          end
+
+          it "should return a copy with only those digits switched to on which are uniquely enabled in both operands (given an Integer)" do
+            bit_set = BitSet.new(0b01101, generic_configuration)
+
+            result = bit_set.public_send(method_name, 0b00011)
+
+            expect(result).to be_a(BitSet)
+            expect(result.configuration).to eql generic_configuration
+            expect(result.to_i).to eql 0b01110
+            expect(result).not_to equal bit_set
+          end
+        end
+      end
+
+      describe "#==" do
+        let(:bit_set) { BitSet.new(0b110, traffic_light_configuration) }
+
+        it "should return true if state and configuration is equal" do
+          expect(bit_set).to eq(BitSet.new(0b110, traffic_light_configuration))
+        end
+
+        it "should return true if state and configuration is equal (different class)" do
+          expect(bit_set).to eq(OpenStruct.new(integer_representation: 0b110, configuration: traffic_light_configuration))
+        end
+
+        it "should return false if state is equal but configuration differs" do
+          expect(bit_set).not_to eq(BitSet.new(0b110, generic_configuration))
+        end
+
+        it "should return false if configuration is equal but state differs" do
+          expect(bit_set).not_to eq(BitSet.new(0b010, traffic_light_configuration))
+        end
+
+        it "should return false if both state and configuration differ" do
+          expect(bit_set).not_to eq(BitSet.new(0b010, generic_configuration))
+        end
+
+        it "should return false if compared to incompatible type" do
+          expect(bit_set).not_to eq(:incompatible)
+        end
+      end
+
+      describe "#eql?" do
+        let(:bit_set) { BitSet.new(0b110, traffic_light_configuration) }
+
+        it "should return true if state and configuration is equal" do
+          expect(bit_set).to eql BitSet.new(0b110, traffic_light_configuration)
+        end
+
+        it "should return false if state and configuration is equal (different class)" do
+          expect(bit_set).not_to eql OpenStruct.new(integer_representation: 0b110, configuration: traffic_light_configuration)
+        end
+
+        it "should return false if state is equal but configuration differs" do
+          expect(bit_set).not_to eql BitSet.new(0b110, generic_configuration)
+        end
+
+        it "should return false if configuration is equal but state differs" do
+          expect(bit_set).not_to eql BitSet.new(0b010, traffic_light_configuration)
+        end
+
+        it "should return false if both state and configuration differ" do
+          expect(bit_set).not_to eql BitSet.new(0b010, generic_configuration)
+        end
+
+        it "should return false if compared to an incompatible object" do
+          expect(bit_set).not_to eql :incompatible
+        end
+      end
+
+      describe "#<=>" do
+        let(:bit_set) { BitSet.new(11, generic_configuration) }
+
+        it "should return -1 if state is lower than that of the compared" do
+          expect(bit_set <=> BitSet.new(12, generic_configuration)).to eql -1
+        end
+
+        it "should return 0 if state is equal to that of the compared" do
+          expect(bit_set <=> BitSet.new(11, generic_configuration)).to eql 0
+        end
+
+        it "should return 1 if state is higher than that of the compared" do
+          expect(bit_set <=> BitSet.new(10, generic_configuration)).to eql 1
+        end
+
+        it "should return nil if configuration differs" do
+          expect(bit_set <=> BitSet.new(11, traffic_light_configuration)).to be_nil
+        end
+
+        it "should return nil if compared to an incompatible object" do
+          expect(bit_set <=> :incompatible).to be_nil
+        end
+
+        it "should make BitSet sortable" do
+          result = [BitSet.new(11, generic_configuration),
+                    BitSet.new(10, generic_configuration),
+                    BitSet.new(12, generic_configuration)].sort
+
+          expect(result).to eql [
+            BitSet.new(10, generic_configuration),
+            BitSet.new(11, generic_configuration),
+            BitSet.new(12, generic_configuration)
+          ]
+        end
+      end
+
+      describe "#hash" do
+        let(:bit_set) { BitSet.new(0b01011, generic_configuration) }
+
+        it "should be stable over multiple calls" do
+          expect(bit_set.hash).to eql bit_set.hash
+        end
+
+        it "should differ if state is equal but configuration differs" do
+          expect(bit_set.hash).not_to eql BitSet.new(0b01011, traffic_light_configuration).hash
+        end
+
+        it "should differ if configuration is equal but state differs" do
+          expect(bit_set.hash).not_to eql BitSet.new(0b00010, generic_configuration).hash
+        end
+
+        it "should differ if both state and configuration differ" do
+          expect(bit_set.hash).not_to eql BitSet.new(0b00010, traffic_light_configuration).hash
+        end
+      end
+
+      describe "#inspect" do
+        it "should return a decent string representation for debugging" do
+          result = BitSet.new(0b011, traffic_light_configuration).inspect
+
+          expect(result).to eql '#<GodObject::BitSet::BitSet: "-yg">'
+        end
+      end
+
+      describe "#to_s" do
+        it "should complain about invalid formats" do
+          expect {
+            BitSet.new(0b00101, generic_configuration).to_s(:medium)
+          }.to raise_error(ArgumentError, "Invalid format: :medium")
+        end
+
+        context "long mode" do
+          it "should by default display every digit as either 0 or 1" do
+            result = BitSet.new(0b00101, generic_configuration).to_s
+
+            expect(result).to eql "00101"
+          end
+
+          it "should display every digit as either it's assigned character or a dash if digits have assigned characters" do
+            result = BitSet.new(0b101, traffic_light_configuration).to_s
+
+            expect(result).to eql "r-g"
+          end
+        end
+
+        context "short mode" do
+          it "should not be available if configuration has no unique characters per digit" do
+            expect {
+              BitSet.new(3, generic_configuration).to_s(:short)
+            }.to raise_error(ArgumentError, 'Short format only available for configurations with unique characters for each digit')
+          end
+
+          it "should only display enabled digits" do
+            result = BitSet.new(0b110, traffic_light_configuration).to_s(:short)
+
+            expect(result).to eql "ry"
+          end
+
+          it "should diplay one dash when no digit is on" do
+            result = BitSet.new(0, traffic_light_configuration).to_s(:short)
+
+            expect(result).to eql "-"
+          end
+        end
+      end
+    end
+
+  end
+end