Class: TopCoderPythonTester

Inherits:

TopCoderTester

• Object
• TopCoderTester
• TopCoderPythonTester

Defined in:

lib/tcjudge.rb

Instance Method Summary

• #convert_type(type_name) ⇒ Object
• #generate_parameter(type, name, value) ⇒ Object
• #generate_parameters(parameters_string) ⇒ Object
• #generate_primary_value(type, value) ⇒ Object
• #generate_result_comparison_function ⇒ Object
• #generate_result_dumper_function ⇒ Object
• #generate_signature ⇒ Object
• #generate_tester ⇒ Object
• #generate_tester_call ⇒ Object
• #generate_tester_function(index) ⇒ Object
• #generate_timestamp ⇒ Object
• #get_template(template_proc) ⇒ Object
• #initialize(problem_definition, test_cases = nil, tmpdir = nil, code = nil, interpreter = nil) ⇒ TopCoderPythonTester constructor

  A new instance of TopCoderPythonTester.

• #print_points(code) ⇒ Object
• #run(index) ⇒ Object

Methods inherited from TopCoderTester

#convert_seconds_to_points, #perform_cut, #split_parameters

Constructor Details

#initialize(problem_definition, test_cases = nil, tmpdir = nil, code = nil, interpreter = nil) ⇒ TopCoderPythonTester

Returns a new instance of TopCoderPythonTester.

# File 'lib/tcjudge.rb', line 1365

def initialize(problem_definition, test_cases = nil, tmpdir = nil, code = nil, interpreter = nil)
  @problem_definition = problem_definition

  if test_cases != nil && tmpdir != nil && code != nil && interpreter != nil
    @test_cases = test_cases
    @tmpdir = tmpdir

    @tester_source_name = "#{@tmpdir}/tester.py"

    open(@tester_source_name, 'w').write "#{ perform_cut(code) }\n#{ generate_tester() }"

    @interpreter = interpreter
  end
end

Instance Method Details

#convert_type(type_name) ⇒ Object

# File 'lib/tcjudge.rb', line 1256

def convert_type(type_name)
  return type_name
end

#generate_parameter(type, name, value) ⇒ Object

# File 'lib/tcjudge.rb', line 1346

def generate_parameter(type, name, value)
  if type =~ /\[\]$/
    # array
    element_type = type.sub(/\[\]$/, '')
    elements = split_parameters(value[1, value.length - 2])
    parameter = "        #{ name } = [ "
    parameter += elements.map { |element| generate_primary_value(element_type, element) }.join(', ')
    parameter += " ]\n"
    return parameter
  else
    return "        #{ name } = #{ generate_primary_value(type, value) };\n"
  end
end

#generate_parameters(parameters_string) ⇒ Object

# File 'lib/tcjudge.rb', line 1324

def generate_parameters(parameters_string)
  result = ''
  parameters = split_parameters(parameters_string)

  @problem_definition[:parameters].each_with_index do |parameter, index|
    result += generate_parameter(parameter[:type], "param#{index}", parameters[index])
  end

  return result
end

#generate_primary_value(type, value) ⇒ Object

# File 'lib/tcjudge.rb', line 1335

def generate_primary_value(type, value)
  case type
  when 'String'
    return "#{value}"
  when 'long'
    return "#{value}L"
  else
    return value
  end
end

#generate_result_comparison_function ⇒ Object

# File 'lib/tcjudge.rb', line 1282

def generate_result_comparison_function
  func = <<EOS
  def compareResult(self, from_, to_):
EOS
  case @problem_definition[:return_type]
  when 'double'
    func += <<EOS
      return abs(from_ - to_) <= 1e-9
EOS
  when 'double[]'
    func += <<EOS
      return reduce(lambda x, y: x && (abs(y[0] - y[1]) <= 1e-9), zip(from_, to_), True)
EOS
  else
    func += <<EOS
      return from_ == to_
EOS
  end

  return func;
end

#generate_result_dumper_function ⇒ Object

# File 'lib/tcjudge.rb', line 1304

def generate_result_dumper_function
  return "    def dumpResult(self, result_):\n        print result_\n"
end

#generate_signature ⇒ Object

# File 'lib/tcjudge.rb', line 1230

def generate_signature()
  return @problem_definition[:method_name] + '(self, ' + \
    (@problem_definition[:parameters].map { |parameter| parameter[:name] }).join(', ') + ')'
end

#generate_tester ⇒ Object

# File 'lib/tcjudge.rb', line 1260

def generate_tester()
  tester = <<EOS
class Tester:
#{ generate_result_comparison_function() }
#{ generate_result_dumper_function() }
EOS

  @test_cases.length.times do |index|
    tester += generate_tester_function(index)
  end

  tester += <<EOS
import sys

if __name__ == '__main__':
  tester = Tester()
  sys.exit(eval('tester.test' + sys.argv[1] + '()'))
EOS

  return tester
end

#generate_tester_call ⇒ Object

# File 'lib/tcjudge.rb', line 1360

def generate_tester_call
  return "        result = target.#{ @problem_definition[:method_name] }(" +
    (0 .. (@problem_definition[:parameters].length - 1)).map { |index| "param#{ index }" }.join(', ') + ");"
end

#generate_tester_function(index) ⇒ Object

# File 'lib/tcjudge.rb', line 1308

def generate_tester_function(index)
  return <<EOS
  def test#{index}(self):
      target = #{ @problem_definition[:class_name] }();
#{ generate_parameters(@test_cases[index][:input]) }
#{ generate_tester_call() }
#{ generate_parameter(@problem_definition[:return_type], "expected", @test_cases[index][:output]) }
      if self.compareResult(result, expected):
          return 0
      else:
          self.dumpResult(result)
          return 1

EOS
end

#generate_timestamp ⇒ Object

# File 'lib/tcjudge.rb', line 1215

def generate_timestamp
  return "# TIMESTAMP: #{ Time.now.to_i }"
end

#get_template(template_proc) ⇒ Object

# File 'lib/tcjudge.rb', line 1236

def get_template(template_proc)
  if template_proc.nil?
    return <<EOS
# -*- coding: utf-8 -*-

import math,string,itertools,fractions,heapq,collections,re,array,bisect

# CUT begin
#{ generate_timestamp() }
# CUT end

class #{ @problem_definition[:class_name] }:
  def #{ generate_signature() }:

EOS
  else
    return instance_eval(&template_proc)
  end
end

#print_points(code) ⇒ Object

# File 'lib/tcjudge.rb', line 1219

def print_points(code)
  code.match(/^# TIMESTAMP: ([0-9]+)$/) do |backward|
    seconds = Time.now.to_i - backward[1].to_i
    @problem_definition[:points].each_with_index do |total, i|
      points = convert_seconds_to_points(seconds, total)
      warn "Score: #{ sprintf('%.2f', points) } / #{ total } (#{ seconds } secs)"
    end
  end
  return
end

#run(index) ⇒ Object

# File 'lib/tcjudge.rb', line 1380

def run(index)
  tester_options = "#{@interpreter} #{@tester_source_name} #{index}"
  if system(tester_options)
    return :AC
  else
    case $?.exitstatus
    when 1
      return :WA
    else
      if $?.exited?
        return :UNKNOWN_ERROR
      else
        puts "\nCompiller Options: #{ @compile_options }"
        puts "Tester Options: #{tester_options}"
        puts "Exit Status: #{$?}"
        return :RUNTIME_ERROR
      end
    end
  end
end