# Copy/paste of koans assert code
#----------------------------------------------------
FailedAssertionError = Class.new(StandardError)
 
def flunk(msg)
    raise FailedAssertionError, msg
end
 
def assert(condition, msg=nil)
    msg ||= "Failed assertion."
    flunk(msg) unless condition
    true
end
 
def assert_not_equal(expected, actual, msg=nil)
    msg ||= "Expected #{expected.inspect} to not equal #{actual.inspect}"
    assert(expected != actual, msg)
end
#----------------------------------------------------
 
# so for this let's say that you're not modeling dice, you're moding something that returns a randomized set of N
# values for an array, and it's normalized, from [0.0 to 1.0] in value
 
 
# This set always returns [0,0,0,0,...]
class FalsePositiveDiceSet
    attr_reader :values
 
    def roll(numberToRoll)
        #oops, I meant to type rand(1.0)
        @values = Array.new(numberToRoll){Random.rand(1)}
    end
end
 
# This set returns something like [0.12870590894540357, 0.1339125315088633, 0.256765300105959, ...]
class TruePositiveDiceSet
    attr_reader :values
 
    def roll(numberToRoll)
        @values = Array.new(numberToRoll){Random.rand(1.0)}
    end
 
 
end
 
class TrueNegativeDiceSet
    attr_reader :values
 
    def initialize()
        @values = [0.0, 0.0, 0.0]
    end
 
    def roll(numberToRoll)
        #whoops, I forgot to roll
    end
end
 
# false negative implementation
class SingleDiceArrayGoodSet
    attr_reader :values
 
    # Alternative, but still technically valid implementation of the same class.
    # If you knew you only wanted to have one set of dice at a time, per class,
    # you could store the array in a field, and just return the same array every time,
    # though I generally wouldn't recommend this unless you have a good reason to, it's weirder to use.
    def initialize()
        @values = []
    end
 
    def roll(numberToRoll)
        @values.clear
        numberToRoll.times{@values << Random.rand(1.0)}
    end
 
end
 
# test code
#----------------------------------------------------
 
def TestDiceObject(dice)
    dice.roll(3)
    first_time = dice.values
    puts("First roll is #{dice.values}")
    dice.roll(3)
    puts("Second roll is #{dice.values}")
 
    # NOTE: for SingleDiceArrayGoodSet, since it's the same array first_time and second_time are the same array.
    second_time = dice.values
 
    # breaking up the statement into parts
    left = [first_time, first_time.object_id]
    right = [second_time, second_time.object_id]
    puts("first time side of assert is #{left.inspect}")
    puts("second time side of assert is #{right.inspect}")
 
    assert_statement = (left != right)
    puts("Assert statement is: #{assert_statement}")
 
    puts("first_time and second_time object_ids do not match: #{first_time.object_id != second_time.object_id}")
 
    begin
        assert_not_equal [first_time, first_time.object_id], [second_time, second_time.object_id], "Two rolls should not be equal"
    rescue FailedAssertionError => ex
        puts("[NOT OK] This dice set was detected as bad by the unit tests. Assert tripped with error: #{ex.to_s}")
    else
        puts("[OK] The unit tests think this dice set is good!")
    end
 
end
 
puts("True positive dice set:")
puts("-------------------------------------------------------------------------------")
TestDiceObject(TruePositiveDiceSet.new)
puts
puts("True negative dice set:")
puts("-------------------------------------------------------------------------------")
TestDiceObject(TrueNegativeDiceSet.new)
puts
puts("False positive dice set:")
puts("-------------------------------------------------------------------------------")
puts
TestDiceObject(FalsePositiveDiceSet.new)
puts
puts("False Negative SingleDiceArrayGoodSet dice set:")
puts("-------------------------------------------------------------------------------")
puts
TestDiceObject(SingleDiceArrayGoodSet.new)
 
# So as other answers have mentioned, it would be pretty hard to test for this kind of error.
# I'd personally run through the program and read its "random" values for a quick check to make sure something like this didn't happen.

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