class Turn::TestCase

def count_errors

def count_errors
  sum = 0; tests.each{ |t| sum += 1 if t.error? }; sum
end

def count_failures

def count_failures
  sum = 0; tests.each{ |t| sum += 1 if t.fail? }; sum
end

def count_passes

def count_passes
  sum = 0; tests.each{ |t| sum += 1 if t.pass? }; sum
end

def count_skips

def count_skips
  # Why not use tests.select(&:skip?).size ?
  sum = 0; tests.each{ |t| sum += 1 if t.skip? }; sum
end

def count_tests

def count_tests
  tests.size
end

def counts

def counts
  return count_tests, count_assertions, count_failures, count_errors, count_skips
end

def each(&block)

def each(&block)
  tests.each(&block)
end

def error?

Were there any errors?
def error?
  count_errors != 0
end

def fail?

Were there any failures?
def fail?
  count_failures != 0
end

def initialize(name, *files)

def initialize(name, *files)
  @name  = name
  @files = (files.empty? ? [name] : files)
  @tests = []
  @message = nil
  @count_assertions = 0
  #@count_tests      = 0
  #@count_failures   = 0
  #@count_errors     = 0
  #@command = command
end

def message

def message
  tests.collect{ |t| t.message }.join("\n")
end

def new_test(name)

def new_test(name)
  c = TestMethod.new(name)
  @tests << c
  c
end

def pass?

Did all tests/assertion pass?
def pass?
  not(fail? or error?)
end