Marcel: PT Probeklausur Lösung

# author:: Marcel Hoop

class UngeradeZahl
  
  # get == method and more
  include Comparable
  
  def initialize(number)
    raise ArgumentError, "number not supported" unless number.is_a?(Integer) && number.odd?
    @number = number;
  end
  
  # return next UngeradeZahl
  def succ()
    UngeradeZahl.new(@number + 2)
  end
  
  def <=>(obj)
    return @number <=> obj.get_number if obj.is_a? self.class
    return @number <=> obj if obj.is_a? Numeric
    return nil
  end
  
  def to_s
    @number.to_s
  end
  
  # PROTECTED METHODS
  protected
  
  def get_number
    return @number
  end
    
end

# Testfälle für UngeradeZahl
# Author:: Bernd Kahlbrandt
require 'test/unit'

require_relative 'ungerade_zahl'

class TestUngeradeZahl < Test::Unit::TestCase
  MAX_FIXNUM = 2**30-1
  MIN_FIXNUM = -MAX_FIXNUM - 1
  def setup
  end

  def test_initialize
    assert_equal(1,UngeradeZahl.new(1).instance_variables.length)
    assert_equal(1,UngeradeZahl.new(-1).instance_variables.length)
    assert_equal(UngeradeZahl.new(1),UngeradeZahl.new(1))
    assert_equal(UngeradeZahl.new(-1),UngeradeZahl.new(-1))
    assert_raise(ArgumentError){UngeradeZahl.new(0)}
    assert_raise(ArgumentError){UngeradeZahl.new(2)}
    assert_raise(ArgumentError){UngeradeZahl.new(Math::PI)}
    assert(MAX_FIXNUM.class.is_a?(Fixnum.class))
    assert(MIN_FIXNUM.class.is_a?(Fixnum.class))
  end

  def test_spaceship
    assert_equal(1,UngeradeZahl.new(11)<=>UngeradeZahl.new(7))
    assert_equal(-1,UngeradeZahl.new(-7)<=>UngeradeZahl.new(11))
    assert_equal(0,UngeradeZahl.new(11)<=>UngeradeZahl.new(11))
  end

  def test_succ
    assert_equal(UngeradeZahl.new(1),UngeradeZahl.new(-1).succ)
    assert_equal(UngeradeZahl.new(MAX_FIXNUM+2),UngeradeZahl.new(MAX_FIXNUM).succ)
    assert_equal(UngeradeZahl.new(MIN_FIXNUM + 3),UngeradeZahl.new(MIN_FIXNUM + 1).succ)
  end

  def test_range
    range = UngeradeZahl.new(-1)..UngeradeZahl.new(3)
    assert_equal(2,(UngeradeZahl.new(-1)...UngeradeZahl.new(3)).count)
    assert_equal(3,range.count)
    assert_equal(UngeradeZahl.new(-1),range.min)
    assert_equal(UngeradeZahl.new(3),range.max)
    assert((UngeradeZahl.new(-1)...UngeradeZahl.new(3)).include?(UngeradeZahl.new(1)))
    refute((UngeradeZahl.new(MIN_FIXNUM+1)...UngeradeZahl.new(MIN_FIXNUM+3)).include?(UngeradeZahl.new(43)))
  end

  def test_to_s
    assert(UngeradeZahl.instance_methods(false).include?(:to_s),"Sie haben vergessen, to_s zu überschreiben!")
    assert(UngeradeZahl.new(1).to_s.is_a?(String), "to_s gibt keinen String zurück") if UngeradeZahl.instance_methods(false).include?(:to_s)
  end
end

# author:: Marcel Hoop

# PUBLIC METHODS
public

# check for errors and get the sum from recursiv method
def summe_recursiv(arr)
  check(arr)
  return summe_recursiv_intern(arr)
end

# add all elements to sum with each and return
def summe_each(arr)
  check(arr)
  sum = 0;
  arr.each do |a|
    sum += a
  end
  return sum
end

# methods with Enumerable

# create and return with inject a sum of all elements
def summe_inject(arr)
  check(arr)
  return arr.inject(0,:+)
end

# create and return with reduce a sum of all elements
def summe_reduce(arr)
  check(arr)
  return arr.reduce(0,:+)
end

# methods with different loops

# add all elements to sum with for and return
def summe_for(arr)
  check(arr)
  sum = 0
  for i in 0...arr.length
    sum += arr[i]
  end
  return sum
