diff --git a/judge/scripts/config/.gitignore b/judge/scripts/config/.gitignore
new file mode 100644
--- /dev/null
+++ b/judge/scripts/config/.gitignore
@@ -0,0 +1,2 @@
+env*.rb
+
diff --git a/judge/scripts/config/env_exam.rb.SAMPLE b/judge/scripts/config/env_exam.rb.SAMPLE
new file mode 100644
--- /dev/null
+++ b/judge/scripts/config/env_exam.rb.SAMPLE
@@ -0,0 +1,20 @@
+#
+# See documentation in lib/configuration.rb
+#
+Grader::Initializer.run do |config|
+
+  config.problems_dir = GRADER_ROOT + "/../ev"
+  config.user_result_dir = GRADER_ROOT + "/../result"
+  
+  config.talkative = true
+  config.logging = true
+  config.log_dir = GRADER_ROOT + "/../log"
+  
+  config.report_grader = true
+ 
+  config.test_request_input_base_dir = RAILS_ROOT + "/data/test_request/input"
+  config.test_request_output_base_dir = RAILS_ROOT + "/data/test_request/output"
+  config.test_request_problem_templates_dir = config.problems_dir + "/test_request"
+ 
+  config.comment_report_style = :short
+end
diff --git a/judge/scripts/config/env_grading.rb.SAMPLE b/judge/scripts/config/env_grading.rb.SAMPLE
new file mode 100644
--- /dev/null
+++ b/judge/scripts/config/env_grading.rb.SAMPLE
@@ -0,0 +1,19 @@
+#
+# See documentation in lib/configuration.rb
+#
+Grader::Initializer.run do |config|
+  config.problems_dir = GRADER_ROOT + "/../ev"
+  config.user_result_dir = GRADER_ROOT + "/../result"
+  
+  config.talkative = true
+  config.logging = true
+  config.log_dir = GRADER_ROOT + "/../log"
+  
+  config.report_grader = true
+  
+  config.test_request_input_base_dir = RAILS_ROOT + "/data/test_request/input"
+  config.test_request_output_base_dir = RAILS_ROOT + "/data/test_request/output"
+  config.test_request_problem_templates_dir = config.problems_dir + "/test_request"
+ 
+  config.comment_report_style = :full
+end
diff --git a/judge/scripts/config/env_test.rb.SAMPLE b/judge/scripts/config/env_test.rb.SAMPLE
new file mode 100644
--- /dev/null
+++ b/judge/scripts/config/env_test.rb.SAMPLE
@@ -0,0 +1,29 @@
+#
+# See documentation in lib/configuration.rb
+#
+Grader::Initializer.run do |config|
+  config.problems_dir = GRADER_ROOT + "/test/sandbox/ev"
+  config.user_result_dir = GRADER_ROOT + "/test/sandbox/result"
+  
+  config.talkative = false
+  
+  config.report_grader = false
+
+  config.rails_env = 'test'
+  
+  config.comment_report_style = :full
+
+  config.test_request_input_base_dir = GRADER_ROOT + "/test/data/test_request/input"
+  config.test_request_output_base_dir = GRADER_ROOT + "/test/sandbox/test_request/output"
+  config.test_request_problem_templates_dir = GRADER_ROOT + "/test/data/test_request/problems"
+
+  #
+  # These options are for testing
+  #
+  class << config
+    attr_accessor :test_data_dir, :test_sandbox_dir
+  end
+
+  config.test_data_dir = GRADER_ROOT + "/test/data"
+  config.test_sandbox_dir = GRADER_ROOT + "/test/sandbox"
+end
diff --git a/judge/scripts/config/environment.rb.SAMPLE b/judge/scripts/config/environment.rb.SAMPLE
new file mode 100644
--- /dev/null
+++ b/judge/scripts/config/environment.rb.SAMPLE
@@ -0,0 +1,10 @@
+# Rails app directory
+RAILS_ROOT = "/home/jittat/web_grader"
+
+GRADER_ROOT = "/home/jittat/grader/scripts"
+
+# This load all required codes
+require File.join(File.dirname(__FILE__),'../lib/boot')
+
+# load the required environment file
+require File.dirname(__FILE__) + "/env_#{GRADER_ENV}.rb"
diff --git a/judge/scripts/grader b/judge/scripts/grader
new file mode 100755
--- /dev/null
+++ b/judge/scripts/grader
@@ -0,0 +1,217 @@
+#!/usr/bin/ruby
+
+def stop_grader(id)
+  if id==:all
+    File.open(File.dirname(__FILE__) + "/stop.all",'w').close
+  else
+    File.open(File.dirname(__FILE__) + "/stop.#{id}",'w').close
+  end
+end
+
+def check_stopfile
+  FileTest.exist?(File.dirname(__FILE__) + "/stop.all") or
+    FileTest.exist?(File.dirname(__FILE__) + "/stop.#{Process.pid}")
+end
+
+def clear_stopfile
+  if FileTest.exist?(File.dirname(__FILE__) + "/stop.#{Process.pid}")
+    system("rm " + File.dirname(__FILE__) + "/stop.#{Process.pid}")
+  end
+end
+
+def config
+  Grader::Configuration.get_instance
+end
+
+def log_file_name
+  if !File.exists?(config.log_dir)
+    raise "Log directory does not exist: #{config.log_dir}"
+  end
+  config.log_dir + 
+    "/#{GRADER_ENV}_#{config.grader_mode}.#{Process.pid}"
+end
+
+def log(str)
+  if config.talkative
+    puts str
+  end
+  if config.logging
+    fp = File.open(log_file_name,"a")
+    fp.puts("GRADER: #{Time.new.strftime("%H:%M")} #{str}")
+    fp.close
+  end
+end
+
+def display_manual
+  puts <<USAGE
+Grader.
+using: (1) grader 
+       (2) grader environment [mode]
+       (3) grader stop [all|pids-list]
+       (4) grader --help
+(1) call grader with environment = 'exam', mode = 'queue'
+(2) possible modes are: 'queue', 'prob', 'test_request'
+(3) create stop-file to stop running grader in queue mode
+(4) You are here.
+USAGE
+end
+
+#########################################
+# main program
+#########################################
+
+# with --help
+if (ARGV.length==1) and (/help/.match(ARGV[0]))
+  display_manual
+  exit(0)
+end
+
+# reading environment and options
+if (ARGV.length >= 1) and (ARGV[0]=='stop')
+  if ARGV.length==1
+    puts "you should specify pid-list or 'all'"
+    display_manual
+  elsif (ARGV.length==2) and (ARGV[1]=='all')
+    stop_grader(:all)
+    puts "A global stop file ('stop.all') created."
+    puts "You should remove it manually later."
+  else
+    (1..ARGV.length-1).each do |i|
+      stop_grader(ARGV[i])
+    end
+    puts "stop file(s) created"
+  end
+  exit(0)
+end
+
+if check_stopfile
+  puts "Stop file exists.  Terminated."
+  clear_stopfile
+  exit(0)
+end
+
+grader_mode = 'queue'
+if ARGV.length >= 1
+  GRADER_ENV = ARGV[0]
+  if ARGV.length >=2
+    grader_mode = ARGV[1]
+  end
+else
+  GRADER_ENV = 'exam'
+end
+
+puts "environment: #{GRADER_ENV}"
+require File.join(File.dirname(__FILE__),'config/environment')
+
+# add grader_mode to config
+# this is needed because method log needs it.  TODO: clean this up
+class << config
+  attr_accessor :grader_mode
+end
+config.grader_mode = grader_mode
+
+# reading rails environment
+log 'Reading rails environment'
+
+RAILS_ENV = config.rails_env
+require RAILS_ROOT + '/config/environment'
+
+# register grader process
+if config.report_grader
+  grader_proc = GraderProcess.register(config.grader_hostname,
+                                       Process.pid,
+                                       grader_mode)
+else
+  grader_proc = nil
+end
+
+#set loggin environment
+ENV['GRADER_LOGGING'] = log_file_name
+
+# register exit handler to report inactive, and terminated
+at_exit do
+  if grader_proc!=nil
+    grader_proc.report_inactive 
+    grader_proc.terminate
+  end
+end
+
+#
+# MAIN LOOP
+#
+
+case grader_mode
+when "queue", "test_request"
+  log "Grader: #{grader_mode}"
+  if grader_mode=="queue"
+    engine = Grader::Engine.new
+  else
+    engine = Grader::Engine.new(Grader::TestRequestRoomMaker.new,
+                                Grader::TestRequestReporter.new)
+  end
+
+  runner = Grader::Runner.new(engine, grader_proc)
+  while true
+    
+    if check_stopfile    # created by calling grader stop
+      clear_stopfile
+      log "stopped (with stop file)"
+      break
+    end
+    
+    if grader_mode=="queue"
+      task = runner.grade_oldest_task
+    else
+      task = runner.grade_oldest_test_request
+    end
+    if task==nil
+      sleep(1)
+    end
+  end
+  
+when "prob"
+  engine = Grader::Engine.new
+  runner = Grader::Runner.new(engine, grader_proc)
+
+  grader_proc.report_active if grader_proc!=nil
+
+  ARGV.shift
+  ARGV.shift
+
+  ARGV.each do |prob_name|
+    prob = Problem.find_by_name(prob_name)
+    if prob==nil
+      puts "cannot find problem: #{prob_name}"
+    else
+      runner.grade_problem(prob)
+    end
+  end
+
+when "sub"
+  engine = Grader::Engine.new
+  runner = Grader::Runner.new(engine, grader_proc)
+
+  grader_proc.report_active if grader_proc!=nil
+
+  ARGV.shift
+  ARGV.shift
+
+  ARGV.each do |sub_id|
+    puts "Grading #{sub_id}"
+    begin
+      submission = Submission.find(sub_id.to_i)
+    rescue ActiveRecord::RecordNotFound
+      puts "Record not found"
+      submission = nil
+    end
+
+    if submission!=nil
+      runner.grade_submission(submission)
+    end
+  end
+
+else
+  display_manual
+  exit(0)
+end
+
diff --git a/judge/scripts/grader_id b/judge/scripts/grader_id
new file mode 100755
--- /dev/null
+++ b/judge/scripts/grader_id
@@ -0,0 +1,110 @@
+#!/usr/bin/ruby
+
+def talk(str)
+  if TALKATIVE
+    puts str
+  end
+end
+
+def execute(command, error_message="")
+  if not system(command)
+    puts "ERROR: #{error_message}"
+    exit(127)
+  end
+end
+
+def save_source(submission,dir,fname)
+  f = File.open("#{dir}/#{fname}","w")
+  f.write(submission.source)
+  f.close
+end
+
+def call_judge(problem_home,language,problem_out_dir,fname)
+  ENV['PROBLEM_HOME'] = problem_home
+  Dir.chdir problem_out_dir
+  cmd = "#{problem_home}/script/judge #{language} #{fname}"
+#  puts "CMD: #{cmd}"
+  system(cmd)
+end
+
+def read_result(test_result_dir)
+  cmp_msg_fname = "#{test_result_dir}/compiler_message"
+  cmp_msg = File.open(cmp_msg_fname).read
+
+  result_fname = "#{test_result_dir}/result"
+  comment_fname = "#{test_result_dir}/comment"  
+  if FileTest.exist?(result_fname)
+    result = File.open(result_fname).readline.to_i
+    comment = File.open(comment_fname).readline.chomp
+    return {:points => result, 
+      :comment => comment, 
+      :cmp_msg => cmp_msg}
+  else
+    return {:points => 0,
+      :comment => 'compile error',
+      :cmp_msg => cmp_msg}
+  end
+end
+
+def save_result(submission,result)
+  submission.graded_at = Time.now
+  submission.points = result[:points]
+  submission.grader_comment = report_comment(result[:comment])
+  submission.compiler_message = result[:cmp_msg]
+  submission.save
+end
+
+def grade(submission_id)
+  sub = Submission.find(submission_id)
+  user = sub.user
+  problem = sub.problem
+
+  language = sub.language.name
+  lang_ext = sub.language.ext
+  # FIX THIS
+  talk 'some hack on language'
+  if language == 'cpp'
+    language = 'c++'
+  end
+
+  user_dir = "#{USER_RESULT_DIR}/#{user.login}"
+  Dir.mkdir(user_dir) if !FileTest.exist?(user_dir)
+  
+  problem_out_dir = "#{user_dir}/#{problem.name}"
+  Dir.mkdir(problem_out_dir) if !FileTest.exist?(problem_out_dir)
+
+  problem_home = "#{PROBLEMS_DIR}/#{problem.name}"
+  source_name = "#{problem.name}.#{lang_ext}"
+
+  save_source(sub,problem_out_dir,source_name)
+  call_judge(problem_home,language,problem_out_dir,source_name)
+  save_result(sub,read_result("#{problem_out_dir}/test-result"))
+end
+
+def stop_grader
+  File.open(File.dirname(__FILE__) + '/stop','w')
+end
+
+def check_stopfile
+  FileTest.exist?(File.dirname(__FILE__) + '/stop')
+end
+
+def clear_stopfile
+  system("rm " + File.dirname(__FILE__) + '/stop')
+end
+
+# reading environment and options
+GRADER_ENV = 'exam'
+puts "environment: #{GRADER_ENV}"
+require File.dirname(__FILE__) + "/environment.rb"
+
+#main program
+talk 'Reading rails environment'
+
+RAILS_ENV = 'development'
+require RAILS_APP_DIR + '/config/environment'
+
+current_dir = `pwd`
+grade(ARGV[0].to_i)
+
+
diff --git a/judge/scripts/import_problem b/judge/scripts/import_problem
new file mode 100755
--- /dev/null
+++ b/judge/scripts/import_problem
@@ -0,0 +1,164 @@
+#!/usr/bin/ruby
+
+# import_problem:
+#  * creates a directory for a problem in the current directory,
+#  * copy testdata in the old format and create standard testcase config file
+
+require 'erb'
+require 'fileutils'
+require File.join(File.dirname(__FILE__),'lib/import_helper')
+
+def input_filename(dir,i)
+  "#{dir}/input-#{i}.txt"
+end
+
+def answer_filename(dir,i)
+  "#{dir}/answer-#{i}.txt"
+end
+
+def build_testrun_info_from_dir(num_testruns,importing_test_dir)
+  filenames = Dir["#{importing_test_dir}/*.in"].collect do |filename|
+    File.basename((/(.*)\.in/.match(filename))[1])
+  end
+  build_testrun_info(num_testruns,filenames)
+end
+
+def copy_testcase(importing_test_dir,fname,dir,i)
+  system("cp #{importing_test_dir}/#{fname}.in #{input_filename(dir,i)}")
+  system("cp #{importing_test_dir}/#{fname}.sol #{answer_filename(dir,i)}")
+end
+
+def process_options(options)
+  i = 4
+  while i<ARGV.length
+    if ARGV[i]=='-t'
+      options[:time_limit] = ARGV[i+1].to_f if ARGV.length>i+1
+      i += 1
+    end
+    if ARGV[i]=='-m'
+      options[:mem_limit] = ARGV[i+1].to_i if ARGV.length>i+1
+      i += 1
+    end
+    i += 1
+  end
+end
+
+SCRIPT_DIR = File.dirname(__FILE__)
+
+# print usage
+if (ARGV.length < 4) or (ARGV[3][0,1]=="-")
+  puts <<USAGE
+using: import_problem name dir num check [options]
+   where: name = problem_name (put '-' (dash) to use dir name)
+          dir = importing testcase directory
+          num = number of testruns
+          check = check script, which can be 
+                   'integer', 'text' (for standard script), 
+                   path_to_your_script, or
+                   'wrapper:(path_to_your_wrapped_script)'
+   options: -t time-limit (in seconds)
+            -m memory-limit (in megabytes)
+What it does:
+  * creates a directory for a problem in the current directory,
+  * copies testdata in the old format and create standard testcase config file
+  * copies a check script for grading
+  * creates a test_request template in the current directory + '/test_request'
+
+For wrapped checked script see comment in templates/check_wrapper for
+  information.
+USAGE
+  exit(127)
+end
+
+# processing arguments
+problem = ARGV[0]
+testcase_dir = ARGV[1]
+problem = File.basename(testcase_dir) if problem=="-"
+num_testruns = ARGV[2].to_i
+check_script = ARGV[3]
+options = {:time_limit => 1,  :mem_limit => 16}
+process_options(options)
+
+testrun_info = build_testrun_info_from_dir(num_testruns, testcase_dir)
+
+# start working
+puts "creating directories"
+
+system("mkdir #{problem}")
+system("mkdir #{problem}/script")
+system("mkdir #{problem}/test_cases")
+#system("cp #{GRADER_DIR}/std-script/* #{problem}/script")
+
+puts "copying testcases"
+
+tr_num = 0
+
+num_testcases = 0
+
+testrun_info.each do |testrun|
+  tr_num += 1
+  puts "testrun: #{tr_num}"
+
+  testrun.each do |testcase_info|
+    testcase_num, testcase_fname = testcase_info
+
+    puts "copy #{testcase_fname} to #{testcase_num}"
+
+    system("mkdir #{problem}/test_cases/#{testcase_num}")
+    copy_testcase("#{testcase_dir}",testcase_fname,"#{problem}/test_cases/#{testcase_num}",testcase_num)
+
+    num_testcases += 1
+  end
+end
+
+# generating all_tests.cfg
+puts "generating testcase config file"
+
+template = File.open(SCRIPT_DIR + "/templates/all_tests.cfg.erb").read
+all_test_cfg = ERB.new(template)
+
+cfg_file = File.open("#{problem}/test_cases/all_tests.cfg","w")
+cfg_file.puts all_test_cfg.result
+cfg_file.close
+
+
+# copy check script
+if res = /^wrapper:(.*)$/.match(check_script)
+  # wrapper script
+  check_script_fname = res[1]
+  script_name = File.basename(check_script_fname)
+  check_wrapper_template = File.open(SCRIPT_DIR + "/templates/check_wrapper").read
+  check_wrapper = ERB.new(check_wrapper_template)
+
+  check_file = File.open("#{problem}/script/check","w")
+  check_file.puts check_wrapper.result
+  check_file.close
+
+  File.chmod(0755,"#{problem}/script/check")
+
+  system("cp #{check_script_fname} #{problem}/script/#{script_name}")
+else
+  if File.exists?(SCRIPT_DIR + "/templates/check.#{check_script}")
+    check_script_fname = SCRIPT_DIR + "/templates/check.#{check_script}"
+  else
+    check_script_fname = check_script
+  end
+  system("cp #{check_script_fname} #{problem}/script/check")
+end
+
+# generating test_request directory
+puts "generating test_request template"
+FileUtils.mkdir_p("test_request/#{problem}/script")
+FileUtils.mkdir_p("test_request/#{problem}/test_cases/1")
+
+template = File.open(SCRIPT_DIR + "/templates/test_request_all_tests.cfg.erb").read
+test_request_all_test_cfg = ERB.new(template)
+
+cfg_file = File.open("test_request/#{problem}/test_cases/all_tests.cfg","w")
+cfg_file.puts test_request_all_test_cfg.result
+cfg_file.close
+
+system("cp #{SCRIPT_DIR}/templates/check_empty test_request/#{problem}/script/check")
+system("cp #{SCRIPT_DIR}/templates/answer-1.txt test_request/#{problem}/test_cases/1")
+
+puts "done"
diff --git a/judge/scripts/lib/boot.rb b/judge/scripts/lib/boot.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/lib/boot.rb
@@ -0,0 +1,10 @@
+
+require File.join(File.dirname(__FILE__), 'configuration')
+require File.join(File.dirname(__FILE__), 'initializer')
+
+require File.join(File.dirname(__FILE__), 'submission_helper')
+require File.join(File.dirname(__FILE__), 'test_request_helper')
+
+require File.join(File.dirname(__FILE__), 'engine')
+require File.join(File.dirname(__FILE__), 'runner')
+
diff --git a/judge/scripts/lib/configuration.rb b/judge/scripts/lib/configuration.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/lib/configuration.rb
@@ -0,0 +1,84 @@
+module Grader
+
+  # This singleton class holds basic configurations for grader.  When
+  # running in each mode, grader uses resources from different
+  # directories and outputs differently.  Usually the attributes name
+  # are descriptive; below we explain more on each attributes.
+  class Configuration
+    # Rails' environment: "development", "production"
+    attr_accessor :rails_env
+
+    # Grader looks for problem [prob] in problem_dir/[prob], and store
+    # execution results for submission [x] of user [u] in directory
+    # user_result_dir/[u]/[x]
+    attr_accessor :problems_dir
+    attr_accessor :user_result_dir
+
+    # If report_grader=true, the grader would add a row in model
+    # GraderProcess.  It would report itself with grader_hostname and
+    # process id.
+    attr_accessor :report_grader
+    attr_accessor :grader_hostname    
+
+    # If talkative=true, grader would report status to console.  If
+    # logging=true, grader would report status to a log file located
+    # in log_dir, in a file name mode.options.pid.  TODO: defined
+    # log file naming.
+    attr_accessor :talkative
+    attr_accessor :logging
+    attr_accessor :log_dir
+
+    # These are directories related to the test interface.
+    attr_accessor :test_request_input_base_dir
+    attr_accessor :test_request_output_base_dir
+    attr_accessor :test_request_problem_templates_dir
+
+    # Comment received from the grading script will be filtered
+    # through Configuration#report_comment.  How this method behave
+    # depends on this option; right now only two formats, :short and
+    # :long
+    attr_accessor :comment_report_style
+
+    def report_comment(comment)
+      case comment_report_style
+      when :short
+        if comment.chomp =~ /^[\[\]P]+$/    # all P's
+          'passed'
+        elsif comment.chomp =~ /[Cc]ompil.*[Ee]rror/
+          'compilation error'
+        else
+          'failed'
+        end
+        
+      when :full
+        comment.chomp
+      end
+    end
+
+    # Codes for singleton
+    private_class_method :new
+
+    @@instance = nil
+
+    def self.get_instance
+      if @@instance==nil
+        @@instance = new
+      end
+      @@instance
+    end
+    
+    private
+    def initialize
+      @talkative = false
+      @log_file = nil
+      @report_grader = false
+      @grader_hostname = `hostname`.chomp
+
+      @rails_env = 'development'
+      
+      @comment_report_style = :full
+    end
+
+  end
+
+end
diff --git a/judge/scripts/lib/engine.rb b/judge/scripts/lib/engine.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/lib/engine.rb
@@ -0,0 +1,138 @@
+require 'fileutils'
+
+module Grader
+
+  #
+  # A grader engine grades a submission, against anything: a test
+  # data, or a user submitted test data.  It uses two helpers objects:
+  # room_maker and reporter.
+  #
+  class Engine
+    
+    attr_writer :room_maker
+    attr_writer :reporter
+
+    def initialize(room_maker=nil, reporter=nil)
+      @config = Grader::Configuration.get_instance
+
+      @room_maker = room_maker || Grader::SubmissionRoomMaker.new 
+      @reporter = reporter || Grader::SubmissionReporter.new
+    end
+    
+    # takes a submission, asks room_maker to produce grading directories,
+    # calls grader scripts, and asks reporter to save the result
+    def grade(submission)
+      current_dir = `pwd`.chomp
+
+      user = submission.user
+      problem = submission.problem
+
+      # TODO: will have to create real exception for this
+      if user==nil or problem == nil
+        @reporter.report_error(submission,"Grading error: problem with submission")
+        #raise "engine: user or problem is nil"
+      end
+
+      # TODO: this is another hack so that output only task can be judged
+      if submission.language!=nil
+        language = submission.language.name
+        lang_ext = submission.language.ext
+      else
+        language = 'c'
+        lang_ext = 'c'
+      end
+
+      # FIX THIS
+      talk 'some hack on language'
+      if language == 'cpp'
+        language = 'c++'
+      end
+
+      # COMMENT: should it be only source.ext?
+      if problem!=nil
+        source_name = "#{problem.name}.#{lang_ext}"
+      else
+        source_name = "source.#{lang_ext}"
+      end
+
+      begin
+        grading_dir = @room_maker.produce_grading_room(submission)
+        @room_maker.save_source(submission,source_name)
+        problem_home = @room_maker.find_problem_home(submission)
+
+        # puts "GRADING DIR: #{grading_dir}"
+        # puts "PROBLEM DIR: #{problem_home}"
+
+        copy_log = copy_script(problem_home)
+      
+        call_judge(problem_home,language,grading_dir,source_name)
+
+        @reporter.report(submission,"#{grading_dir}/test-result")
+
+        clear_script(copy_log,problem_home)
+
+      rescue RuntimeError => msg
+        @reporter.report_error(submission,"Grading error: #{msg}")
+
+      ensure
+        @room_maker.clean_up(submission)
+        Dir.chdir(current_dir)   # this is really important
+      end
+    end
+    
+    protected
+    
+    def talk(str)
+      if @config.talkative
+        puts str
+      end
+    end
+
+    def call_judge(problem_home,language,grading_dir,fname)
+      ENV['PROBLEM_HOME'] = problem_home
+      
+      talk grading_dir
+      Dir.chdir grading_dir
+      cmd = "#{problem_home}/script/judge #{language} #{fname}"
+      talk "CMD: #{cmd}"
+      system(cmd)
+    end
+
+    def get_std_script_dir
+      GRADER_ROOT + '/std-script'
+    end
+
+    def copy_script(problem_home)
+      script_dir = "#{problem_home}/script"
+      std_script_dir = get_std_script_dir
+
+      raise "std-script directory not found" if !FileTest.exist?(std_script_dir)
+
+      scripts = Dir[std_script_dir + '/*']
+      
+      copied = []
+
+      scripts.each do |s|
+        fname = File.basename(s)
+        if !FileTest.exist?("#{script_dir}/#{fname}")
+          copied << fname
+          system("cp #{s} #{script_dir}")
+        end
+      end
+      
+      return copied
+    end
+    
+    def clear_script(log,problem_home)
+      log.each do |s|
+        system("rm #{problem_home}/script/#{s}")
+      end
+    end
+
+    def mkdir_if_does_not_exist(dirname)
+      Dir.mkdir(dirname) if !FileTest.exist?(dirname)
+    end
+    
+  end
+  
+end
diff --git a/judge/scripts/lib/import_helper.rb b/judge/scripts/lib/import_helper.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/lib/import_helper.rb
@@ -0,0 +1,28 @@
+
+def filter_filename_for_testrun(testrun, filename_list)
+  l = []
+  regex = Regexp.new("^(#{testrun}[a-z]*|#{testrun}-.*)$")
+  filename_list.each do |filename|
+    if regex.match(filename)
+      l << filename
+    end
+  end
+  l
+end
+
+def build_testrun_info(num_testruns, input_filename_list)
+  info = []
+  num_testcases = 0
+  num_testruns.times do |i|
+    r = i+1
+    testrun_info = []
+    filenames = filter_filename_for_testrun(r, input_filename_list)
+    filenames.each do |fname|
+      num_testcases += 1
+      testrun_info << [num_testcases,fname]
+    end
+    info << testrun_info
+  end
+  info
+end
+
diff --git a/judge/scripts/lib/initializer.rb b/judge/scripts/lib/initializer.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/lib/initializer.rb
@@ -0,0 +1,13 @@
+
+module Grader
+
+  class Initializer
+
+    def self.run(&block)
+      config = Grader::Configuration.get_instance
+      yield config
+    end
+
+  end
+
+end
diff --git a/judge/scripts/lib/runner.rb b/judge/scripts/lib/runner.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/lib/runner.rb
@@ -0,0 +1,58 @@
+#
+# A runner drives the engine into various tasks.
+# 
+
+module Grader
+
+  class Runner
+
+    def initialize(engine, grader_process=nil)
+      @engine = engine
+      @grader_process = grader_process
+    end
+
+    def grade_oldest_task
+      task = Task.get_inqueue_and_change_status(Task::STATUS_GRADING)
+      if task!=nil 
+        @grader_process.report_active(task) if @grader_process!=nil
+        
+        submission = Submission.find(task.submission_id)
+        @engine.grade(submission)
+        task.status_complete!
+        @grader_process.report_inactive(task) if @grader_process!=nil
+      end
+      return task
+    end
+
+    def grade_problem(problem)
+      users = User.find(:all)
+      users.each do |u|
+        puts "user: #{u.login}"
+        last_sub = Submission.find_last_by_user_and_problem(u.id,problem.id)
+        if last_sub!=nil
+          @engine.grade(last_sub)
+        end
+      end
+    end
+
+    def grade_submission(submission)
+      puts "Submission: #{submission.id} by #{submission.user.full_name}"
+      @engine.grade(submission)
+    end
+
+    def grade_oldest_test_request
+      test_request = TestRequest.get_inqueue_and_change_status(Task::STATUS_GRADING)
+      if test_request!=nil 
+        @grader_process.report_active(test_request) if @grader_process!=nil
+        
+        @engine.grade(test_request)
+        test_request.status_complete!
+        @grader_process.report_inactive(test_request) if @grader_process!=nil
+      end
+      return test_request
+    end
+
+  end
+
+end
+
diff --git a/judge/scripts/lib/submission_helper.rb b/judge/scripts/lib/submission_helper.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/lib/submission_helper.rb
@@ -0,0 +1,123 @@
+module Grader
+
+  class SubmissionRoomMaker
+    def initialize
+      @config = Grader::Configuration.get_instance
+    end
+    
+    def produce_grading_room(submission)
+      user = submission.user
+      problem = submission.problem
+      grading_room = "#{@config.user_result_dir}/" + 
+        "#{user.login}/#{problem.name}/#{submission.id}"
+      
+      FileUtils.mkdir_p(grading_room)
+      grading_room
+    end
+    
+    def find_problem_home(submission)
+      problem = submission.problem
+      "#{@config.problems_dir}/#{problem.name}"
+    end
+
+    def save_source(submission,source_name)
+      dir = self.produce_grading_room(submission)
+      f = File.open("#{dir}/#{source_name}","w")
+      f.write(submission.source)
+      f.close
+    end
+
+    def clean_up(submission)
+    end
+  end
+  
+  class SubmissionReporter
+    def initialize
+      @config = Grader::Configuration.get_instance
+    end
+    
+    def report(sub,test_result_dir)
+      save_result(sub,read_result(test_result_dir))
+    end
+    
+    def report_error(sub,msg)
+      save_result(sub,{:points => 0,
+                    :comment => "Grading error: #{msg}" })
+    end
+
+    protected
+    def read_result(test_result_dir)
+      cmp_msg_fname = "#{test_result_dir}/compiler_message"
+      if FileTest.exist?(cmp_msg_fname)
+        cmp_file = File.open(cmp_msg_fname)
+        cmp_msg = cmp_file.read
+        cmp_file.close
+      else
+        cmp_msg = ""
+      end
+      
+      result_fname = "#{test_result_dir}/result"
+      comment_fname = "#{test_result_dir}/comment"  
+      if FileTest.exist?(result_fname)
+        comment = ""
+        begin
+          result_file = File.open(result_fname)
+          result = result_file.readline.to_i
+          result_file.close
+        rescue
+          result = 0
+          comment = "error reading result file."
+        end
+          
+        begin
+          comment_file = File.open(comment_fname)
+          comment += comment_file.readline.chomp
+          comment_file.close
+        rescue
+          comment += ""
+        end
+
+        return {:points => result, 
+          :comment => comment, 
+          :cmp_msg => cmp_msg}
+      else
+        if FileTest.exist?("#{test_result_dir}/a.out")
+          return {:points => 0,
+            :comment => 'error during grading',
+            :cmp_msg => cmp_msg}
+        else
+          return {:points => 0,
+            :comment => 'compilation error',
+            :cmp_msg => cmp_msg}
+        end
+      end
+    end
+    
+    def save_result(submission,result)
+      problem = submission.problem
+      submission.graded_at = Time.now.gmtime
+      points = result[:points]
+      submission.points = points
+      comment = @config.report_comment(result[:comment])
+
+      #
+      # TODO: FIX THIS MESSAGE
+      #
+      if problem == nil
+        submission.grader_comment = 'PASSED: ' + comment + '(problem is nil)'
+      elsif points == problem.full_score
+        #submission.grader_comment = 'PASSED: ' + comment
+        submission.grader_comment = comment
+      elsif result[:comment].chomp =~ /^[\[\]P]+$/
+        submission.grader_comment = 'PASSED: ' + comment + '(inconsistent score)'
+      else
+        #submission.grader_comment = 'FAILED: ' + comment
+        submission.grader_comment = comment
+      end
+      submission.compiler_message = result[:cmp_msg] or ''
+      submission.save
+    end
+    
+  end
+  
+end
diff --git a/judge/scripts/lib/test_request_helper.rb b/judge/scripts/lib/test_request_helper.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/lib/test_request_helper.rb
@@ -0,0 +1,242 @@
+#
+# This part contains various test_request helpers for interfacing
+# with Grader::Engine.  There are TestRequestRoomMaker and
+# TestRequestReporter.
+
+module Grader
+
+  #
+  # A TestRequestRoomMaker is a helper object for Engine
+  # - finds grading room: in user_result_dir/(user)/test_request/ ...
+  # - prepare problem configuration for grading --- basically it copy
+  #   all config files, and copy user's input into the testcase
+  #   directory.  First, it finds the template from problem template
+  #   directory; if it can't find a template, it'll use the template
+  #   from default template.
+  class TestRequestRoomMaker
+    def initialize
+      @config = Grader::Configuration.get_instance
+    end
+    
+    def produce_grading_room(test_request)
+      grading_room = grading_room_dir(test_request)
+      FileUtils.mkdir_p(grading_room)
+
+      #
+      # Also copy additional submitted file to this directory as well.
+      # The program would see this file only if it is copied
+      #    to the sandbox directory later.  The run script should do it.
+      #
+      if FileTest.exists?("#{test_request.input_file_name}.files")
+        cmd = "cp #{test_request.input_file_name}.files/* #{grading_room}"
+        system(cmd)
+      end
+
+      grading_room
+    end
+    
+    def find_problem_home(test_request)
+      problem_name = test_request.problem_name
+
+      template_dir = "#{@config.test_request_problem_templates_dir}/" + problem_name
+
+      raise "Test Request: error template not found" if !File.exists?(template_dir)
+      
+      problem_home = problem_home_dir(test_request)
+      FileUtils.mkdir_p(problem_home)
+      
+      copy_problem_template(template_dir,problem_home)
+      link_input_file(test_request,problem_home)
+
+      problem_home
+    end
+    
+    def save_source(test_request,source_name)
+      dir = self.produce_grading_room(test_request)
+      submission = test_request.submission
+      f = File.open("#{dir}/#{source_name}","w")
+      f.write(submission.source)
+      f.close
+    end
+    
+    def clean_up(test_request)
+      problem_home = problem_home_dir(test_request)
+      remove_data_files(problem_home)
+    end
+    
+    protected
+    def grading_room_dir(test_request)
+      problem_name = test_request.problem_name
+      user = test_request.user
+      grading_room = "#{@config.user_result_dir}" + 
+        "/#{user.login}/test_request" +
+        "/#{problem_name}/#{test_request.id}"
+      grading_room
+    end
+    
+    def problem_home_dir(test_request)
+      problem_name = test_request.problem_name
+      user = test_request.user
+      "#{@config.user_result_dir}" + 
+        "/#{user.login}/test_request/#{problem_name}"
+    end
+    
+    def copy_problem_template(template_dir,problem_home)
+      cmd = "cp -R #{template_dir}/* #{problem_home}"
+      system_and_raise_when_fail(cmd,"Test Request: cannot copy problem template")
+    end
+    
+    def link_input_file(test_request,problem_home)
+      input_fname = "#{test_request.input_file_name}"
+      if !File.exists?(input_fname)
+        raise "Test Request: input file not found."
+      end
+
+      input_fname_problem_home = "#{problem_home}/test_cases/1/input-1.txt"
+      if File.exists?(input_fname_problem_home)
+        FileUtils.rm([input_fname_problem_home], :force => true)
+      end
+
+      cmd = "ln -s #{input_fname} #{input_fname_problem_home}" 
+      system_and_raise_when_fail(cmd,"Test Request: cannot link input file")
+    end
+    
+    def remove_data_files(problem_home)
+      if File.exists?("#{problem_home}/test_cases/1/input-1.txt")
+        cmd = "rm #{problem_home}/test_cases/1/*"
+        system_and_raise_when_fail(cmd,"Test Request: cannot remove data files")
+      end
+    end
+    
+    def system_and_raise_when_fail(cmd,msg)
+      if !system(cmd)
+        raise msg
+      end
+    end
+    
+  end
+  
+  class TestRequestReporter
+    def initialize
+      @config = Grader::Configuration.get_instance
+    end
+    
+    def report(test_request,test_result_dir)
+      save_result(test_request,read_result(test_result_dir))
+    end
+
+    def report_error(test_request, msg)
+      save_result(test_request, {:running_stat => {
+                      :msg => "#{msg}",
+                      :running_time => nil,
+                      :exit_status => "Some error occured. Program did not run",
+                      :memory_usage => nil
+                    }})
+    end
+    
+    protected
+    def read_result(test_result_dir)
+      # TODO:
+      cmp_msg_fname = "#{test_result_dir}/compiler_message"
+      cmp_file = File.open(cmp_msg_fname)
+      cmp_msg = cmp_file.read
+      cmp_file.close
+      
+      result_file_name = "#{test_result_dir}/1/result"
+
+      if File.exists?(result_file_name)
+        output_file_name = "#{test_result_dir}/1/output.txt"
+        results = File.open("#{test_result_dir}/1/result").readlines
+        stat = extract_running_stat(results)
+
+        return {
+          :output_file_name => output_file_name,
+          :running_stat => stat,
+          :comment => "", 
+          :cmp_msg => cmp_msg}
+      else
+        return {
+          :running_stat => nil,
+          :comment => "Compilation error", 
+          :cmp_msg => cmp_msg}
+      end
+    end
+
+    def extract_running_stat(results)
+      running_stat_line = results[-1]
+
+      # extract exit status line
+      run_stat = ""
+      if !(/[Cc]orrect/.match(results[0]))
+        run_stat = results[0].chomp
+      else
+        run_stat = 'Program exited normally'
+      end
+
+      # extract running time
+      if res = /r(.*)u(.*)s/.match(running_stat_line)
+        seconds = (res[1].to_f + res[2].to_f)
+        time_stat = "Time used: #{seconds} sec."
+      else
+        seconds = nil
+        time_stat = "Time used: n/a sec."
+      end
+
+      # extract memory usage
+      if res = /s(.*)m/.match(running_stat_line)
+        memory_used = res[1].to_i
+      else
+        memory_used = -1
+      end
+
+      return {
+        :msg => "#{run_stat}\n#{time_stat}",
+        :running_time => seconds,
+        :exit_status => run_stat,
+        :memory_usage => memory_used
+      }
+    end
+    
+    def save_result(test_request,result)
+      if result[:output_file_name]!=nil
+        test_request.output_file_name = link_output_file(test_request,
+                                                         result[:output_file_name])
+      end
+      test_request.graded_at = Time.now
+      test_request.compiler_message = (result[:cmp_msg] or '')
+      test_request.grader_comment = (result[:comment] or '')
+      if result[:running_stat]!=nil
+        test_request.running_stat = (result[:running_stat][:msg] or '')
+        test_request.running_time = (result[:running_stat][:running_time] or nil)
+        test_request.exit_status = result[:running_stat][:exit_status]
+        test_request.memory_usage = result[:running_stat][:memory_usage]
+      else
+        test_request.running_stat = ''
+      end
+      test_request.save
+    end
+    
+    protected
+    def link_output_file(test_request, fname)
+      target_file_name = random_output_file_name(test_request.user,
+                                                 test_request.problem)
+      FileUtils.mkdir_p(File.dirname(target_file_name))
+      cmd = "ln -s #{fname} #{target_file_name}"
+      if !system(cmd)
+        raise "TestRequestReporter: cannot move output file"
+      end
+      return target_file_name
+    end
+
+    def random_output_file_name(user,problem)
+      problem_name = TestRequest.name_of(problem)
+      begin
+        tmpname =  "#{@config.test_request_output_base_dir}" +
+          "/#{user.login}/#{problem_name}/#{rand(10000)}"
+      end while File.exists?(tmpname)
+      tmpname
+    end
+
+  end
+  
+end
diff --git a/judge/scripts/new_problem b/judge/scripts/new_problem
new file mode 100755
--- /dev/null
+++ b/judge/scripts/new_problem
@@ -0,0 +1,73 @@
+#!/usr/bin/ruby
+
+# new_problem:
+#  * creates a directory for a problem in the current directory,
+#  * create standard testcase config file
+
+require 'erb'
+
+def process_options(options)
+  i = 2
+  while i<ARGV.length
+    if ARGV[i]=='-t'
+      options[:time_limit] = ARGV[i+1].to_i if ARGV.length>i+1
+      i += 1
+    end
+    if ARGV[i]=='-m'
+      options[:mem_limit] = ARGV[i+1].to_i if ARGV.length>i+1
+      i += 1
+    end
+    i += 1
+  end
+end
+
+
+puts "This script is out of dated, shall be fixed soon"
+puts "Right now, you can create raw_ev and import"
+exit(0)
+
+GRADER_DIR = File.dirname(__FILE__)
+
+# print usage
+if ARGV.length < 2
+  puts <<USAGE 
+using: new_problem problem number_of_testcase [options]
+* creates a directory for a problem in the current directory,
+* create standard testcase config file
+* options: -t time-limit (in seconds)
+           -m mem-limit (in MB)
+USAGE
+  exit(127)
+end
+
+# processing arguments
+problem = ARGV[0]
+num_testcases = ARGV[1].to_i
+
+options = {:time_limit => 1,  :mem_limit => 16}
+process_options(options)
+
+# start working
+puts "creating directories"
+
+system("mkdir #{problem}")
+system("mkdir #{problem}/script")
+system("mkdir #{problem}/test_cases")
+
+puts "creating testcases directories"
+
+1.upto(num_testcases) do |i|
+  system("mkdir #{problem}/test_cases/#{i}")
+end
+
+# generating all_tests.cfg
+puts "generating testcase config file"
+
+template = File.open(File.dirname(__FILE__) + "/templates/all_tests.cfg.erb").read
+all_test_cfg = ERB.new(template)
+
+cfg_file = File.open("#{problem}/test_cases/all_tests.cfg","w")
+cfg_file.puts all_test_cfg.result
+cfg_file.close
+
+puts "done"
diff --git a/judge/scripts/std-script/box.cc b/judge/scripts/std-script/box.cc
new file mode 100644
--- /dev/null
+++ b/judge/scripts/std-script/box.cc
@@ -0,0 +1,684 @@
+/*
+ *	A Simple Testing Sandbox
+ *
+ *	(c) 2001--2004 Martin Mares <mj@ucw.cz>
+ */
+
+#define _LARGEFILE64_SOURCE
+//#define _GNU_SOURCE
+
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <time.h>
+#include <sys/wait.h>
+#include <sys/user.h>
+#include <sys/time.h>
+#include <sys/ptrace.h>
+#include <sys/signal.h>
+#include <sys/sysinfo.h>
+#include <sys/syscall.h>
+#include <sys/resource.h>
+
+#define NONRET __attribute__((noreturn))
+#define UNUSED __attribute__((unused))
+
+static int filter_syscalls;		/* 0=off, 1=liberal, 2=totalitarian */
+static double timeout;
+static int pass_environ;
+static int use_wall_clock;
+static int file_access;
+static int verbose;
+static int memory_limit;
+static int allow_times;
+static char *redir_stdin, *redir_stdout;
+static char *set_cwd;
+
+static pid_t box_pid;
+static int is_ptraced;
+static volatile int timer_tick;
+static time_t start_time;
+static int ticks_per_sec;
+static int page_size;
+
+#if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ > 0
+/* glibc 2.1 or newer -> has lseek64 */
+#define long_seek(f,o,w) lseek64(f,o,w)
+#else
+/* Touching clandestine places in glibc */
+extern loff_t llseek(int fd, loff_t pos, int whence);
+#define long_seek(f,o,w) llseek(f,o,w)
+#endif
+
+int max_mem_used = 0;
+
+void print_running_stat(double wall_time,
+			double user_time,
+			double system_time,
+			int mem_usage)
+{
+  fprintf(stderr,"%.4lfr%.4lfu%.4lfs%dm\n", 
+	  wall_time, user_time, system_time, mem_usage);
+}
+
+static void NONRET
+box_exit(void)
+{
+  if (box_pid > 0) {
+    if (is_ptraced)
+      ptrace(PTRACE_KILL, box_pid);
+    kill(-box_pid, SIGKILL);
+    kill(box_pid, SIGKILL);
+  }
+
+  struct timeval total;
+  int wall;
+  struct rusage rus;
+  int stat;
+  pid_t p;
+  
+  // wait so that we can get information
+  p = wait4(box_pid, &stat, WUNTRACED, &rus);
+  if (p < 0) {
+    fprintf(stderr,"wait4: error\n");
+    print_running_stat(0,0,0,max_mem_used);
+  } else if (p != box_pid) {
+    fprintf(stderr,"wait4: unknown pid %d exited!\n", p);
+    print_running_stat(0,0,0,max_mem_used);
+  } else {
+    if (!WIFEXITED(stat))
+      fprintf(stderr,"wait4: unknown status\n");
+    struct timeval total;
+    int wall;
+    wall = time(NULL) - start_time;
+    timeradd(&rus.ru_utime, &rus.ru_stime, &total);
+    
+    print_running_stat((double)wall,
+		       (double) rus.ru_utime.tv_sec + 
+		       ((double) rus.ru_utime.tv_usec/1000000.0),
+		       (double) rus.ru_stime.tv_sec + 
+		       ((double) rus.ru_stime.tv_usec/1000000.0),
+		       max_mem_used);
+  }
+  exit(1);
+}
+
+static void NONRET __attribute__((format(printf,1,2)))
+die(char *msg, ...)
+{
+  va_list args;
+  va_start(args, msg);
+  vfprintf(stderr, msg, args);
+  fputc('\n', stderr);
+  box_exit();
+}
+
+static void __attribute__((format(printf,1,2)))
+log(char *msg, ...)
+{
+  va_list args;
+  va_start(args, msg);
+  if (verbose)
+    {
+      vfprintf(stderr, msg, args);
+      fflush(stderr);
+    }
+  va_end(args);
+}
+
+static void
+valid_filename(unsigned long addr)
+{
+  char namebuf[4096], *p, *end;
+  static int mem_fd;
+
+  if (!file_access)
+    die("File access forbidden.");
+  if (file_access >= 9)
+    return;
+
+  if (!mem_fd)
+    {
+      sprintf(namebuf, "/proc/%d/mem", (int) box_pid);
+      mem_fd = open(namebuf, O_RDONLY);
+      if (mem_fd < 0)
+	die("open(%s): %m", namebuf);
+    }
+  p = end = namebuf;
+  do
+    {
+      if (p >= end)
+	{
+	  int remains = PAGE_SIZE - (addr & (PAGE_SIZE-1));
+	  int l = namebuf + sizeof(namebuf) - end;
+	  if (l > remains)
+	    l = remains;
+	  if (!l)
+	    die("Access to file with name too long.");
+	  if (long_seek(mem_fd, addr, SEEK_SET) < 0)
+	    die("long_seek(mem): %m");
+	  remains = read(mem_fd, end, l);
+	  if (remains < 0)
+	    die("read(mem): %m");
+	  if (!remains)
+	    die("Access to file with name out of memory.");
+	  end += l;
+	  addr += l;
+	}
+    }
+  while (*p++);
+
+  log("[%s] ", namebuf);
+  if (file_access >= 3)
+    return;
+  if (!strchr(namebuf, '/') && strcmp(namebuf, ".."))
+    return;
+  if (file_access >= 2)
+    {
+      if ((!strncmp(namebuf, "/etc/", 5) ||
+	   !strncmp(namebuf, "/lib/", 5) ||
+	   !strncmp(namebuf, "/usr/lib/", 9))
+	  && !strstr(namebuf, ".."))
+	return;
+      if (!strcmp(namebuf, "/dev/null") ||
+	  !strcmp(namebuf, "/dev/zero") ||
+	  !strcmp(namebuf, "/proc/meminfo") ||
+	  !strcmp(namebuf, "/proc/self/stat") ||
+	  !strncmp(namebuf, "/usr/share/zoneinfo/", 20))
+	return;
+    }
+  die("Forbidden access to file `%s'.", namebuf);
+}
+
+static int
+valid_syscall(struct user *u)
+{
+  switch (u->regs.orig_eax)
+    {
+    case __NR_execve:
+      {
+	static int exec_counter;
+	return !exec_counter++;
+      }
+    case __NR_open:
+    case __NR_creat:
+    case __NR_unlink:
+    case __NR_oldstat:
+    case __NR_access:			
+    case __NR_oldlstat:			
+    case __NR_truncate:
+    case __NR_stat:
+    case __NR_lstat:
+    case __NR_truncate64:
+    case __NR_stat64:
+    case __NR_lstat64:
+      valid_filename(u->regs.ebx);
+      return 1;
+    case __NR_exit:
+    case __NR_read:
+    case __NR_write:
+    case __NR_close:
+    case __NR_lseek:
+    case __NR_getpid:
+    case __NR_getuid:
+    case __NR_oldfstat:
+    case __NR_dup:
+    case __NR_brk:
+    case __NR_getgid:
+    case __NR_geteuid:
+    case __NR_getegid:
+    case __NR_dup2:
+    case __NR_ftruncate:
+    case __NR_fstat:
+    case __NR_personality:
+    case __NR__llseek:
+    case __NR_readv:
+    case __NR_writev:
+    case __NR_getresuid:
+#ifdef __NR_pread64
+    case __NR_pread64:
+    case __NR_pwrite64:
+#else
+    case __NR_pread:
+    case __NR_pwrite:
+#endif
+    case __NR_ftruncate64:
+    case __NR_fstat64:
+    case __NR_fcntl:
+    case __NR_fcntl64:
+    case __NR_mmap:
+    case __NR_munmap:
+    case __NR_ioctl:
+    case __NR_uname:
+    case 252:
+    case 243:
+// added for free pascal
+    case __NR_ugetrlimit:
+    case __NR_readlink:
+      return 1;
+      //    case __NR_time:
+    case __NR_alarm:
+      //    case __NR_pause:
+    case __NR_signal:
+    case __NR_fchmod:
+    case __NR_sigaction:
+    case __NR_sgetmask:
+    case __NR_ssetmask:
+    case __NR_sigsuspend:
+    case __NR_sigpending:
+    case __NR_getrlimit:
+    case __NR_getrusage:
+    case __NR_gettimeofday:
+    case __NR_select:
+    case __NR_readdir:
+    case __NR_setitimer:
+    case __NR_getitimer:
+    case __NR_sigreturn:
+    case __NR_mprotect:
+    case __NR_sigprocmask:
+    case __NR_getdents:
+    case __NR_getdents64:
+    case __NR__newselect:
+    case __NR_fdatasync:
+    case __NR_mremap:
+    case __NR_poll:
+    case __NR_getcwd:
+    case __NR_nanosleep:
+    case __NR_rt_sigreturn:
+    case __NR_rt_sigaction:
+    case __NR_rt_sigprocmask:
+    case __NR_rt_sigpending:
+    case __NR_rt_sigtimedwait:
+    case __NR_rt_sigqueueinfo:
+    case __NR_rt_sigsuspend:
+    case __NR_mmap2:
+    case __NR__sysctl:
+      return (filter_syscalls == 1);
+    case __NR_times:
+    case __NR_time:
+      return allow_times;
+    case __NR_kill:
+      if (u->regs.ebx == box_pid)
+	die("Commited suicide by signal %d.", (int)u->regs.ecx);
+      return 0;
+    default:
+      return 0;
+    }
+}
+
+static void
+signal_alarm(int unused UNUSED)
+{
+  /* Time limit checks are synchronous, so we only schedule them there. */
+  timer_tick = 1;
+
+  //NOTE: do not use alarm, changed to setitimer for precision
+  //  alarm(1);
+}
+
+static void
+signal_int(int unused UNUSED)
+{
+  /* Interrupts are fatal, so no synchronization requirements. */
+  die("Interrupted.");
+}
+
+static void
+check_timeout(void)
+{
+  double sec;
+
+  if (use_wall_clock)
+    sec = (double)(time(NULL) - start_time);
+  else
+    {
+      char buf[4096], *x;
+      int c, utime, stime;
+      static int proc_status_fd;
+      if (!proc_status_fd)
+	{
+	  sprintf(buf, "/proc/%d/stat", (int) box_pid);
+	  proc_status_fd = open(buf, O_RDONLY);
+	  if (proc_status_fd < 0)
+	    die("open(%s): %m", buf);
+	}
+      lseek(proc_status_fd, 0, SEEK_SET);
+      if ((c = read(proc_status_fd, buf, sizeof(buf)-1)) < 0)
+	die("read on /proc/$pid/stat: %m");
+      if (c >= (int) sizeof(buf) - 1)
+	die("/proc/$pid/stat too long");
+      buf[c] = 0;
+      x = buf;
+      while (*x && *x != ' ')
+	x++;
+      while (*x == ' ')
+	x++;
+      if (*x++ != '(')
+	die("proc syntax error 1");
+      while (*x && (*x != ')' || x[1] != ' '))
+	x++;
+      while (*x == ')' || *x == ' ')
+	x++;
+      if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
+	die("proc syntax error 2");
+      //printf("%s - %d\n",x,ticks_per_sec);
+      sec = ((double)(utime + stime))/(double)ticks_per_sec;
+    }
+  if (verbose > 1)
+    fprintf(stderr, "[timecheck: %d seconds]\n", sec);
+  if (sec > timeout) {
+    die("Time limit exceeded.",sec,timeout);
+  }
+}
+
+static void
+check_memory_usage()
+{
+  char proc_fname[100];
+  sprintf(proc_fname,"/proc/%d/statm",box_pid);
+  //printf("proc fname: %s\n",proc_fname);
+  FILE *fp = fopen(proc_fname,"r");
+  if(fp!=NULL) {
+    char line[1000];
+    fgets(line,999,fp);
+    //printf("%s\n",line);
+    int m;
+
+    if(sscanf(line,"%d",&m)==1) {
+      m = (m*page_size+1023)/1024;
+      if(m>max_mem_used)
+	max_mem_used = m;
+    }
+
+    fclose(fp);
+  } 
+}
+
+static void
+boxkeeper(void)
+{
+  int syscall_count = 0;
+  struct sigaction sa;
+
+  is_ptraced = 1;
+  bzero(&sa, sizeof(sa));
+  sa.sa_handler = signal_int;
+  sigaction(SIGINT, &sa, NULL);
+  start_time = time(NULL);
+  ticks_per_sec = sysconf(_SC_CLK_TCK);
+  page_size = getpagesize();
+  if (ticks_per_sec <= 0)
+    die("Invalid ticks_per_sec!");
+
+  check_memory_usage();
+  
+  sa.sa_handler = signal_alarm;
+  sigaction(SIGALRM, &sa, NULL);
+  //alarm(1);
+
+  struct itimerval val;
+  val.it_interval.tv_sec = 0;
+  val.it_interval.tv_usec = 50000;
+  val.it_value.tv_sec = 0;
+  val.it_value.tv_usec = 50000;
+  setitimer(ITIMER_REAL,&val,NULL);
+
+  /*
+    --- add alarm handler no matter what..
+  if (timeout)
+    {
+      sa.sa_handler = signal_alarm;
+      sigaction(SIGALRM, &sa, NULL);
+      alarm(1);
+    }
+  */
+
+  for(;;)
+    {
+      struct rusage rus;
+      int stat;
+      pid_t p;
+
+      if (timer_tick)
+	{
+	  check_timeout();
+	  check_memory_usage();
+	  timer_tick = 0;
+	}
+      p = wait4(box_pid, &stat, WUNTRACED, &rus);
+
+      if (p < 0)
+	{
+	  if (errno == EINTR)
+	    continue;
+	  die("wait4: %m");
+	}
+      if (p != box_pid)
+	die("wait4: unknown pid %d exited!", p);
+      if (WIFEXITED(stat))
+	{
+	  struct timeval total;
+	  int wall;
+	  wall = time(NULL) - start_time;
+	  timeradd(&rus.ru_utime, &rus.ru_stime, &total);
+
+	  box_pid = 0;
+	  if (WEXITSTATUS(stat))
+	    fprintf(stderr,"Exited with error status %d.\n", WEXITSTATUS(stat));
+	  else if ((use_wall_clock ? 
+		    wall : 
+		    (double) total.tv_sec + 
+		    ((double) total.tv_usec/1000000.0)) > timeout)
+	    fprintf(stderr,"Time limit exceeded.\n");
+	  else
+	    // report OK and statistics
+	    fprintf(stderr,"OK\n");
+
+	  print_running_stat((double) wall,
+			     (double) rus.ru_utime.tv_sec + 
+			     ((double) rus.ru_utime.tv_usec/1000000.0),
+			     (double) rus.ru_stime.tv_sec + 
+			     ((double) rus.ru_stime.tv_usec/1000000.0),
+			     max_mem_used);
+/*
+	  (%.4lf sec real (%d), %d sec wall, %d syscalls, %d kb)\n", 
+		  (double) total.tv_sec + ((double)total.tv_usec / 1000000.0), 
+		  (int) total.tv_usec,
+		  wall, 
+		  syscall_count,
+		  max_mem_used);
+*/
+	  exit(0);
+	}
+      if (WIFSIGNALED(stat))
+	{
+	  box_pid = 0;
+	  fprintf(stderr,"Caught fatal signal %d.\n", WTERMSIG(stat));
+
+	  struct timeval total;
+	  int wall;
+	  wall = time(NULL) - start_time;
+	  timeradd(&rus.ru_utime, &rus.ru_stime, &total);
+	  print_running_stat((double) wall,
+			     (double) rus.ru_utime.tv_sec + 
+			     ((double) rus.ru_utime.tv_usec/1000000.0),
+			     (double) rus.ru_stime.tv_sec + 
+			     ((double) rus.ru_stime.tv_usec/1000000.0),
+			     max_mem_used);
+	  exit(0);
+	}
+      if (WIFSTOPPED(stat))
+	{
+	  int sig = WSTOPSIG(stat);
+	  if (sig == SIGTRAP)
+	    {
+	      struct user u;
+	      static int stop_count = -1;
+	      if (ptrace(PTRACE_GETREGS, box_pid, NULL, &u) < 0)
+		die("ptrace(PTRACE_GETREGS): %m");
+	      stop_count++;
+	      if (!stop_count)			/* Traceme request */
+		log(">> Traceme request caught\n");
+	      else if (stop_count & 1)		/* Syscall entry */
+		{
+		  log(">> Syscall %3ld (%08lx,%08lx,%08lx) ", u.regs.orig_eax, u.regs.ebx, u.regs.ecx, u.regs.edx);
+		  syscall_count++;
+		  if (!valid_syscall(&u))
+		    {
+		      /*
+		       * Unfortunately, PTRACE_KILL kills _after_ the syscall completes,
+		       * so we have to change it to something harmless (e.g., an undefined
+		       * syscall) and make the program continue.
+		       */
+		      unsigned int sys = u.regs.orig_eax;
+		      u.regs.orig_eax = 0xffffffff;
+		      if (ptrace(PTRACE_SETREGS, box_pid, NULL, &u) < 0)
+			die("ptrace(PTRACE_SETREGS): %m");
+		      die("Forbidden syscall %d.", sys);
+		    }
+		}
+	      else					/* Syscall return */
+		log("= %ld\n", u.regs.eax);
+	      ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
+	    }
+	  else if (sig != SIGSTOP && sig != SIGXCPU && sig != SIGXFSZ)
+	    {
+	      log(">> Signal %d\n", sig);
+	      ptrace(PTRACE_SYSCALL, box_pid, 0, sig);
+	    }
+	  else
+	    die("Received signal %d.", sig);
+	}
+      else
+	die("wait4: unknown status %x, giving up!", stat);
+    }
+}
+
+static void
+box_inside(int argc, char **argv)
+{
+  struct rlimit rl;
+  char *args[argc+1];
+  char *env[1] = { NULL };
+
+  memcpy(args, argv, argc * sizeof(char *));
+  args[argc] = NULL;
+  if (set_cwd && chdir(set_cwd))
+    die("chdir: %m");
+  if (redir_stdin)
+    {
+      close(0);
+      if (open(redir_stdin, O_RDONLY) != 0)
+	die("open(\"%s\"): %m", redir_stdin);
+    }
+  if (redir_stdout)
+    {
+      close(1);
+      if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
+	die("open(\"%s\"): %m", redir_stdout);
+    }
+  dup2(1, 2);
+  setpgrp();
+  if (memory_limit)
+    {
+      rl.rlim_cur = rl.rlim_max = memory_limit * 1024;
+      if (setrlimit(RLIMIT_AS, &rl) < 0)
+	die("setrlimit: %m");
+    }
+  rl.rlim_cur = rl.rlim_max = 64;
+  if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
+    die("setrlimit: %m");
+  if (filter_syscalls && ptrace(PTRACE_TRACEME) < 0)
+    die("ptrace(PTRACE_TRACEME): %m");
+  execve(args[0], args, (pass_environ ? environ : env));
+  die("execve(\"%s\"): %m", args[0]);
+}
+
+static void
+usage(void)
+{
+  fprintf(stderr, "Invalid arguments!\n");
+  printf("\
+Usage: box [<options>] -- <command> <arguments>\n\
+\n\
+Options:\n\
+-a <level>\tSet file access level (0=none, 1=cwd, 2=/etc,/lib,..., 3=whole fs, 9=no checks; needs -f)\n\
+-c <dir>\tChange directory to <dir> first\n\
+-e\t\tPass full environment of parent process\n\
+-f\t\tFilter system calls (-ff=very restricted)\n\
+-i <file>\tRedirect stdin from <file>\n\
+-m <size>\tLimit address space to <size> KB\n\
+-o <file>\tRedirect stdout to <file>\n\
+-t <time>\tStop after <time> seconds\n\
+-T\t\tAllow syscalls for measuring run time\n\
+-v\t\tBe verbose\n\
+-w\t\tMeasure wall clock time instead of run time\n\
+");
+  exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+  int c;
+  uid_t uid;
+
+  while ((c = getopt(argc, argv, "a:c:efi:m:o:t:Tvw")) >= 0)
+    switch (c)
+      {
+      case 'a':
+	file_access = atol(optarg);
+	break;
+      case 'c':
+	set_cwd = optarg;
+	break;
+      case 'e':
+	pass_environ = 1;
+	break;
+      case 'f':
+	filter_syscalls++;
+	break;
+      case 'i':
+	redir_stdin = optarg;
+	break;
+      case 'm':
+	memory_limit = atol(optarg);
+	break;
+      case 'o':
+	redir_stdout = optarg;
+	break;
+      case 't':
+	timeout = atof(optarg);
+	break;
+      case 'T':
+	allow_times++;
+	break;
+      case 'v':
+	verbose++;
+	break;
+      case 'w':
+	use_wall_clock = 1;
+	break;
+      default:
+	usage();
+      }
+  if (optind >= argc)
+    usage();
+
+  uid = geteuid();
+  if (setreuid(uid, uid) < 0)
+    die("setreuid: %m");
+  box_pid = fork();
+  if (box_pid < 0)
+    die("fork: %m");
+  if (!box_pid)
+    box_inside(argc-optind, argv+optind);
+  else
+    boxkeeper();
+  die("Internal error: fell over edge of the world");
+}
diff --git a/judge/scripts/std-script/check b/judge/scripts/std-script/check
new file mode 100755
--- /dev/null
+++ b/judge/scripts/std-script/check
@@ -0,0 +1,84 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+
+puts "YOU HAVE TO EDIT THE CHECKING CODE HERE: #{__FILE__}"
+exit(127)
+
+# below are codes for checking integer and text
+
+########### THIS IS FOR CHECKING INTEGER ##########
+num_pattern = /^[0-9]*/
+if (output_file_content =~ num_pattern) == nil
+  report_wrong.call
+end
+
+output_i = output_file_content.to_i
+answer_i = answer_file_content.to_i
+
+if output_i == answer_i
+  report_correct.call
+else 
+  report_wrong.call
+end
+
+########### THIS IS FOR CHECKING TEXT ##########
+
+# check visible text
+
+out_items = output_file_content.split
+ans_items = answer_file_content.split
+
+if out_items.length != ans_items.length
+  report_wrong.call
+else
+  out_items.length.times do |i|
+    if out_items[i]!=ans_items[i]
+      report_wrong.call
+    end
+  end
+  report_correct.call
+end
diff --git a/judge/scripts/std-script/compile b/judge/scripts/std-script/compile
new file mode 100755
--- /dev/null
+++ b/judge/scripts/std-script/compile
@@ -0,0 +1,107 @@
+#!/bin/sh
+
+##############################
+#
+# Standard Compile Script 
+#
+# Supported compilers: 
+#   gcc, g++, and fpc.
+#
+##############################
+
+talk ()
+{
+    if [ "$TALKATIVE" != "" ]; then
+	echo "$1"
+    fi
+}
+
+export C_COMPILER=/usr/bin/gcc
+export CPLUSPLUS_COMPILER=/usr/bin/g++
+export PASCAL_COMPILER=/usr/bin/fpc
+
+export C_OPTIONS="-O2 -s -static -std=c99 -DCONTEST -lm -Wall"
+export CPLUSPLUS_OPTIONS="-O2 -s -static -DCONTEST -lm -Wall"
+export PASCAL_OPTIONS="-O1 -XS -dCONTEST"
+
+# Check for the correct number of arguments. Otherwise, print usage.
+if [ $# -eq 0 -o $# -gt 4 ]
+then
+    echo "Usage: $0 <language> [<source-file>] [<output-file>] [<message-file>]"
+    echo
+    echo "<source-file>  is defaulted to \"source\"."
+    echo "<output-file>  is defaulted to \"a.out\"."
+    echo "<message-file> is defaulted to \"compiler_message\"."
+    echo
+    exit 127
+fi
+
+# Retrieve the arguments.
+if [ $# -ge 1 ]
+then
+    export PROG_LANG=$1
+    talk "programming language: ${PROG_LANG}"
+fi
+
+if [ $# -ge 2 ]
+then
+    export SOURCE_FILE=$2
+else
+    export SOURCE_FILE=source
+fi
+talk "         source file: $SOURCE_FILE"
+
+if [ $# -ge 3 ]
+then
+    export OUTPUT_FILE=$3
+else
+    export OUTPUT_FILE=a.out
+fi
+talk "         output file: $OUTPUT_FILE"
+
+if [ $# -eq 4 ]
+then
+    export MESSAGE_FILE=$4
+else
+    export MESSAGE_FILE=compiler_message
+fi
+talk "        message file: $MESSAGE_FILE"
+
+# Remove any remaining output files or message files.
+rm -Rf $OUTPUT_FILE
+rm -Rf $MESSAGE_FILE
+
+# Check if the source file exists before attempt compiling.
+if [ ! -f $SOURCE_FILE ]
+then
+    talk "ERROR: The source file does not exist!"
+    echo "ERROR: The source file did not exist." > $MESSAGE_FILE
+    exit 127
+fi
+
+# Compile.
+if [ $PROG_LANG = "c" ]
+then
+    $C_COMPILER $SOURCE_FILE -o $OUTPUT_FILE $C_OPTIONS 2>$MESSAGE_FILE
+elif [ $PROG_LANG = "c++" ]
+then
+    $CPLUSPLUS_COMPILER $SOURCE_FILE -o $OUTPUT_FILE $CPLUSPLUS_OPTIONS 2>$MESSAGE_FILE
+elif [ $PROG_LANG = "pas" ]
+then
+    $PASCAL_COMPILER $SOURCE_FILE -ooutpas $PASCAL_OPTIONS >$MESSAGE_FILE
+    mv outpas $OUTPUT_FILE
+else
+    talk "ERROR: Invalid language specified!"
+    echo "ERROR: Invalid language specified!" > $MESSAGE_FILE
+    exit 127
+fi
+
+# Report success or failure.
+if [ -f $OUTPUT_FILE ]
+then
+    talk "Compilation was successful!"    
+else
+    talk "ERROR: Something was wrong during the compilation!"
+    talk "Dumping compiler message:"
+    #cat $MESSAGE_FILE
+fi
diff --git a/judge/scripts/std-script/grade b/judge/scripts/std-script/grade
new file mode 100755
--- /dev/null
+++ b/judge/scripts/std-script/grade
@@ -0,0 +1,106 @@
+#!/usr/bin/ruby
+
+CORRECT_MARK = 'P'
+INCORRECT_MARK = '-'
+TIMEOUT_MARK = 'T'
+RUN_ERROR_MARK = 'x'
+
+def log(str='')
+  if ENV['TALKATIVE']!=nil
+    puts str
+  end
+  if ENV['GRADER_LOGGING']!=nil
+    log_fname = ENV['GRADER_LOGGING']
+    fp = File.open(log_fname,"a")
+    fp.puts("grade: #{Time.new.strftime("%H:%M")} #{str}")
+    fp.close
+  end
+end
+
+def char_comment(comment)
+  if comment =~ /[Ii]ncorrect/
+    INCORRECT_MARK
+  elsif comment =~ /[Cc]orrect/
+    CORRECT_MARK
+  elsif comment =~ /[Tt]ime/
+    TIMEOUT_MARK
+  elsif res = /^[Cc]omment:(.*)$/.match(comment)
+    res[1]
+  else
+    RUN_ERROR_MARK  # these are run time errors
+  end
+end
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+if problem.well_formed? == false
+  log "The problem specification is not well formed."
+  exit(127)
+end
+
+all_score = 0
+all_comment = ''
+(1..(problem.runs.length-1)).each do |k|
+  log "grade run #{k}"
+  run = problem.runs[k]
+  run_score = nil
+  run_comment = ''
+  run_comment_short = ''
+  run.tests.each do |test_num|
+    result_file_name = "#{test_num}/result"
+    if not File.exists?(result_file_name)
+      run_comment += "result file for test #{test_num} not found\n"
+      run_comment_short += RUN_ERROR_MARK
+      log "Cannot find the file #{test_num}/result!"
+    else
+      result_file = File.new(result_file_name, "r")
+      result_file_lines = result_file.readlines
+      if result_file_lines.length>=2
+        current_run_score = result_file_lines[1].to_i
+        run_comment += result_file_lines[0]
+        run_comment_short += char_comment(result_file_lines[0].chomp)
+      else
+        current_run_score = 0
+        run_comment += "result file for test #{test_num} error\n"
+        run_comment_short += RUN_ERROR_MARK
+        log "Error in #{test_num}/result!"
+      end
+
+      # the score of this run should be the minimum of the score for
+      #   each test case
+      if (run_score==nil) or (run_score>current_run_score)
+        run_score = current_run_score
+      end
+      result_file.close
+    end
+  end
+
+  run_result_file = File.new("result-#{k}", "w")
+  run_result_file.write run_score
+  run_result_file.write "\n"
+  run_result_file.close
+
+  run_comment_file = File.new("comment-#{k}", "w")
+  run_comment_file.write "#{run_comment}\n"
+  run_comment_file.close
+
+  all_score = all_score + run_score
+
+  # append comment for test run with many test cases
+  if run.tests.length > 1 
+    run_comment_short = '[' + run_comment_short + ']'
+  end
+  all_comment += run_comment_short
+end
+
+result_file = File.new("result", "w")
+result_file.write all_score
+result_file.write "\n"
+result_file.close
+
+comment_file = File.new("comment", "w")
+comment_file.write "#{all_comment}\n"
+comment_file.close
diff --git a/judge/scripts/std-script/judge b/judge/scripts/std-script/judge
new file mode 100755
--- /dev/null
+++ b/judge/scripts/std-script/judge
@@ -0,0 +1,138 @@
+#!/usr/bin/ruby
+
+def log(str='')
+  if ENV['TALKATIVE']!=nil
+    puts str
+  end
+  if ENV['GRADER_LOGGING']!=nil
+    log_fname = ENV['GRADER_LOGGING']
+    fp = File.open(log_fname,"a")
+    fp.puts("judge: #{Time.new.strftime("%H:%M")} #{str}")
+    fp.close
+  end
+end
+
+problem_home = ENV['PROBLEM_HOME']
+
+def execute(command, error_message="")
+  if not system(command)
+    msg = "ERROR: #{error_message}"
+    log msg
+    raise msg
+  end
+end
+
+# ARGV[0] --- language
+# ARGV[1] --- program source file
+# ARGV[2] --- test result directory
+# ARGV[3] --- sandbox directory
+
+if ARGV.length < 2 || ARGV.length > 4
+  puts "Usage: judge <language> <program-source> [<test-result-directory>] [<sandbox-directory>]"
+  puts "  <sandbox-directory> is defaulted to ./sandbox"
+  puts "  <test-result-directory> is defaulted to ./test-result"
+  puts "WARNING: The judge script will forcefully create the (implicitly and explicitly) specified directories and remove anything inside it."
+  exit(127)
+end
+
+language = ARGV[0]
+if language != "c" && language != "c++" && language != "pas"
+  log "You specified a language that is not supported: #{language}."
+  exit(127)
+end
+
+source_file = ARGV[1]
+if File.exist?(source_file) == false
+  log "The source file does not exist."
+  exit(127)
+end
+
+log "Making test result and sandbox directories..."
+
+current_dir = `pwd`
+current_dir.strip!
+
+if ARGV.length >= 3
+  test_result_dir = ARGV[2]
+else
+  test_result_dir = "#{current_dir}/test-result"
+end
+log "Test result directory: #{test_result_dir}"
+system("rm -Rf #{test_result_dir}")
+execute("mkdir #{test_result_dir}", "Cannot make directory #{test_result_dir}.")
+
+if ARGV.length >= 4
+  sandbox_dir = ARGV[3]
+else
+  sandbox_dir = "#{current_dir}/sandbox"
+end
+log "Sandbox directory: #{sandbox_dir}"
+system("rm -Rf #{sandbox_dir}")
+execute("mkdir #{sandbox_dir}", "Cannot make directory #{sandbox_dir}")
+
+# Compile
+log
+log "Compiling..."
+execute("cp #{source_file} #{sandbox_dir}", "Cannot copy the source file to #{sandbox_dir}")
+begin 
+  Dir.chdir sandbox_dir
+rescue
+  log "ERROR: Cannot change directory to #{sandbox_dir}."
+  exit(127)
+end
+execute("#{problem_home}/script/compile #{language} #{source_file}", "Compilation error!")
+compile_message = `cat compiler_message`
+compile_message.strip!
+execute("mv compiler_message #{test_result_dir}", "Cannot move the compiler message to #{test_result_dir}.")
+if !FileTest.exist?("a.out")
+  log "Cannot compile the source code. See message in #{test_result_dir}/compile_message"
+  exit(127)
+else
+  execute("mv a.out #{test_result_dir}", "Cannot move the compiled program to #{test_result_dir}")
+  system("rm -Rf #{sandbox_dir}/*")
+end
+
+require "#{problem_home}/script/test_dsl.rb"
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+if problem.well_formed? == false
+  log "The problem specification is not well formed."
+  exit(127)
+end
+
+# Doing the testing.
+(1..(problem.num_tests)).each do |test_num|
+
+  $stdout.print "[#{test_num}]"
+  $stdout.flush
+
+  log "Test number: #{test_num}"
+  execute("cp #{test_result_dir}/a.out #{sandbox_dir}", "Cannot copy the compiled program into #{sandbox_dir}")
+  begin
+    execute("#{problem_home}/script/run #{language} #{test_num}", "Error occured during execution of the run script")
+  rescue
+    # do nothing
+  end
+  execute("mkdir #{test_result_dir}/#{test_num}", "Cannot create directory #{test_result_dir}/#{test_num}")
+  execute("mv #{sandbox_dir}/result #{test_result_dir}/#{test_num}", "Cannot copy the result file into #{test_result_dir}/#{test_num}")
+  execute("mv #{sandbox_dir}/comment #{test_result_dir}/#{test_num}", "Cannot copy the comment file into #{test_result_dir}/#{test_num}")
+  execute("mv #{sandbox_dir}/output.txt #{test_result_dir}/#{test_num}", "Cannot copy the output file into #{test_result_dir}/#{test_num}")
+  execute("rm -Rf #{sandbox_dir}/*", "Cannot clear #{sandbox_dir}")
+end
+
+$stdout.print "[done]\n"
+
+# Grade
+log
+log "Grading..."
+begin
+  Dir.chdir test_result_dir
+rescue
+  log "ERROR: Cannot change directory to #{test_result_dir}."
+  exit(127)
+end
+execute("#{problem_home}/script/grade", "An error occured during grading!")
+
+log
+log "All done!"
diff --git a/judge/scripts/std-script/run b/judge/scripts/std-script/run
new file mode 100755
--- /dev/null
+++ b/judge/scripts/std-script/run
@@ -0,0 +1,155 @@
+#!/usr/bin/ruby
+
+def log(str='')
+  if ENV['TALKATIVE']!=nil
+    puts str
+  end
+  if ENV['GRADER_LOGGING']!=nil
+    log_fname = ENV['GRADER_LOGGING']
+    fp = File.open(log_fname,"a")
+    fp.puts("run: #{Time.new.strftime("%H:%M")} #{str}")
+    fp.close
+  end
+end
+
+def extract_time(t)
+  #  puts "TIME: #{t}"
+  if (result=/^(.*)r(.*)u(.*)s/.match(t))
+    {:real => result[1], :user => result[2], :sys => result[3]}
+  else
+    #{:real => 0, :user => 0, :sys => 0}
+    #puts "ERROR READING RUNNING TIME: #{t}"
+    raise "Error reading running time: #{t}"
+  end
+end
+
+def compile_box(source,bin)
+  system("g++ #{source} -o #{bin}")
+end
+
+if ARGV.length < 2 || ARGV.length > 3
+  puts "Usage: run <language> <test-num> [<program-name>]"
+  exit(127)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length > 2
+  program_name = ARGV[2]
+else
+  program_name = "a.out"
+end
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+if problem.well_formed? == false
+  log "The problem specification is not well formed."
+  exit(127)
+end
+
+# Check if the test number is okay.
+if test_num <= 0 || test_num > problem.num_tests
+  log "You have specified a wrong test number."
+  exit(127)
+end
+
+#####################################
+# Set the relavant file names here. #
+#####################################
+
+input_file_name = "#{problem_home}/test_cases/#{test_num}/input-#{test_num}.txt"
+
+#####################################
+
+time_limit = problem.get_time_limit test_num
+mem_limit = problem.get_mem_limit(test_num) * 1024
+
+# Copy the input file.
+#`cp #{problem_home}/test_cases/#{test_num}/#{input_file_name} .`
+
+# check if box is there, if not, compile it!
+if !File.exists?("#{problem_home}/script/box")
+  log "WARNING: Compiling box: to increase efficiency, it should be compile manually"
+  compile_box("#{problem_home}/script/box.cc",
+              "#{problem_home}/script/box")
+end
+
+# Hide PROBLEM_HOME
+ENV['PROBLEM_HOME'] = nil
+
+# Run the program.
+#run_command = "/usr/bin/time -f \"#{time_output_format}\" 2>run_result #{problem_home}/script/box_new -a 2 -f -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name}"
+run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name} 2>run_result"
+log "Running test #{test_num}..."
+log run_command
+log 
+system(run_command)
+
+# Restore PROBLEM_HOME
+ENV['PROBLEM_HOME'] = problem_home
+
+# Create the result file. 
+result_file = File.new("result", "w") 
+comment_file = File.new("comment", "w")
+
+# Check if the program actually produced any output.
+run_result_file = File.new("run_result", "r")
+run_result = run_result_file.readlines
+run_result_file.close
+
+run_stat = run_result[run_result.length-1]
+running_time = extract_time(run_stat)
+
+report = lambda{ |status, points, comment|
+  result_file.write status.strip
+  result_file.write "\n" 
+  result_file.write points.to_s.strip
+  result_file.write "\n" 
+  result_file.write run_stat.strip 
+  result_file.write "\n"
+  result_file.close 
+  `rm run_result`
+  # `rm output.txt`   --- keep the output
+
+  comment_file.write comment
+
+  # added for debuggin --- jittat
+  comment_file.write "--run-result--\n"
+  run_result.each do |l|
+    comment_file.write l
+  end
+
+  comment_file.close
+
+  log "Done!"
+  exit(0)  
+}
+
+if run_result[0][0,2] != "OK"
+  log "There was a runtime error."
+  report.call(run_result[0], 0, "No comment.\n")
+end
+
+if running_time[:user].to_f + running_time[:sys].to_f > time_limit
+  log "Time limit exceeded."
+  report.call("Time limit exceeded", 0, "No comment.\n")
+end
+
+# Run 'check' to evaluate the output.
+#puts "There was no runtime error. Proceed to checking the output."
+check_command = "#{problem_home}/script/check #{language} #{test_num}"
+log "Checking the output..."
+log check_command
+if not system(check_command)
+  log "Problem with check script"
+  report.call("Incorrect",0,"Check script error.\n")
+  exit(127)
+end
+
+check_file = File.new("check_result", "r")
+check_file_lines = check_file.readlines
+
+report.call(check_file_lines[0], check_file_lines[1], "No comment.\n")
diff --git a/judge/scripts/std-script/test_dsl.rb b/judge/scripts/std-script/test_dsl.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/std-script/test_dsl.rb
@@ -0,0 +1,180 @@
+class DSLNode
+  def DSLNode.scalar_attr(*names)
+    names.each do |name|
+      define_method name do |*a|        
+        if a.length == 0
+          instance_variable_get( "@#{name}" )
+        else
+          instance_variable_set( "@#{name}", a[0] )
+        end
+      end
+    end
+  end
+
+  def DSLNode.array_attr(*names)
+    names.each do |name|
+      define_method name do |*a|
+        if a.length == 0
+          instance_variable_get( "@#{name}" )
+        else
+          instance_variable_set( "@#{name}", a )
+        end
+      end
+    end
+  end
+end
+
+class Problem < DSLNode
+  def initialize
+    @runs = []
+    @tests = []
+  end
+
+  def Problem.getter(name, plural_name, each_name)
+    eval "def get_#{name}(index) \n \
+      if defined?(@tests) and @tests[index] != nil \n \
+        if @tests[index].#{name} != nil \n \                    
+          return @tests[index].#{name} \n \
+        end \n \
+      end \n \
+      \n \
+      (1..@runs.length-1).each do |i| \n \
+        run = @runs[i] \n \
+        k = run.tests.index(index) \n \
+        if k == nil \n \
+          next \n \
+        end \n \
+        \n \
+        if run.#{plural_name} != nil && run.#{plural_name}[k] != nil \n \
+          return run.#{plural_name}[k] \n \
+        end \n \
+        \n \
+        if run.#{each_name} != nil \n \
+          return run.#{each_name} \n \
+        end \n \
+      end \n \
+      \n \
+      if @#{each_name} != nil \n \
+        return @#{each_name} \n \
+      else \n \
+        raise 'The problem is malformed (possibly in more than one way)!' \n \
+      end \n \
+    end"
+  end
+
+  scalar_attr :num_tests, :full_score, :score_each, :time_limit_each, :mem_limit_each
+  array_attr :runs, :tests
+  getter "score", "scores", "score_each"
+  getter "mem_limit", "mem_limits", "mem_limit_each"
+  getter "time_limit", "time_limits", "time_limit_each"
+
+  def run(index, &block)
+    new_run = Run.new
+    new_run.instance_eval &block
+    @runs[index] = new_run
+  end
+
+  def test(index, &block)
+    new_test = Test.new
+    new_test.instance_eval &block
+    @tests[index] = new_test
+  end
+
+  def read_test(index)
+    filename = ENV['PROBLEM_HOME'] + "/test_cases/#{index}/test.cfg"
+    if File.exists?(filename)
+      @tests[index] ||= Test.new
+      content = File.read(filename)
+      @tests[index].instance_eval content
+    end
+  end
+
+  def Problem.set_instance(prob)
+    @instance = prob
+  end
+
+  def Problem.get_instance
+    return @instance
+  end
+
+  def well_formed?
+    # Check if run 1 to run @runs.length are present.
+    (1..(@runs.length-1)).each do |i|
+      if @runs[i] == nil
+        puts "run #{i} is not present"
+        return false
+      end
+    end
+
+    # Check if all tests are in one and only one run.
+    test_present = []
+    (1..(@num_tests)).each do |i|
+      test_present[i] = false
+    end
+    (1..(@runs.length-1)).each do |j|
+      run = @runs[j]
+      if run.tests!=nil
+        run.tests.each do |t|
+          if test_present[t] == false
+            test_present[t] = true
+          else
+            puts "test #{t} is present in more than one run"
+            return false
+          end
+        end
+      end
+    end
+    (1..(@num_tests)).each do |i|
+      if test_present[i] == false
+        puts "test #{i} is not present"
+        return false
+      end
+    end
+
+    # Check if we can find the score, mem limit, and time limit for all tests.
+    (1..(@num_tests)).each do |i|
+      begin
+        get_score i
+      rescue
+        puts "cannot get score for test #{i}"
+        return false
+      end
+
+      begin
+        get_mem_limit i
+      rescue
+        puts "cannot get mem limit for test #{i}"
+        return false
+      end
+
+      begin
+        get_time_limit i
+      rescue
+        puts "cannot get time limit for test #{i}"
+        return false
+      end  
+    end
+
+    return true
+  end
+end
+
+class Run < DSLNode
+  scalar_attr :score_each, :time_limit_each, :mem_limit_each
+  array_attr :tests, :scores, :time_limits, :mem_limits
+end
+
+class Test < DSLNode
+  scalar_attr :score, :time_limit, :mem_limit  
+end
+
+def problem(&blk)
+  prob = Problem.new
+  prob.instance_eval &blk
+  Problem.set_instance prob
+  p = Problem.get_instance
+  (1..(p.num_tests)).each do |i|
+    p.read_test i
+  end
+  p.well_formed?
+end
diff --git a/judge/scripts/templates/all_tests.cfg.erb b/judge/scripts/templates/all_tests.cfg.erb
new file mode 100755
--- /dev/null
+++ b/judge/scripts/templates/all_tests.cfg.erb
@@ -0,0 +1,20 @@
+problem do
+  num_tests <%= num_testcases %>
+  full_score <%= num_testruns*10 %>
+  time_limit_each <%= options[:time_limit] %>
+  mem_limit_each <%= options[:mem_limit] %>
+  score_each 10
+
+<% tr_num = 0 %>
+<% testrun_info.each do |testrun| %>
+  <% tr_num += 1 %>
+  run <%= tr_num %> do
+    tests <%= (testrun.collect {|testcase| testcase[0]}).join(", ") %>
+    <% if testrun.length==1 %>
+    scores 10
+    <% else %>
+    scores 10 <% (testrun.length-1).times do %>,10 <% end %>
+    <% end %>
+  end
+<% end %>
+end
diff --git a/judge/scripts/templates/answer-1.txt b/judge/scripts/templates/answer-1.txt
new file mode 100644
diff --git a/judge/scripts/templates/check.integer b/judge/scripts/templates/check.integer
new file mode 100755
--- /dev/null
+++ b/judge/scripts/templates/check.integer
@@ -0,0 +1,62 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+
+########### THIS IS FOR CHECKING INTEGER ##########
+num_pattern = /^[0-9]*/
+if (output_file_content =~ num_pattern) == nil
+  report_wrong.call
+end
+
+output_i = output_file_content.to_i
+answer_i = answer_file_content.to_i
+
+if output_i == answer_i
+  report_correct.call
+else 
+  report_wrong.call
+end
+
diff --git a/judge/scripts/templates/check.text b/judge/scripts/templates/check.text
new file mode 100755
--- /dev/null
+++ b/judge/scripts/templates/check.text
@@ -0,0 +1,64 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+
+########### THIS IS FOR CHECKING TEXT ##########
+
+# check visible text
+
+out_items = output_file_content.split
+ans_items = answer_file_content.split
+
+if out_items.length != ans_items.length
+  report_wrong.call
+else
+  out_items.length.times do |i|
+    if out_items[i]!=ans_items[i]
+      report_wrong.call
+    end
+  end
+  report_correct.call
+end
diff --git a/judge/scripts/templates/check_empty b/judge/scripts/templates/check_empty
new file mode 100755
--- /dev/null
+++ b/judge/scripts/templates/check_empty
@@ -0,0 +1,47 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+report_correct.call
diff --git a/judge/scripts/templates/check_wrapper b/judge/scripts/templates/check_wrapper
new file mode 100644
--- /dev/null
+++ b/judge/scripts/templates/check_wrapper
@@ -0,0 +1,48 @@
+#!/usr/bin/ruby
+
+#
+# This is a check script wrapper.  It read all required information
+# and call a real check script call REAL_CHECK_SCRIPT in directory
+# [problem_home]/script
+#
+
+REAL_CHECK_SCRIPT = "<%= script_name %>"
+
+# The REAL_CHECK_SCRIPT is called with:
+#
+#  (script) <lang> <test-num> <in-file> <out-file> <ans-file> <full-score>
+#
+# and REAL_CHECK_SCRIPT's output to standard out is redirected to
+# 'check_result' as required by normal check script.
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+answer_file_name = "#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt"
+input_file_name = "#{problem_home}/test_cases/#{test_num}/input-#{test_num}.txt"
+
+score = problem.get_score(test_num)
+
+cmd = "#{problem_home}/script/#{REAL_CHECK_SCRIPT} " +
+  "#{language} #{test_num} #{input_file_name} #{output_file_name} " +
+  "#{answer_file_name} #{score} > check_result"
+
+#puts "wrapper-CMD: #{cmd}"
+
+system(cmd)
diff --git a/judge/scripts/templates/test_request_all_tests.cfg.erb b/judge/scripts/templates/test_request_all_tests.cfg.erb
new file mode 100755
--- /dev/null
+++ b/judge/scripts/templates/test_request_all_tests.cfg.erb
@@ -0,0 +1,12 @@
+problem do
+  num_tests 1
+  full_score 10
+  time_limit_each <%= options[:time_limit] %>
+  mem_limit_each <%= options[:mem_limit] %>
+  score_each 10
+
+  run 1 do
+    tests 1
+  end
+
+end
diff --git a/judge/scripts/test/data/add_fail_test_case_1.c b/judge/scripts/test/data/add_fail_test_case_1.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/add_fail_test_case_1.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int main()
+{
+  int a,b;
+  scanf("%d %d",&a,&b);
+  if((a==1) && (b==1))
+    printf("100\n");
+  else
+    printf("%d\n",a+b);
+  return 0;
+}
+
diff --git a/judge/scripts/test/data/add_nonzero_exit_status.c b/judge/scripts/test/data/add_nonzero_exit_status.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/add_nonzero_exit_status.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+int main()
+{
+  int a,b;
+  scanf("%d %d",&a,&b);
+  printf("%d\n",a+b);
+  return 10;
+}
+
diff --git a/judge/scripts/test/data/add_too_much_memory_dynamic.c b/judge/scripts/test/data/add_too_much_memory_dynamic.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/add_too_much_memory_dynamic.c
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main()
+{
+  int a,b;
+  char *huge_array;
+
+  scanf("%d %d",&a,&b);
+
+  huge_array = (char *)malloc(5000000);
+  if(huge_array==NULL)
+    printf("NO!");
+  else
+    printf("%d\n",a+b);
+
+  return 0;
+}
+
diff --git a/judge/scripts/test/data/add_too_much_memory_static.c b/judge/scripts/test/data/add_too_much_memory_static.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/add_too_much_memory_static.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+int big_array[2000000];
+
+int main()
+{
+  int a,b;
+  scanf("%d %d",&a,&b);
+  printf("%d\n",a+b);
+  return 0;
+}
+
diff --git a/judge/scripts/test/data/ev/test_memory/script/check b/judge/scripts/test/data/ev/test_memory/script/check
new file mode 100755
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_memory/script/check
@@ -0,0 +1,59 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+num_pattern = /^[0-9]*/
+if (output_file_content =~ num_pattern) == nil
+  report_wrong.call
+end
+
+output_i = output_file_content.to_i
+answer_i = answer_file_content.to_i
+
+if output_i == answer_i
+  report_correct.call
+else 
+  report_wrong.call
+end
diff --git a/judge/scripts/test/data/ev/test_memory/test_cases/1/answer-1.txt b/judge/scripts/test/data/ev/test_memory/test_cases/1/answer-1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_memory/test_cases/1/answer-1.txt
@@ -0,0 +1,2 @@
+2
+
diff --git a/judge/scripts/test/data/ev/test_memory/test_cases/1/input-1.txt b/judge/scripts/test/data/ev/test_memory/test_cases/1/input-1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_memory/test_cases/1/input-1.txt
@@ -0,0 +1,2 @@
+1 1
+
diff --git a/judge/scripts/test/data/ev/test_memory/test_cases/2/answer-2.txt b/judge/scripts/test/data/ev/test_memory/test_cases/2/answer-2.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_memory/test_cases/2/answer-2.txt
@@ -0,0 +1,2 @@
+2
+
diff --git a/judge/scripts/test/data/ev/test_memory/test_cases/2/input-2.txt b/judge/scripts/test/data/ev/test_memory/test_cases/2/input-2.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_memory/test_cases/2/input-2.txt
@@ -0,0 +1,2 @@
+1 1
+
diff --git a/judge/scripts/test/data/ev/test_memory/test_cases/all_tests.cfg b/judge/scripts/test/data/ev/test_memory/test_cases/all_tests.cfg
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_memory/test_cases/all_tests.cfg
@@ -0,0 +1,20 @@
+problem do
+  num_tests 2
+  full_score 20
+  time_limit_each 1
+  mem_limit_each 5
+  score_each 10
+
+  run 1 do
+    tests 1
+  end
+
+  test 2 do
+    mem_limit 10
+  end
+
+  run 2 do
+    tests 2
+  end
+    
+end
diff --git a/judge/scripts/test/data/ev/test_normal/script/check b/judge/scripts/test/data/ev/test_normal/script/check
new file mode 100755
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/script/check
@@ -0,0 +1,59 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+num_pattern = /^[0-9]*/
+if (output_file_content =~ num_pattern) == nil
+  report_wrong.call
+end
+
+output_i = output_file_content.to_i
+answer_i = answer_file_content.to_i
+
+if output_i == answer_i
+  report_correct.call
+else 
+  report_wrong.call
+end
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/1/answer-1.txt b/judge/scripts/test/data/ev/test_normal/test_cases/1/answer-1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/1/answer-1.txt
@@ -0,0 +1,1 @@
+2
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/1/input-1.txt b/judge/scripts/test/data/ev/test_normal/test_cases/1/input-1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/1/input-1.txt
@@ -0,0 +1,1 @@
+1 1
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/10/answer-10.txt b/judge/scripts/test/data/ev/test_normal/test_cases/10/answer-10.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/10/answer-10.txt
@@ -0,0 +1,1 @@
+-256
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/10/input-10.txt b/judge/scripts/test/data/ev/test_normal/test_cases/10/input-10.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/10/input-10.txt
@@ -0,0 +1,1 @@
+-128 -128
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/2/answer-2.txt b/judge/scripts/test/data/ev/test_normal/test_cases/2/answer-2.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/2/answer-2.txt
@@ -0,0 +1,1 @@
+32
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/2/input-2.txt b/judge/scripts/test/data/ev/test_normal/test_cases/2/input-2.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/2/input-2.txt
@@ -0,0 +1,1 @@
+20 12
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/3/answer-3.txt b/judge/scripts/test/data/ev/test_normal/test_cases/3/answer-3.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/3/answer-3.txt
@@ -0,0 +1,1 @@
+4
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/3/input-3.txt b/judge/scripts/test/data/ev/test_normal/test_cases/3/input-3.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/3/input-3.txt
@@ -0,0 +1,1 @@
+1 3
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/3/test.cfg b/judge/scripts/test/data/ev/test_normal/test_cases/3/test.cfg
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/3/test.cfg
@@ -0,0 +1,1 @@
+mem_limit 32
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/4/answer-4.txt b/judge/scripts/test/data/ev/test_normal/test_cases/4/answer-4.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/4/answer-4.txt
@@ -0,0 +1,1 @@
+64
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/4/input-4.txt b/judge/scripts/test/data/ev/test_normal/test_cases/4/input-4.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/4/input-4.txt
@@ -0,0 +1,1 @@
+32 32
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/5/answer-5.txt b/judge/scripts/test/data/ev/test_normal/test_cases/5/answer-5.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/5/answer-5.txt
@@ -0,0 +1,1 @@
+-2
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/5/input-5.txt b/judge/scripts/test/data/ev/test_normal/test_cases/5/input-5.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/5/input-5.txt
@@ -0,0 +1,1 @@
+-1 -1
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/6/answer-6.txt b/judge/scripts/test/data/ev/test_normal/test_cases/6/answer-6.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/6/answer-6.txt
@@ -0,0 +1,1 @@
+-32
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/6/input-6.txt b/judge/scripts/test/data/ev/test_normal/test_cases/6/input-6.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/6/input-6.txt
@@ -0,0 +1,1 @@
+-16 -16
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/7/answer-7.txt b/judge/scripts/test/data/ev/test_normal/test_cases/7/answer-7.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/7/answer-7.txt
@@ -0,0 +1,1 @@
+0
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/7/input-7.txt b/judge/scripts/test/data/ev/test_normal/test_cases/7/input-7.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/7/input-7.txt
@@ -0,0 +1,1 @@
+0 0
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/8/answer-8.txt b/judge/scripts/test/data/ev/test_normal/test_cases/8/answer-8.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/8/answer-8.txt
@@ -0,0 +1,1 @@
+-1
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/8/input-8.txt b/judge/scripts/test/data/ev/test_normal/test_cases/8/input-8.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/8/input-8.txt
@@ -0,0 +1,1 @@
+0 -1
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/8/test.cfg b/judge/scripts/test/data/ev/test_normal/test_cases/8/test.cfg
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/8/test.cfg
@@ -0,0 +1,1 @@
+mem_limit 64
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/9/answer-9.txt b/judge/scripts/test/data/ev/test_normal/test_cases/9/answer-9.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/9/answer-9.txt
@@ -0,0 +1,1 @@
+256
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/9/input-9.txt b/judge/scripts/test/data/ev/test_normal/test_cases/9/input-9.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/9/input-9.txt
@@ -0,0 +1,1 @@
+128 128
\ No newline at end of file
diff --git a/judge/scripts/test/data/ev/test_normal/test_cases/all_tests.cfg b/judge/scripts/test/data/ev/test_normal/test_cases/all_tests.cfg
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_normal/test_cases/all_tests.cfg
@@ -0,0 +1,40 @@
+problem do
+  num_tests 10
+  full_score 135
+  time_limit_each 1
+  mem_limit_each 11
+  score_each 10
+
+  run 1 do
+    tests 1, 2
+    scores 30, 30
+    time_limits 1, 2
+    mem_limits 5, 6
+  end
+
+  run 2 do
+    tests 3, 4, 5, 6, 7
+    score_each 50
+    time_limit_each 3                  
+    mem_limit_each 3 
+  end
+
+  run 3 do     
+    tests 8, 9, 10
+  end
+
+  test 8 do
+    score 55
+    time_limit 3
+    mem_limit 10
+  end
+ 
+  test 9 do
+    score 55
+  end
+
+  test 10 do
+    score 55
+    time_limit 1
+  end
+end
diff --git a/judge/scripts/test/data/ev/test_timeout/script/check b/judge/scripts/test/data/ev/test_timeout/script/check
new file mode 100755
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_timeout/script/check
@@ -0,0 +1,59 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+num_pattern = /^[0-9]*/
+if (output_file_content =~ num_pattern) == nil
+  report_wrong.call
+end
+
+output_i = output_file_content.to_i
+answer_i = answer_file_content.to_i
+
+if output_i == answer_i
+  report_correct.call
+else 
+  report_wrong.call
+end
diff --git a/judge/scripts/test/data/ev/test_timeout/test_cases/1/answer-1.txt b/judge/scripts/test/data/ev/test_timeout/test_cases/1/answer-1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_timeout/test_cases/1/answer-1.txt
@@ -0,0 +1,2 @@
+2
+
diff --git a/judge/scripts/test/data/ev/test_timeout/test_cases/1/input-1.txt b/judge/scripts/test/data/ev/test_timeout/test_cases/1/input-1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_timeout/test_cases/1/input-1.txt
@@ -0,0 +1,2 @@
+1 1
+
diff --git a/judge/scripts/test/data/ev/test_timeout/test_cases/2/answer-2.txt b/judge/scripts/test/data/ev/test_timeout/test_cases/2/answer-2.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_timeout/test_cases/2/answer-2.txt
@@ -0,0 +1,2 @@
+2
+
diff --git a/judge/scripts/test/data/ev/test_timeout/test_cases/2/input-2.txt b/judge/scripts/test/data/ev/test_timeout/test_cases/2/input-2.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_timeout/test_cases/2/input-2.txt
@@ -0,0 +1,2 @@
+1 1
+
diff --git a/judge/scripts/test/data/ev/test_timeout/test_cases/all_tests.cfg b/judge/scripts/test/data/ev/test_timeout/test_cases/all_tests.cfg
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_timeout/test_cases/all_tests.cfg
@@ -0,0 +1,24 @@
+problem do
+  num_tests 2
+  full_score 20
+  time_limit_each 1
+  mem_limit_each 16
+  score_each 10
+
+  test 1 do
+    time_limit 0.5
+  end
+
+  run 1 do
+    tests 1
+  end
+
+  test 2 do
+    time_limit 0.6
+  end
+
+  run 2 do
+    tests 2
+  end
+    
+end
diff --git a/judge/scripts/test/data/ev/test_yesno/script/check b/judge/scripts/test/data/ev/test_yesno/script/check
new file mode 100755
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_yesno/script/check
@@ -0,0 +1,64 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+
+########### THIS IS FOR CHECKING TEXT ##########
+
+# check visible text
+
+out_items = output_file_content.split
+ans_items = answer_file_content.split
+
+if out_items.length != ans_items.length
+  report_wrong.call
+else
+  out_items.length.times do |i|
+    if out_items[i]!=ans_items[i]
+      report_wrong.call
+    end
+  end
+  report_correct.call
+end
diff --git a/judge/scripts/test/data/ev/test_yesno/test_cases/1/answer-1.txt b/judge/scripts/test/data/ev/test_yesno/test_cases/1/answer-1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_yesno/test_cases/1/answer-1.txt
@@ -0,0 +1,2 @@
+yes
+
diff --git a/judge/scripts/test/data/ev/test_yesno/test_cases/1/input-1.txt b/judge/scripts/test/data/ev/test_yesno/test_cases/1/input-1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_yesno/test_cases/1/input-1.txt
@@ -0,0 +1,2 @@
+hello (this won't be read)
+
diff --git a/judge/scripts/test/data/ev/test_yesno/test_cases/all_tests.cfg b/judge/scripts/test/data/ev/test_yesno/test_cases/all_tests.cfg
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/ev/test_yesno/test_cases/all_tests.cfg
@@ -0,0 +1,12 @@
+problem do
+  num_tests 1
+  full_score 10
+  time_limit_each 1
+  mem_limit_each 64
+  score_each 10
+
+  run 1 do
+    tests 1
+  end
+
+end
diff --git a/judge/scripts/test/data/test1_compile_error.c b/judge/scripts/test/data/test1_compile_error.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/test1_compile_error.c
@@ -0,0 +1,13 @@
+/*
+LANG: C
+*/
+#include <stdio.h>
+
+int main()
+{
+  int a,
+  scanf("%d %d",&a,&b);
+  printf("%d\n",a+b);
+  return 0;
+}
+
diff --git a/judge/scripts/test/data/test1_correct.c b/judge/scripts/test/data/test1_correct.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/test1_correct.c
@@ -0,0 +1,13 @@
+/*
+LANG: C
+*/
+#include <stdio.h>
+
+int main()
+{
+  int a,b;
+  scanf("%d %d",&a,&b);
+  printf("%d\n",a+b);
+  return 0;
+}
+
diff --git a/judge/scripts/test/data/test2_05sec.c b/judge/scripts/test/data/test2_05sec.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/test2_05sec.c
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <time.h>
+#include <sys/resource.h>
+
+// run it for 1.5 s
+
+int main()
+{
+  int a,b;
+
+  int c=0;
+
+  scanf("%d %d",&a,&b);
+  printf("%d\n",a+b);
+
+  struct rusage ru;
+
+  while(1) {
+    c++;
+    b+=c;
+    while(c<100000) {
+      c++;
+      b+=c;
+    }
+    getrusage(RUSAGE_SELF,&ru);
+    double rtime = ru.ru_utime.tv_sec + ru.ru_stime.tv_sec;
+    rtime += (double)ru.ru_utime.tv_usec / 1000000.0;
+    rtime += (double)ru.ru_stime.tv_usec / 1000000.0;
+    if(rtime > 0.5)
+      break;
+  }
+  printf("%d\n",b);
+  exit(0);
+}
+
diff --git a/judge/scripts/test/data/test2_timeout.c b/judge/scripts/test/data/test2_timeout.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/test2_timeout.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main()
+{
+  int a,b;
+
+  scanf("%d %d",&a,&b);
+  while(1)
+    ;
+}
+
diff --git a/judge/scripts/test/data/test_request/input/in1.txt b/judge/scripts/test/data/test_request/input/in1.txt
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/test_request/input/in1.txt
@@ -0,0 +1,2 @@
+10
+20
diff --git a/judge/scripts/test/data/test_request/problems/test_normal/script/check b/judge/scripts/test/data/test_request/problems/test_normal/script/check
new file mode 100755
--- /dev/null
+++ b/judge/scripts/test/data/test_request/problems/test_normal/script/check
@@ -0,0 +1,47 @@
+#!/usr/bin/ruby
+
+problem_home = ENV['PROBLEM_HOME']
+require "#{problem_home}/script/test_dsl.rb"
+
+if ARGV.length < 2
+  puts "Usage: check <language> <test-number> [<output-file>]"
+  exit(0)
+end
+
+language = ARGV[0]
+test_num = ARGV[1].to_i
+if ARGV.length >= 3
+  output_file_name = ARGV[2]
+else
+  output_file_name = "output.txt"
+end
+
+load "#{problem_home}/test_cases/all_tests.cfg"
+problem = Problem.get_instance
+
+output_file = File.new(output_file_name, "r")
+answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
+result_file = File.new("check_result", "w")
+
+output_file_content = output_file.read
+answer_file_content = answer_file.read
+
+report_correct = lambda {
+  result_file.write "Correct\n"
+  result_file.write problem.get_score(test_num)
+  result_file.write "\n"  
+  result_file.close
+  exit(0)
+}
+
+report_wrong = lambda {
+  result_file.write "Incorrect\n"
+  result_file.write "0\n"
+  result_file.close
+  exit(0)
+}
+
+##################
+# Your code here #
+##################
+report_correct.call
diff --git a/judge/scripts/test/data/test_request/problems/test_normal/test_cases/1/answer-1.txt b/judge/scripts/test/data/test_request/problems/test_normal/test_cases/1/answer-1.txt
new file mode 100644
diff --git a/judge/scripts/test/data/test_request/problems/test_normal/test_cases/all_tests.cfg b/judge/scripts/test/data/test_request/problems/test_normal/test_cases/all_tests.cfg
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/test_request/problems/test_normal/test_cases/all_tests.cfg
@@ -0,0 +1,11 @@
+problem do
+  num_tests 1
+  full_score 10
+  time_limit_each 1
+  mem_limit_each 16
+  score_each 10
+
+  run 1 do
+    tests 1
+  end
+end
diff --git a/judge/scripts/test/data/test_run_stat.c b/judge/scripts/test/data/test_run_stat.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/test_run_stat.c
@@ -0,0 +1,29 @@
+/*
+LANG: C
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+int main()
+{
+  int a,b,d;
+  int i,j;
+  char *c = malloc(100000);
+  
+  scanf("%d %d",&a,&b);
+  d = a+b;
+  //  printf("%d\n",a+b);
+  for(j=0; j<1; j++)
+    for(i=0; i<100000000; i++) {
+      b+=a;
+      a++;
+    } 
+  if((c!=NULL) || (b<100))
+    b++;
+  if(b==100)
+    printf("hello");
+  else
+    printf("%d\n",d);
+  return 0;
+}
+
diff --git a/judge/scripts/test/data/yesno_access_problem_home.c b/judge/scripts/test/data/yesno_access_problem_home.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/yesno_access_problem_home.c
@@ -0,0 +1,12 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main()
+{
+  char* prob_home = getenv("PROBLEM_HOME");
+  if(prob_home!=NULL)
+    printf("yes\n");
+  else
+    printf("no\n");
+  exit(0);
+}
diff --git a/judge/scripts/test/data/yesno_open_file.c b/judge/scripts/test/data/yesno_open_file.c
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/data/yesno_open_file.c
@@ -0,0 +1,13 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main()
+{
+  FILE *fp = fopen("/bin/ls","r");
+  if(fp!=NULL) {
+    printf("yes\n");
+    fclose(fp);
+  } else
+    printf("no\n");
+  exit(0);
+}
diff --git a/judge/scripts/test/engine_spec.rb b/judge/scripts/test/engine_spec.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/engine_spec.rb
@@ -0,0 +1,316 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__),'engine_spec_helper')
+
+describe "A grader engine, when grading submissions" do
+
+  include GraderEngineHelperMethods
+
+  before(:each) do
+    @config = Grader::Configuration.get_instance
+
+    # this test is from Pong
+    @problem_test_normal = stub(Problem,
+                                :id => 1, :name => 'test_normal', 
+                                :full_score => 135)
+    @user_user1 = stub(User,
+                       :id => 1, :login => 'user1')
+    
+    @engine = Grader::Engine.new    
+    init_sandbox
+  end
+
+  it "should grade normal submission" do
+    grader_should(:grade => "test1_correct.c",
+                  :on => @problem_test_normal,
+                  :and_report => {
+                    :score => 135,
+                    :comment => /^(\[|P|\])+/})
+  end
+  
+
+  it "should produce error message when submission cannot compile" do
+    grader_should(:grade => "test1_compile_error.c",
+                  :on => @problem_test_normal,
+                  :and_report => {
+                    :score => 0,
+                    :comment => 'compilation error',
+                    :compiler_message => /[Ee]rror/})
+  end
+
+  it "should produce timeout error when submission runs forever" do
+    @problem_test_timeout = stub(Problem,
+                                 :id => 1, :name => 'test_timeout', 
+                                 :full_score => 10)
+    grader_should(:grade => "test2_timeout.c",
+                  :on => @problem_test_timeout,
+                  :and_report => {
+                    :score => 0,
+                    :comment => 'TT'})
+  end
+
+  it "should produce timeout error correctly with fractional running time and fractional time limits" do
+     @problem_test_timeout = stub(Problem,
+                                 :id => 1, :name => 'test_timeout', 
+                                 :full_score => 20)
+    grader_should(:grade => "test2_05sec.c",
+                  :on => @problem_test_timeout,
+                  :and_report => {
+                    :score => 10,
+                    :comment => 'TP'})
+  end
+  
+  it "should produce runtime error when submission uses too much static memory" do
+    @problem_test_memory = stub(Problem,
+                                :id => 1, :name => 'test_memory', 
+                                :full_score => 20)
+    grader_should(:grade => "add_too_much_memory_static.c",
+                  :on => @problem_test_memory,
+                  :and_report => {
+                    :score => 10,
+                    :comment => /[^P]P/})
+  end
+
+  it "should not allow submission to allocate too much dynamic memory" do
+    @problem_test_memory = stub(Problem,
+                                :id => 1, :name => 'test_memory', 
+                                :full_score => 20)
+    grader_should(:grade => "add_too_much_memory_dynamic.c",
+                  :on => @problem_test_memory,
+                  :and_report => {
+                    :score => 10,
+                    :comment => /[^P]P/})
+  end
+
+  it "should score test runs correctly when submission fails in some test case" do
+    grader_should(:grade => "add_fail_test_case_1.c",
+                  :on => @problem_test_normal,
+                  :and_report => {
+                    :score => 105,
+                    :comment => /^.*(-|x).*$/})
+  end
+
+  it "should fail submission with non-zero exit status" do
+    grader_should(:grade => "add_nonzero_exit_status.c",
+                  :on => @problem_test_normal,
+                  :and_report => {
+                    :score => 0,
+                    :comment => /^(\[|x|\])+$/})
+  end
+
+  it "should not allow malicious submission to see PROBLEM_HOME" do
+    problem_test_yesno =  stub(Problem,
+                                :id => 1, :name => 'test_yesno', 
+                                :full_score => 10)
+    grader_should(:grade => "yesno_access_problem_home.c",
+                  :on => problem_test_yesno,
+                  :and_report => {
+                    :score => 0,
+                    :comment => /(-|x)/})
+  end
+
+  it "should not allow malicious submission to open files" do
+    problem_test_yesno =  stub(Problem,
+                                :id => 1, :name => 'test_yesno', 
+                                :full_score => 10)
+    grader_should(:grade => "yesno_open_file.c",
+                  :on => problem_test_yesno,
+                  :and_report => {
+                    :score => 0,
+                    :comment => /(-|x)/})
+  end
+
+  def grader_should(args)
+    @user1 = stub(User,
+                  :id => 1, :login => 'user1')
+    submission = 
+      create_submission_from_file(1, @user1, args[:on], args[:grade])
+    submission.should_receive(:graded_at=)
+
+    expected_score = args[:and_report][:score]
+    expected_comment = args[:and_report][:comment]
+    if args[:and_report][:compiler_message]!=nil
+      expected_compiler_message = args[:and_report][:compiler_message]
+    else
+      expected_compiler_message = ''
+    end
+
+    submission.should_receive(:points=).with(expected_score)
+    submission.should_receive(:grader_comment=).with(expected_comment)
+    submission.should_receive(:compiler_message=).with(expected_compiler_message)
+    submission.should_receive(:save)
+
+    @engine.grade(submission)
+  end
+
+  protected
+
+  def create_normal_submission_mock_from_file(source_fname)
+    create_submission_from_file(1, @user_user1, @problem_test_normal, source_fname)
+  end
+  
+end
+
+describe "A grader engine, when grading test requests" do
+
+  include GraderEngineHelperMethods
+
+  before(:each) do
+    @config = Grader::Configuration.get_instance
+    @engine = Grader::Engine.new(Grader::TestRequestRoomMaker.new,
+                                 Grader::TestRequestReporter.new)
+    init_sandbox
+  end
+
+  it "should report error if there is no problem template" do
+    problem = stub(Problem,
+                   :id => 1, :name => 'nothing')
+    grader_should(:grade => 'test1_correct.c',
+                  :on => problem,
+                  :with => 'in1.txt',
+                  :and_report => {
+                    :graded_at= => nil,
+                    :compiler_message= => '',
+                    :grader_comment= => '',
+                    :running_stat= => /template not found/,
+                    :running_time= => nil,
+                    :exit_status= => nil,
+                    :memory_usage= => nil,
+                    :save => nil})
+  end
+
+  it "should run test request and produce output file" do
+    problem = stub(Problem,
+                   :id => 1, :name => 'test_normal')
+    grader_should(:grade => 'test1_correct.c',
+                  :on => problem,
+                  :with => 'in1.txt',
+                  :and_report => {
+                    :graded_at= => nil,
+                    :compiler_message= => '',
+                    :grader_comment= => '',
+                    :running_stat= => /0.0\d* sec./, 
+                    :output_file_name= => lambda { |fname|
+                      File.exists?(fname).should be_true
+                    },
+                    :running_time= => nil,
+                    :exit_status= => nil,
+                    :memory_usage= => nil,
+                    :save => nil})
+  end
+
+  it "should clean up problem directory after running test request" do
+    problem = stub(Problem,
+                   :id => 1, :name => 'test_normal')
+    grader_should(:grade => 'test1_correct.c',
+                  :on => problem,
+                  :with => 'in1.txt',
+                  :and_report => {
+                    :graded_at= => nil,
+                    :compiler_message= => '',
+                    :grader_comment= => '',
+                    :running_stat= => nil, 
+                    :output_file_name= => nil,
+                    :running_time= => nil,
+                    :exit_status= => nil,
+                    :memory_usage= => nil,
+                    :save => nil})
+    File.exists?(@config.user_result_dir + "/test_request/test_normal/test_cases/1/input-1.txt").should be_false
+  end
+
+  it "should compile test request with error and report compilation error" do
+    problem = stub(Problem,
+                   :id => 1, :name => 'test_normal')
+    grader_should(:grade => 'test1_compile_error.c',
+                  :on => problem,
+                  :with => 'in1.txt',
+                  :and_report => {
+                    :graded_at= => nil,
+                    :compiler_message= => /.+/,
+                    :grader_comment= => /[Cc]ompil.*error/,
+                    :running_stat= => '', 
+                    :save => nil})
+  end
+
+  it "should report exit status" do
+    problem = stub(Problem,
+                   :id => 1, :name => 'test_normal')
+    grader_should(:grade => 'add_nonzero_exit_status.c',
+                  :on => problem,
+                  :with => 'in1.txt',
+                  :and_report => {
+                    :graded_at= => nil,
+                    :compiler_message= => '',
+                    :grader_comment= => '',
+                    :running_stat= => /[Ee]xit.*status.*10.*0\.0\d* sec/m,
+                    :output_file_name= => lambda { |fname|
+                      File.exists?(fname).should be_true
+                    },
+                    :running_time= => nil,
+                    :exit_status= => /10/,
+                    :memory_usage= => nil,
+                    :save => nil})
+  end
+
+  it "should produce running statistics for normal submission" do
+    problem = stub(Problem,
+                   :id => 1, :name => 'test_normal')
+    grader_should(:grade => 'test_run_stat.c',
+                  :on => problem,
+                  :with => 'in1.txt',
+                  :and_report => {
+                    :graded_at= => nil,
+                    :compiler_message= => '',
+                    :grader_comment= => '',
+                    :running_stat= => nil,
+                    :output_file_name= => lambda { |fname|
+                      File.exists?(fname).should be_true
+                    },
+                    :running_time= => lambda { |t|
+                      (t>=0.14) and (t<=0.16)
+                    },
+                    :exit_status= => nil,
+                    :memory_usage= => lambda { |s|
+                      (s>=500) and (s<=1000)
+                    },
+                    :save => nil})
+  end
+
+  protected
+  def grader_should(args)
+    @user1 = stub(User,
+                  :id => 1, :login => 'user1')
+
+    problem = args[:on]
+    input_file = @config.test_request_input_base_dir + "/" + args[:with]
+
+    submission = 
+      create_submission_from_file(1, @user1, args[:on], args[:grade])
+
+    test_request = stub(TestRequest,
+                        :id => 1,
+                        :user => @user1,
+                        :problem => problem,
+                        :submission => submission,
+                        :input_file_name => input_file,
+                        :language => submission.language,
+                        :problem_name => problem.name)
+
+    expectations = args[:and_report]
+
+    expectations.each do |key,val|
+      if val==nil
+        test_request.should_receive(key)
+      elsif val.class == Proc
+        test_request.should_receive(key) { |fname|
+          val.call(fname)
+        }
+      else
+        test_request.should_receive(key).with(val)
+      end
+    end
+
+    @engine.grade(test_request)
+  end
+
+end
+
diff --git a/judge/scripts/test/engine_spec_helper.rb b/judge/scripts/test/engine_spec_helper.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/engine_spec_helper.rb
@@ -0,0 +1,30 @@
+module GraderEngineHelperMethods
+
+  def clear_sandbox
+    config = Grader::Configuration.get_instance
+    clear_cmd = "rm -rf #{config.test_sandbox_dir}/*"
+    system(clear_cmd)
+  end
+
+  def init_sandbox
+    config = Grader::Configuration.get_instance
+    clear_sandbox
+    FileUtils.mkdir_p config.user_result_dir
+    cp_cmd = "cp -R #{config.test_data_dir}/ev #{config.test_sandbox_dir}"
+    system(cp_cmd)
+  end
+
+  def create_submission_from_file(id, user, problem, 
+                                  source_fname, language=nil)
+
+    language = stub(Language, :name => 'c', :ext => 'c') if language==nil
+
+    config = Grader::Configuration.get_instance
+    source = File.open(config.test_data_dir + "/" + source_fname).read
+    stub(Submission,
+         :id => id, :user => user, :problem => problem,
+         :source => source, :language => language)
+  end
+
+end
+
diff --git a/judge/scripts/test/engine_test.rb b/judge/scripts/test/engine_test.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/engine_test.rb
@@ -0,0 +1,152 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+require File.join(File.dirname(__FILE__),'test_helper')
+
+class GraderEngineTest < UnitTest.TestCase
+
+  def setup
+    @@lang_c = stub(:name => 'c', :ext => 'c')
+    @@lang_cpp = stub(:name => 'cpp', :ext => 'cpp')
+    @@lang_pas = stub(:name => 'pas', :ext => 'pas')
+
+    @config = Grader::Configuration.get_instance
+
+    @problem_test1 = stub(:id => 1, :name => 'test1', :full_score => 135)
+    @user_user1 = stub(:id => 1, :login => 'user1')
+
+    @engine = Grader::Engine.new    
+
+    init_sandbox
+  end
+
+  def teardown
+  end
+
+  def test_grade_oldest_task_with_no_submission
+    Task.expects(:get_inqueue_and_change_status).returns(nil)
+    assert_equal nil, @engine.grade_oldest_task, 'should return nil when there is no task'
+  end
+
+  def test_normal_submission
+    submission = create_test1_submission_mock_from_file("test1_correct.c")
+
+    submission.expects(:graded_at=)
+    submission.expects(:points=).with(135)
+    submission.expects(:grader_comment=).with do |value|
+      /^PASSED/.match(value)
+    end
+    submission.expects(:compiler_message=).with('')
+    submission.expects(:save)
+
+    @engine.grade(submission)
+  end
+
+  def test_compile_error_submission
+    submission = create_test1_submission_mock_from_file("test1_compile_error.c")
+
+    submission.expects(:graded_at=)
+    submission.expects(:points=).with(0)
+    submission.expects(:grader_comment=).with('FAILED: compile error')
+    submission.expects(:compiler_message=) do |value|
+      /[Ee]rror/.match value
+    end
+    submission.expects(:save)
+
+    @engine.grade(submission)
+  end
+
+  def test_timeout_submission
+    @problem_test2 = stub(:id => 1, :name => 'test2', :full_score => 10)
+    @user_user1 = stub(:id => 1, :login => 'user1')
+
+    submission = create_submission_from_file(1, @user_user1, @problem_test2,
+                                             "test2_timeout.c")
+
+    submission.expects(:graded_at=)
+    submission.expects(:points=).with(0)
+    submission.expects(:grader_comment=).with do |value|
+      /^FAILED: TT$/.match value
+    end
+    submission.expects(:compiler_message=).with('')
+    submission.expects(:save)
+
+    @engine.grade(submission)
+  end
+
+  def test_timeout_submission_running_one_and_a_half_second
+    @problem_test2 = stub(:id => 1, :name => 'test2', :full_score => 20)
+    @user_user1 = stub(:id => 1, :login => 'user1')
+
+    submission = create_submission_from_file(1, @user_user1, @problem_test2,
+                                             "test2_1-5sec.c")
+
+    submission.expects(:graded_at=)
+    submission.expects(:points=).with(10)
+    submission.expects(:grader_comment=).with do |value|
+      /^FAILED: TP$/.match value
+    end
+    submission.expects(:compiler_message=).with('')
+    submission.expects(:save)
+
+    @engine.grade(submission)
+  end
+
+  def test_grade_oldest_task
+    # mock submission
+    submission = create_test1_submission_mock_from_file("test1_correct.c")
+
+    submission.expects(:graded_at=)
+    submission.expects(:points=).with(135)
+    submission.expects(:grader_comment=).with do |value|
+      /^PASSED/.match(value)
+    end
+    submission.expects(:compiler_message=).with('')
+    submission.expects(:save)
+
+    # mock task
+    task = stub(:id => 1, :submission_id => submission.id)
+    Task.expects(:get_inqueue_and_change_status).returns(task)
+    task.expects(:status_complete!)
+
+    # mock Submission
+    Submission.expects(:find).with(task.submission_id).returns(submission)
+
+    @engine.grade_oldest_task
+  end
+
+  def test_grade_oldest_task_with_grader_process
+    grader_process = stub
+    grader_process.expects(:report_active)
+
+    @engine = Grader::Engine.new(grader_process)
+
+    test_grade_oldest_task
+  end
+
+  protected
+
+  def clear_sandbox
+    clear_cmd = "rm -rf #{@config.test_sandbox_dir}/*"
+    system(clear_cmd)
+  end
+
+  def init_sandbox
+    clear_sandbox
+    Dir.mkdir @config.user_result_dir
+    cp_cmd = "cp -R #{@config.test_data_dir}/ev #{@config.test_sandbox_dir}"
+    system(cp_cmd)
+  end
+
+  def create_submission_from_file(id, user, problem, source_fname, language = @@lang_c)
+    source = File.open(@config.test_data_dir + "/" + source_fname).read
+    stub(:id => id, :user => user, :problem => problem,
+         :source => source, :language => language)
+  end
+
+  def create_test1_submission_mock_from_file(source_fname)
+    create_submission_from_file(1, @user_user1, @problem_test1, source_fname)
+  end
+  
+end
diff --git a/judge/scripts/test/import_helper_test.rb b/judge/scripts/test/import_helper_test.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/import_helper_test.rb
@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+require File.join(File.dirname(__FILE__),'../lib/import_helper')
+
+class ImportHelperTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_build_only_singleton_testruns
+    testrun_info = build_testrun_info(3,['1','2','3'])
+    assert_equal [[[1,'1']],[[2,'2']],[[3,'3']]], testrun_info, 'should build singleton testruns'
+  end
+
+  def test_build_only_singleton_testruns2
+    testrun_info = build_testrun_info(4,['1','2','3','4'])
+    assert_equal [[[1,'1']],[[2,'2']],[[3,'3']],[[4,'4']]], testrun_info, 'should build singleton testruns'
+  end
+
+  def test_build_testruns_when_testcases_defined_by_appending_alphabets
+    testrun_info = build_testrun_info(4,['1a','1b','2','3a','3b','4'])
+    assert_equal [[[1,'1a'],[2,'1b']],
+                  [[3,'2']],
+                  [[4,'3a'],[5,'3b']],
+                  [[6,'4']]], testrun_info
+  end
+
+  def test_build_testruns_when_testcases_defined_by_appending_dashed_numbers
+    testrun_info = build_testrun_info(4,['1-1','1-2','2','3-1','3-2','4'])
+    assert_equal [[[1,'1-1'],[2,'1-2']],
+                  [[3,'2']],
+                  [[4,'3-1'],[5,'3-2']],
+                  [[6,'4']]], testrun_info
+  end
+end
diff --git a/judge/scripts/test/runner_spec.rb b/judge/scripts/test/runner_spec.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/runner_spec.rb
@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__),'engine_spec_helper')
+
+describe "A grader runner, when grade task" do
+
+  include GraderEngineHelperMethods
+
+  before(:each) do
+    @config = Grader::Configuration.get_instance
+    @problem_test_normal = stub(Problem,
+                                :id => 1, :name => 'test_normal', 
+                                :full_score => 135)
+    @user_user1 = stub(User,
+                       :id => 1, :login => 'user1')
+    
+    @engine = Grader::Engine.new    
+    @runner = Grader::Runner.new(@engine)
+    init_sandbox
+  end
+
+  it "should just return nil when there is no submission" do
+    Task.should_receive(:get_inqueue_and_change_status).and_return(nil)
+    @runner.grade_oldest_task.should be_nil
+  end
+
+  it "should grade oldest task in queue" do
+    submission = create_normal_submission_mock_from_file("test1_correct.c")
+
+    submission.should_receive(:graded_at=)
+    submission.should_receive(:points=).with(135)
+    submission.should_receive(:grader_comment=).with(/^PASSED/)
+    submission.should_receive(:compiler_message=).with('')
+    submission.should_receive(:save)
+
+    # mock task
+    task = stub(Task,:id => 1, :submission_id => submission.id)
+    Task.should_receive(:get_inqueue_and_change_status).and_return(task)
+    task.should_receive(:status_complete!)
+
+    # mock Submission
+    Submission.should_receive(:find).
+      with(task.submission_id).
+      and_return(submission)
+
+    @runner.grade_oldest_task
+  end
+
+  # to be converted
+  def test_grade_oldest_task_with_grader_process
+    grader_process = stub
+    grader_process.expects(:report_active)
+
+    @runner = Grader::Runner.new(@engine,grader_process)
+
+    test_grade_oldest_task
+  end
+
+  protected
+
+  def create_normal_submission_mock_from_file(source_fname)
+    create_submission_from_file(1, @user_user1, @problem_test_normal, source_fname)
+  end
+  
+end
+
diff --git a/judge/scripts/test/spec_helper.rb b/judge/scripts/test/spec_helper.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/spec_helper.rb
@@ -0,0 +1,25 @@
+
+# This test helper loads the grader's environment and rails environment
+
+GRADER_ENV = 'test'
+require File.join(File.dirname(__FILE__),'../config/environment')
+
+
+# this shall be removed soon
+RAILS_ENV = Grader::Configuration.get_instance.rails_env
+require RAILS_ROOT + '/config/environment'
+
+# make sure not to access real database!
+# taken from http://blog.jayfields.com/2006/06/ruby-on-rails-unit-tests.html
+
+class UnitTest
+  def self.TestCase
+    class << ActiveRecord::Base
+      def connection
+        raise 'You cannot access the database from a unit test'
+#        raise InvalidActionError, 'You cannot access the database from a unit test', caller
+      end
+    end
+    Test::Unit::TestCase
+  end
+end
diff --git a/judge/scripts/test/test_helper.rb b/judge/scripts/test/test_helper.rb
new file mode 100644
--- /dev/null
+++ b/judge/scripts/test/test_helper.rb
@@ -0,0 +1,25 @@
+
+# This test helper loads the grader's environment and rails environment
+
+GRADER_ENV = 'test'
+require File.join(File.dirname(__FILE__),'../config/environment')
+
+
+# this shall be removed soon
+RAILS_ENV = Grader::Configuration.get_instance.rails_env
+require RAILS_ROOT + '/config/environment'
+
+# make sure not to access real database!
+# taken from http://blog.jayfields.com/2006/06/ruby-on-rails-unit-tests.html
+
+class UnitTest
+  def self.TestCase
+    class << ActiveRecord::Base
+      def connection
+        raise 'You cannot access the database from a unit test'
+#        raise InvalidActionError, 'You cannot access the database from a unit test', caller
+      end
+    end
+    Test::Unit::TestCase
+  end
+end