end

# add all elements to sum with while and return
def summe_while(arr)
  check(arr)
  sum = 0
  i = 0
  while i < arr.length
    sum += arr[i]
    i += 1
  end
  return sum
end

# PRIVATE METHODS
private

# check if array is valid
def check(arr)
  raise ArgumentError, "not enumerable" unless arr.is_a?(Enumerable)
  raise TypeError, "not numeric" unless arr.all? { |a| a.is_a? Numeric }
end

# add and return the sum recursively
def summe_recursiv_intern(arr)
  return 0 if arr.empty?
  return arr.shift + summe_recursiv_intern(arr)
end

# Testfälle für summen.rb
# Author:: Bernd Kahlbrandt
methods_at_start = public_methods
require_relative 'summen'
$methods_to_test =   public_methods - methods_at_start
require 'test/unit'

class TestSummen < Test::Unit::TestCase
  def setup
    @test_empty = []
    @test1 = [1]
    @test_not_enum = 42
    @test_not_num = ["a","b","c"]
    @test_int = [1, 2, 3, 4, 5]
    @test_float = [1.2, 2.3, 4.5, 6.7]
    @test_mixed = [1, 3.1415]
  end

  def test_all
    $methods_to_test.each{|meth| test(meth)}
  end

  def test(meth)
    assert_equal(€(@test_empty),send(meth,@test_empty),meth.to_s)
    assert_equal(€(@test1),send(meth,@test1),meth.to_s)
    assert_equal(€(@test_int),send(meth,@test_int),meth.to_s)
    assert_equal(€(@test_float),send(meth,@test_float),meth.to_s)
    assert_equal(€(@test_mixed),send(meth,@test_mixed),meth.to_s)
    assert_raise(ArgumentError, meth.to_s) {send(meth,@test_not_enum)}
    assert_raise(TypeError, meth.to_s) {send(meth,@test_not_num)}
  end
  # Ρεφερενυιμπλεμντιερθνγ
  private

  def €(_)
    _.reduce(0,:+)
  end
end

# author:: Marcel Hoop

require_relative 'empty_stack_error'

class Stack
  
  # initialize a empty array for stack
  def initialize()
    @arr = []
  end
  
  # return self instead the returned value from @arr.push
  # because it return the array and not the object of our class
  # or because the tests require self as return value
  # raise if parameter is nil
  def push(obj)
    raise ArgumentError, "Sie haben versucht nil einzufügen!" if obj.nil?
    @arr.push(obj)
    return self
  end
  
  # return the last element
  # raise if array is empty
  def peek
    raise EmptyStackError if empty?
    return @arr.last
  end
  
  # pop remove the last element but doesn't return it
  # return the changed object self
  # raise if array is empty
  def pop
    raise EmptyStackError if empty?
    temp = @arr.pop
    return self
  end
  
  # return true or false if array is empty or not
  def empty?
    return @arr.empty?
  end
  
  # return the string from array
  def to_s
    @arr.to_s
  end
  
end

class EmptyStackError < StandardError
  def initialize(msg="obj is empty")
    super
  end
end

# Testfälle für Stack
# Author:: Bernd Kahlbrandt
require 'test/unit'

require_relative 'stack'
require_relative 'empty_stack_error'

class TestStack < Test::Unit::TestCase
  def setup
    @stack_num = Stack.new
    @stack_string = Stack.new
    @stack_mix = Stack.new
  end

  def test_initialize
    @stack_num = Stack.new()
    assert(@stack_num.empty?())
  end

  def test_push
    assert_raise(ArgumentError,"Sie haben versucht nil einzufügen!") {@stack_num.push(nil)}
    refute(@stack_num.push(1).empty?)
  end

  def test_peek
    assert_raise(EmptyStackError){@stack_mix.peek}
    @stack_num.push(1)
    assert_equal(1,@stack_num.peek)
    @stack_mix.push(42).push("08/15")
    assert_equal("08/15",@stack_mix.peek)
  end
  def test_pop
    assert_raise(EmptyStackError){@stack_mix.peek}
    @stack_num.push(1)
    @stack_num.pop
    assert(@stack_num.empty?)
    @stack_mix.push(42).push("08/15")
    refute(@stack_mix.empty?)
  end

  def test_empty
    assert(Stack.new().empty?)
    refute(@stack_num.push(1).empty?)
  end
end