cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r22:a8f2ad67d212` public

parent | child

Description:

Merged new-arch-branch changes 61:73 into the trunk git-svn-id: http://theory.cpe.ku.ac.th/grader/judge/trunk/scripts@74 6386c4cd-e34a-4fa8-8920-d93eb39b512e

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r22:a8f2ad67d212 - Mon, 03 Mar 2008 18:03:00 - 52 files changed: 851 inserted, 236 deleted

config/env_exam.rb.SAMPLE created 644 ¶ +20

			@@ -0,0 +1,20
		1	+
		2	+
		3	+ Grader::Initializer.run do \|config\|
		4	+
		5	+ config.problems_dir = "/home/jittat/grader/ev"
		6	+ config.user_result_dir = "/home/jittat/grader/result"
		7	+
		8	+ config.talkative = true
		9	+
		10	+ config.report_grader = true
		11	+
		12	+ config.report_comment = lambda do \|comment\|
		13	+ if comment.chomp =~ /^P+$/ # all P's
		14	+ 'passed'
		15	+ else
		16	+ 'failed'
		17	+ end
		18	+ end
		19	+
		20	+ end

config/env_grading.rb.SAMPLE created 644 ¶ +16

			@@ -0,0 +1,16
		1	+
		2	+
		3	+ Grader::Initializer.run do \|config\|
		4	+
		5	+ config.problems_dir = "/home/jittat/grader/ev"
		6	+ config.user_result_dir = "/home/jittat/grader/result"
		7	+
		8	+ config.talkative = true
		9	+
		10	+ config.report_grader = true
		11	+
		12	+ config.report_comment = lambda do \|comment\|
		13	+ comment.chomp
		14	+ end
		15	+
		16	+ end

config/env_test.rb.SAMPLE created 644 ¶ +25

			@@ -0,0 +1,25
		1	+
		2	+
		3	+ Grader::Initializer.run do \|config\|
		4	+
		5	+ config.problems_dir = "/home/jittat/grader/scripts/test/sandbox/ev"
		6	+ config.user_result_dir = "/home/jittat/grader/scripts/test/sandbox/result"
		7	+
		8	+ config.talkative = true
		9	+
		10	+ config.report_grader = false
		11	+
		12	+ config.rails_env = 'test'
		13	+
		14	+ config.report_comment = lambda do \|comment\|
		15	+ comment.chomp
		16	+ end
		17	+
		18	+ class << config
		19	+ attr_accessor :test_data_dir, :test_sandbox_dir
		20	+ end
		21	+
		22	+ config.test_data_dir = "/home/jittat/grader/scripts/test/data"
		23	+ config.test_sandbox_dir = "/home/jittat/grader/scripts/test/sandbox"
		24	+
		25	+ end

config/environment.rb.SAMPLE created 644 ¶ +11

			@@ -0,0 +1,11
		1	+
		2	+ # Rails app directory
		3	+ RAILS_ROOT = "/home/jittat/web_grader"
		4	+
		5	+ GRADER_ROOT = "/home/jittat/grader/scripts"
		6	+
		7	+ require File.join(File.dirname(__FILE__),'../lib/boot')
		8	+
		9	+ # load the required environment file
		10	+ require File.dirname(__FILE__) + "/env_#{GRADER_ENV}.rb"
		11	+

lib/boot.rb created 644 ¶ +5

			@@ -0,0 +1,5
		1	+
		2	+ require File.join(File.dirname(__FILE__), 'configuration')
		3	+ require File.join(File.dirname(__FILE__), 'initializer')
		4	+ require File.join(File.dirname(__FILE__), 'engine')
		5	+

lib/configuration.rb created 644 ¶ +38

			@@ -0,0 +1,38
		1	+
		2	+ module Grader
		3	+
		4	+ class Configuration
		5	+
		6	+ private_class_method :new
		7	+
		8	+ attr_accessor :problems_dir
		9	+ attr_accessor :user_result_dir
		10	+ attr_accessor :talkative
		11	+ attr_accessor :report_grader
		12	+ attr_accessor :grader_hostname
		13	+ attr_accessor :report_comment
		14	+ attr_accessor :rails_env
		15	+
		16	+ @@instance = nil
		17	+
		18	+ def self.get_instance
		19	+ if @@instance==nil
		20	+ @@instance = new
		21	+ end
		22	+ @@instance
		23	+ end
		24	+
		25	+ private
		26	+ def initialize
		27	+ @talkative = false
		28	+ @report_grader = false
		29	+ @grader_hostname = `hostname`.chomp
		30	+
		31	+ @rails_env = 'development'
		32	+
		33	+ @report_comment = lambda { \|comment\| comment }
		34	+ end
		35	+
		36	+ end
		37	+
		38	+ end

lib/engine.rb created 644 ¶ +183

			@@ -0,0 +1,183
		1	+
		2	+ module Grader
		3	+
		4	+ class Engine
		5	+
		6	+ def initialize(grader_process=nil)
		7	+ @config = Grader::Configuration.get_instance
		8	+ @grader_process = grader_process
		9	+ end
		10	+
		11	+ def grade(sub)
		12	+ current_dir = `pwd`.chomp
		13	+
		14	+ submission_id = sub.id
		15	+ user = sub.user
		16	+ problem = sub.problem
		17	+
		18	+ # TODO: will have to create real exception for this
		19	+ raise "improper submission" if user==nil or problem==nil
		20	+
		21	+ language = sub.language.name
		22	+ lang_ext = sub.language.ext
		23	+ # FIX THIS
		24	+ talk 'some hack on language'
		25	+ if language == 'cpp'
		26	+ language = 'c++'
		27	+ end
		28	+
		29	+ user_dir = "#{@config.user_result_dir}/#{user.login}"
		30	+ problem_out_dir = "#{user_dir}/#{problem.name}"
		31	+ submission_out_dir = "#{user_dir}/#{problem.name}/#{submission_id}"
		32	+
		33	+ mkdir_if_does_not_exist(user_dir)
		34	+ mkdir_if_does_not_exist(problem_out_dir)
		35	+ mkdir_if_does_not_exist(submission_out_dir)
		36	+
		37	+ problem_home = "#{@config.problems_dir}/#{problem.name}"
		38	+ source_name = "#{problem.name}.#{lang_ext}"
		39	+
		40	+ save_source(sub,submission_out_dir,source_name)
		41	+
		42	+ copy_log = copy_script(problem_home)
		43	+
		44	+ call_judge(problem_home,language,submission_out_dir,source_name)
		45	+ save_result(sub,read_result("#{submission_out_dir}/test-result"))
		46	+
		47	+ clear_script(copy_log,problem_home)
		48	+
		49	+ Dir.chdir(current_dir)
		50	+ end
		51	+
		52	+ def grade_oldest_task
		53	+ task = Task.get_inqueue_and_change_status(Task::STATUS_GRADING)
		54	+ if task!=nil
		55	+ @grader_process.report_active(task) if @grader_process!=nil
		56	+
		57	+ submission = Submission.find(task.submission_id)
		58	+ grade(submission)
		59	+ task.status_complete!
		60	+ end
		61	+ return task
		62	+ end
		63	+
		64	+ def grade_problem(problem)
		65	+ users = User.find(:all)
		66	+ users.each do \|u\|
		67	+ puts "user: #{u.login}"
		68	+ last_sub = Submission.find(:first,
		69	+ :conditions => "user_id = #{u.id} and " +
		70	+ "problem_id = #{prob.id}",
		71	+ :order => 'submitted_at DESC')
		72	+ if last_sub!=nil
		73	+ grade(last_sub)
		74	+ end
		75	+ end
		76	+ end
		77	+
		78	+ protected
		79	+
		80	+ def talk(str)
		81	+ if @config.talkative
		82	+ puts str
		83	+ end
		84	+ end
		85	+
		86	+ def save_source(submission,dir,fname)
		87	+ f = File.open("#{dir}/#{fname}","w")
		88	+ f.write(submission.source)
		89	+ f.close
		90	+ end
		91	+
		92	+ def call_judge(problem_home,language,submission_out_dir,fname)
		93	+ ENV['PROBLEM_HOME'] = problem_home
		94	+
		95	+ talk submission_out_dir
		96	+ Dir.chdir submission_out_dir
		97	+ cmd = "#{problem_home}/script/judge #{language} #{fname}"
		98	+ talk "CMD: #{cmd}"
		99	+ system(cmd)
		100	+ end
		101	+
		102	+ def read_result(test_result_dir)
		103	+ cmp_msg_fname = "#{test_result_dir}/compiler_message"
		104	+ cmp_file = File.open(cmp_msg_fname)
		105	+ cmp_msg = cmp_file.read
		106	+ cmp_file.close
		107	+
		108	+ result_fname = "#{test_result_dir}/result"
		109	+ comment_fname = "#{test_result_dir}/comment"
		110	+ if FileTest.exist?(result_fname)
		111	+ result_file = File.open(result_fname)
		112	+ result = result_file.readline.to_i
		113	+ result_file.close
		114	+
		115	+ comment_file = File.open(comment_fname)
		116	+ comment = comment_file.readline.chomp
		117	+ comment_file.close
		118	+
		119	+ return {:points => result,
		120	+ :comment => comment,
		121	+ :cmp_msg => cmp_msg}
		122	+ else
		123	+ return {:points => 0,
		124	+ :comment => 'compile error',
		125	+ :cmp_msg => cmp_msg}
		126	+ end
		127	+ end
		128	+
		129	+ def save_result(submission,result)
		130	+ problem = submission.problem
		131	+ submission.graded_at = Time.now
		132	+ points = result[:points]
		133	+ submission.points = points
		134	+ comment = @config.report_comment.call(result[:comment])
		135	+ if problem == nil
		136	+ submission.grader_comment = 'PASSED: ' + comment + '(problem is nil)'
		137	+ elsif points == problem.full_score
		138	+ submission.grader_comment = 'PASSED: ' + comment
		139	+ else
		140	+ submission.grader_comment = 'FAILED: ' + comment
		141	+ end
		142	+ submission.compiler_message = result[:cmp_msg]
		143	+ submission.save
		144	+ end
		145	+
		146	+ def get_std_script_dir
		147	+ GRADER_ROOT + '/std-script'
		148	+ end
		149	+
		150	+ def copy_script(problem_home)
		151	+ script_dir = "#{problem_home}/script"
		152	+ std_script_dir = get_std_script_dir
		153	+
		154	+ raise "std-script directory not found" if !FileTest.exist?(std_script_dir)
		155	+
		156	+ scripts = Dir[std_script_dir + '/*']
		157	+
		158	+ copied = []
		159	+
		160	+ scripts.each do \|s\|
		161	+ fname = File.basename(s)
		162	+ if !FileTest.exist?("#{script_dir}/#{fname}")
		163	+ copied << fname
		164	+ system("cp #{s} #{script_dir}")
		165	+ end
		166	+ end
		167	+
		168	+ return copied
		169	+ end
		170	+
		171	+ def clear_script(log,problem_home)
		172	+ log.each do \|s\|
		173	+ system("rm #{problem_home}/script/#{s}")
		174	+ end
		175	+ end
		176	+
		177	+ def mkdir_if_does_not_exist(dirname)
		178	+ Dir.mkdir(dirname) if !FileTest.exist?(dirname)
		179	+ end
		180	+
		181	+ end
		182	+
		183	+ end

lib/initializer.rb created 644 ¶ +13

			@@ -0,0 +1,13
		1	+
		2	+ module Grader
		3	+
		4	+ class Initializer
		5	+
		6	+ def self.run(&block)
		7	+ config = Grader::Configuration.get_instance
		8	+ yield config
		9	+ end
		10	+
		11	+ end
		12	+
		13	+ end

test/data/ev/test1/script/check created 755 ¶ +59

			@@ -0,0 +1,59
		1	+ #!/usr/bin/ruby
		2	+
		3	+ problem_home = ENV['PROBLEM_HOME']
		4	+ require "#{problem_home}/script/test_dsl.rb"
		5	+
		6	+ if ARGV.length < 2
		7	+ puts "Usage: check <language> <test-number> [<output-file>]"
		8	+ exit(0)
		9	+ end
		10	+
		11	+ language = ARGV[0]
		12	+ test_num = ARGV[1].to_i
		13	+ if ARGV.length >= 3
		14	+ output_file_name = ARGV[2]
		15	+ else
		16	+ output_file_name = "output.txt"
		17	+ end
		18	+
		19	+ load "#{problem_home}/test_cases/all_tests.cfg"
		20	+ problem = Problem.get_instance
		21	+
		22	+ output_file = File.new(output_file_name, "r")
		23	+ answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
		24	+ result_file = File.new("check_result", "w")
		25	+
		26	+ output_file_content = output_file.read
		27	+ answer_file_content = answer_file.read
		28	+
		29	+ report_correct = lambda {
		30	+ result_file.write "Correct\n"
		31	+ result_file.write problem.get_score(test_num)
		32	+ result_file.write "\n"
		33	+ result_file.close
		34	+ exit(0)
		35	+ }
		36	+
		37	+ report_wrong = lambda {
		38	+ result_file.write "Incorrect\n"
		39	+ result_file.write "0\n"
		40	+ result_file.close
		41	+ exit(0)
		42	+ }
		43	+
		44	+ ##################
		45	+ # Your code here #
		46	+ ##################
		47	+ num_pattern = /^[0-9]*/
		48	+ if (output_file_content =~ num_pattern) == nil
		49	+ report_wrong.call
		50	+ end
		51	+
		52	+ output_i = output_file_content.to_i
		53	+ answer_i = answer_file_content.to_i
		54	+
		55	+ if output_i == answer_i
		56	+ report_correct.call
		57	+ else
		58	+ report_wrong.call
		59	+ end

test/data/ev/test1/test_cases/1/answer-1.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 2 No newline at end of file

test/data/ev/test1/test_cases/1/input-1.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 1 1 No newline at end of file

test/data/ev/test1/test_cases/10/answer-10.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ -256 No newline at end of file

test/data/ev/test1/test_cases/10/input-10.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ -128 -128 No newline at end of file

test/data/ev/test1/test_cases/2/answer-2.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 32 No newline at end of file

test/data/ev/test1/test_cases/2/input-2.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 20 12 No newline at end of file

test/data/ev/test1/test_cases/3/answer-3.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 4 No newline at end of file

test/data/ev/test1/test_cases/3/input-3.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 1 3 No newline at end of file

test/data/ev/test1/test_cases/3/test.cfg created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ mem_limit 32 No newline at end of file

test/data/ev/test1/test_cases/4/answer-4.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 64 No newline at end of file

test/data/ev/test1/test_cases/4/input-4.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 32 32 No newline at end of file

test/data/ev/test1/test_cases/5/answer-5.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ -2 No newline at end of file

test/data/ev/test1/test_cases/5/input-5.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ -1 -1 No newline at end of file

test/data/ev/test1/test_cases/6/answer-6.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ -32 No newline at end of file

test/data/ev/test1/test_cases/6/input-6.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ -16 -16 No newline at end of file

test/data/ev/test1/test_cases/7/answer-7.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 0 No newline at end of file

test/data/ev/test1/test_cases/7/input-7.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 0 0 No newline at end of file

test/data/ev/test1/test_cases/8/answer-8.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ -1 No newline at end of file

test/data/ev/test1/test_cases/8/input-8.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 0 -1 No newline at end of file

test/data/ev/test1/test_cases/8/test.cfg created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ mem_limit 64 No newline at end of file

test/data/ev/test1/test_cases/9/answer-9.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 256 No newline at end of file

test/data/ev/test1/test_cases/9/input-9.txt created 644 ¶ +1

			@@ -0,0 +1,1
		1	+ 128 128 No newline at end of file

test/data/ev/test1/test_cases/all_tests.cfg created 644 ¶ +39

			@@ -0,0 +1,39
		1	+ problem do
		2	+ num_tests 10
		3	+ full_score 135
		4	+ time_limit_each 1
		5	+ mem_limit_each 11
		6	+ score_each 10
		7	+
		8	+ run 1 do
		9	+ tests 1, 2
		10	+ scores 10, 20
		11	+ time_limits 1, 2
		12	+ mem_limits 5, 6
		13	+ end
		14	+
		15	+ run 2 do
		16	+ tests 3, 4, 5, 6, 7
		17	+ score_each 10
		18	+ time_limit_each 3
		19	+ mem_limit_each 3
		20	+ end
		21	+
		22	+ run 3 do
		23	+ tests 8, 9, 10
		24	+ end
		25	+
		26	+ test 8 do
		27	+ score 30
		28	+ time_limit 3
		29	+ mem_limit 10
		30	+ end
		31	+
		32	+ test 9 do
		33	+ score 15
		34	+ end
		35	+
		36	+ test 10 do
		37	+ time_limit 1
		38	+ end
		39	+ end

test/data/ev/test2/script/check created 755 ¶ +59

			@@ -0,0 +1,59
		1	+ #!/usr/bin/ruby
		2	+
		3	+ problem_home = ENV['PROBLEM_HOME']
		4	+ require "#{problem_home}/script/test_dsl.rb"
		5	+
		6	+ if ARGV.length < 2
		7	+ puts "Usage: check <language> <test-number> [<output-file>]"
		8	+ exit(0)
		9	+ end
		10	+
		11	+ language = ARGV[0]
		12	+ test_num = ARGV[1].to_i
		13	+ if ARGV.length >= 3
		14	+ output_file_name = ARGV[2]
		15	+ else
		16	+ output_file_name = "output.txt"
		17	+ end
		18	+
		19	+ load "#{problem_home}/test_cases/all_tests.cfg"
		20	+ problem = Problem.get_instance
		21	+
		22	+ output_file = File.new(output_file_name, "r")
		23	+ answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
		24	+ result_file = File.new("check_result", "w")
		25	+
		26	+ output_file_content = output_file.read
		27	+ answer_file_content = answer_file.read
		28	+
		29	+ report_correct = lambda {
		30	+ result_file.write "Correct\n"
		31	+ result_file.write problem.get_score(test_num)
		32	+ result_file.write "\n"
		33	+ result_file.close
		34	+ exit(0)
		35	+ }
		36	+
		37	+ report_wrong = lambda {
		38	+ result_file.write "Incorrect\n"
		39	+ result_file.write "0\n"
		40	+ result_file.close
		41	+ exit(0)
		42	+ }
		43	+
		44	+ ##################
		45	+ # Your code here #
		46	+ ##################
		47	+ num_pattern = /^[0-9]*/
		48	+ if (output_file_content =~ num_pattern) == nil
		49	+ report_wrong.call
		50	+ end
		51	+
		52	+ output_i = output_file_content.to_i
		53	+ answer_i = answer_file_content.to_i
		54	+
		55	+ if output_i == answer_i
		56	+ report_correct.call
		57	+ else
		58	+ report_wrong.call
		59	+ end

test/data/ev/test2/test_cases/1/answer-1.txt created 644 ¶ +2

			@@ -0,0 +1,2
		1	+ 2
		2	+

test/data/ev/test2/test_cases/1/input-1.txt created 644 ¶ +2

			@@ -0,0 +1,2
		1	+ 1 1
		2	+

test/data/ev/test2/test_cases/2/answer-2.txt created 644 ¶ +2

			@@ -0,0 +1,2
		1	+ 2
		2	+

test/data/ev/test2/test_cases/2/input-2.txt created 644 ¶ +2

			@@ -0,0 +1,2
		1	+ 1 1
		2	+

test/data/ev/test2/test_cases/all_tests.cfg created 644 ¶ +20

			@@ -0,0 +1,20
		1	+ problem do
		2	+ num_tests 2
		3	+ full_score 10
		4	+ time_limit_each 1
		5	+ mem_limit_each 16
		6	+ score_each 10
		7	+
		8	+ run 1 do
		9	+ tests 1
		10	+ end
		11	+
		12	+ test 2 do
		13	+ time_limit 2
		14	+ end
		15	+
		16	+ run 2 do
		17	+ tests 2
		18	+ end
		19	+
		20	+ end

test/data/test1_compile_error.c created 644 ¶ +10

			@@ -0,0 +1,10
		1	+ #include <stdio.h>
		2	+
		3	+ int main()
		4	+ {
		5	+ int a,
		6	+ scanf("%d %d",&a,&b);
		7	+ printf("%d\n",a+b);
		8	+ return 0;
		9	+ }
		10	+

test/data/test1_correct.c created 644 ¶ +10

			@@ -0,0 +1,10
		1	+ #include <stdio.h>
		2	+
		3	+ int main()
		4	+ {
		5	+ int a,b;
		6	+ scanf("%d %d",&a,&b);
		7	+ printf("%d\n",a+b);
		8	+ return 0;
		9	+ }
		10	+

test/data/test2_1-5sec.c created 644 ¶ +19

			@@ -0,0 +1,19
		1	+ #include <stdio.h>
		2	+
		3	+ int main()
		4	+ {
		5	+ int a,b;
		6	+
		7	+ int c=0;
		8	+
		9	+ scanf("%d %d",&a,&b);
		10	+ printf("%d\n",a+b);
		11	+
		12	+ for(a=0; a<2; a++) {
		13	+ while(c<1150000000) {
		14	+ c++;
		15	+ b+=c;
		16	+ }
		17	+ }
		18	+ }
		19	+

test/data/test2_timeout.c created 644 ¶ +11

			@@ -0,0 +1,11
		1	+ #include <stdio.h>
		2	+
		3	+ int main()
		4	+ {
		5	+ int a,b;
		6	+
		7	+ scanf("%d %d",&a,&b);
		8	+ while(1)
		9	+ ;
		10	+ }
		11	+

test/engine_test.rb created 644 ¶ +152

			@@ -0,0 +1,152
		1	+ require 'test/unit'
		2	+ require 'rubygems'
		3	+ require 'mocha'
		4	+
		5	+ require File.join(File.dirname(__FILE__),'test_helper')
		6	+
		7	+ class GraderEngineTest < UnitTest.TestCase
		8	+
		9	+ def setup
		10	+ @@lang_c = stub(:name => 'c', :ext => 'c')
		11	+ @@lang_cpp = stub(:name => 'cpp', :ext => 'cpp')
		12	+ @@lang_pas = stub(:name => 'pas', :ext => 'pas')
		13	+
		14	+ @config = Grader::Configuration.get_instance
		15	+
		16	+ @problem_test1 = stub(:id => 1, :name => 'test1', :full_score => 135)
		17	+ @user_user1 = stub(:id => 1, :login => 'user1')
		18	+
		19	+ @engine = Grader::Engine.new
		20	+
		21	+ init_sandbox
		22	+ end
		23	+
		24	+ def teardown
		25	+ end
		26	+
		27	+ def test_grade_oldest_task_with_no_submission
		28	+ Task.expects(:get_inqueue_and_change_status).returns(nil)
		29	+ assert_equal nil, @engine.grade_oldest_task, 'should return nil when there is no task'
		30	+ end
		31	+
		32	+ def test_normal_submission
		33	+ submission = create_test1_submission_mock_from_file("test1_correct.c")
		34	+
		35	+ submission.expects(:graded_at=)
		36	+ submission.expects(:points=).with(135)
		37	+ submission.expects(:grader_comment=).with do \|value\|
		38	+ /^PASSED/.match(value)
		39	+ end
		40	+ submission.expects(:compiler_message=).with('')
		41	+ submission.expects(:save)
		42	+
		43	+ @engine.grade(submission)
		44	+ end
		45	+
		46	+ def test_compile_error_submission
		47	+ submission = create_test1_submission_mock_from_file("test1_compile_error.c")
		48	+
		49	+ submission.expects(:graded_at=)
		50	+ submission.expects(:points=).with(0)
		51	+ submission.expects(:grader_comment=).with('FAILED: compile error')
		52	+ submission.expects(:compiler_message=) do \|value\|
		53	+ /[Ee]rror/.match value
		54	+ end
		55	+ submission.expects(:save)
		56	+
		57	+ @engine.grade(submission)
		58	+ end
		59	+
		60	+ def test_timeout_submission
		61	+ @problem_test2 = stub(:id => 1, :name => 'test2', :full_score => 10)
		62	+ @user_user1 = stub(:id => 1, :login => 'user1')
		63	+
		64	+ submission = create_submission_from_file(1, @user_user1, @problem_test2,
		65	+ "test2_timeout.c")
		66	+
		67	+ submission.expects(:graded_at=)
		68	+ submission.expects(:points=).with(0)
		69	+ submission.expects(:grader_comment=).with do \|value\|
		70	+ /^FAILED: TT$/.match value
		71	+ end
		72	+ submission.expects(:compiler_message=).with('')
		73	+ submission.expects(:save)
		74	+
		75	+ @engine.grade(submission)
		76	+ end
		77	+
		78	+ def test_timeout_submission_running_one_and_a_half_second
		79	+ @problem_test2 = stub(:id => 1, :name => 'test2', :full_score => 10)
		80	+ @user_user1 = stub(:id => 1, :login => 'user1')
		81	+
		82	+ submission = create_submission_from_file(1, @user_user1, @problem_test2,
		83	+ "test2_1-5sec.c")
		84	+
		85	+ submission.expects(:graded_at=)
		86	+ submission.expects(:points=).with(0)
		87	+ submission.expects(:grader_comment=).with do \|value\|
		88	+ /^FAILED: TP$/.match value
		89	+ end
		90	+ submission.expects(:compiler_message=).with('')
		91	+ submission.expects(:save)
		92	+
		93	+ @engine.grade(submission)
		94	+ end
		95	+
		96	+ def test_grade_oldest_task
		97	+ # mock submission
		98	+ submission = create_test1_submission_mock_from_file("test1_correct.c")
		99	+
		100	+ submission.expects(:graded_at=)
		101	+ submission.expects(:points=).with(135)
		102	+ submission.expects(:grader_comment=).with do \|value\|
		103	+ /^PASSED/.match(value)
		104	+ end
		105	+ submission.expects(:compiler_message=).with('')
		106	+ submission.expects(:save)
		107	+
		108	+ # mock task
		109	+ task = stub(:id => 1, :submission_id => submission.id)
		110	+ Task.expects(:get_inqueue_and_change_status).returns(task)
		111	+ task.expects(:status_complete!)
		112	+
		113	+ # mock Submission
		114	+ Submission.expects(:find).with(task.submission_id).returns(submission)
		115	+
		116	+ @engine.grade_oldest_task
		117	+ end
		118	+
		119	+ def test_grade_oldest_task_with_grader_process
		120	+ grader_process = stub
		121	+ grader_process.expects(:report_active)
		122	+
		123	+ @engine = Grader::Engine.new(grader_process)
		124	+
		125	+ test_grade_oldest_task
		126	+ end
		127	+
		128	+ protected
		129	+
		130	+ def clear_sandbox
		131	+ clear_cmd = "rm -rf #{@config.test_sandbox_dir}/*"
		132	+ system(clear_cmd)
		133	+ end
		134	+
		135	+ def init_sandbox
		136	+ clear_sandbox
		137	+ Dir.mkdir @config.user_result_dir
		138	+ cp_cmd = "cp -R #{@config.test_data_dir}/ev #{@config.test_sandbox_dir}"
		139	+ system(cp_cmd)
		140	+ end
		141	+
		142	+ def create_submission_from_file(id, user, problem, source_fname, language = @@lang_c)
		143	+ source = File.open(@config.test_data_dir + "/" + source_fname).read
		144	+ stub(:id => id, :user => user, :problem => problem,
		145	+ :source => source, :language => language)
		146	+ end
		147	+
		148	+ def create_test1_submission_mock_from_file(source_fname)
		149	+ create_submission_from_file(1, @user_user1, @problem_test1, source_fname)
		150	+ end
		151	+
		152	+ end

test/test_helper.rb created 644 ¶ +25

			@@ -0,0 +1,25
		1	+
		2	+ # This test helper loads the grader's environment and rails environment
		3	+
		4	+ GRADER_ENV = 'test'
		5	+ require File.join(File.dirname(__FILE__),'../config/environment')
		6	+
		7	+
		8	+ # this shall be removed soon
		9	+ RAILS_ENV = Grader::Configuration.get_instance.rails_env
		10	+ require RAILS_ROOT + '/config/environment'
		11	+
		12	+ # make sure not to access real database!
		13	+ # taken from http://blog.jayfields.com/2006/06/ruby-on-rails-unit-tests.html
		14	+
		15	+ class UnitTest
		16	+ def self.TestCase
		17	+ class << ActiveRecord::Base
		18	+ def connection
		19	+ raise 'You cannot access the database from a unit test'
		20	+ # raise InvalidActionError, 'You cannot access the database from a unit test', caller
		21	+ end
		22	+ end
		23	+ Test::Unit::TestCase
		24	+ end
		25	+ end

grader ¶ +25 -159

               #!/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
+            -
-            -   puts problem_out_dir
-            -   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_file = File.open(cmp_msg_fname)
-            -   cmp_msg = cmp_file.read
-            -   cmp_file.close
+            -
-            -   result_fname = "#{test_result_dir}/result"
-            -   comment_fname = "#{test_result_dir}/comment"
-            -   if FileTest.exist?(result_fname)
-            -     result_file = File.open(result_fname)
-            -     result = result_file.readline.to_i
-            -     result_file.close
+            -
-            -     comment_file = File.open(comment_fname)
-            -     comment = comment_file.readline.chomp
-            -     comment_file.close
+            -
-            -     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)
-            -   problem = Problem.find(submission.problem_id)
-            -   submission.graded_at = Time.now
-            -   submission.points = result[:points]
-            -   if submission.points == problem.full_score
-            -     submission.grader_comment = 'PASSED: ' + report_comment(result[:comment])
-            -   else
-            -     submission.grader_comment = 'FAILED: ' + report_comment(result[:comment])
-            -   end
-            -   submission.compiler_message = result[:cmp_msg]
-            -   submission.save
-            - end
+            -
-            - def copy_script(problem_home)
-            -   script_dir = "#{problem_home}/script"
-            -   std_script_dir = File.dirname(__FILE__) + '/std-script'
-            -   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 grade(submission_id)
-            -   current_dir = `pwd`.chomp
+            -
-            -   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}/#{submission_id}"
-            -   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)
+            -
-            -   copy_log = copy_script(problem_home)
+            -
-            -   call_judge(problem_home,language,problem_out_dir,source_name)
-            -   save_result(sub,read_result("#{problem_out_dir}/test-result"))
+            -
-            -   clear_script(copy_log,problem_home)
+            -
-            -   Dir.chdir(current_dir)
-            - end
+            -
               def stop_grader
                 File.open(File.dirname(__FILE__) + '/stop','w').close
               end
               def check_stopfile
                 FileTest.exist?(File.dirname(__FILE__) + '/stop')
               end
               def clear_stopfile
                 system("rm " + File.dirname(__FILE__) + '/stop')
               end
+            + def config
+            +   Grader::Configuration.get_instance
+            + end
+            +
+            + def talk(str)
+            +   if config.talkative
+            +     puts str
+            +   end
+            + end
+            +
               #########################################
               # main program
               #########################################
               # reading environment and options
               if (ARGV.length >= 1) and (ARGV[0]=='stop')
                 end
               else
                 GRADER_ENV = 'exam'
               end
               puts "environment: #{GRADER_ENV}"
-            - require File.dirname(__FILE__) + "/environment.rb"
+            + require File.join(File.dirname(__FILE__),'config/environment')
               #reading rails environment
               talk 'Reading rails environment'
-            - RAILS_ENV = 'development'
-            - require RAILS_APP_DIR + '/config/environment'
+            + RAILS_ENV = config.rails_env
+            + require RAILS_ROOT + '/config/environment'
+            +
               #register grader process
-            - if REPORT_GRADER
-            -   grader_proc = GraderProcess.register(GRADER_IP_ADDRESS,
+            + if config.report_grader
+            +   grader_proc = GraderProcess.register(config.grader_hostname,
                                                      Process.pid,
                                                      grader_mode)
               else
                 grader_proc = nil
               end
+            + # create judge engine
+            + engine = Grader::Engine.new(grader_proc)
+            +
               case grader_mode
               when "queue"
                 talk 'Grader queue'
                 while true
                   if check_stopfile    # created by calling grader stop
                     clear_stopfile
                     puts "stopped"
-            -       grader_proc.report_inactive if grader_proc!=nil
-            -       exit(0)
+            +       break
                   end
+            -
-            -     task = Task.get_inqueue_and_change_status(Task::STATUS_GRADING)
-            -     if task!=nil
-            -       grader_proc.report_active(task) if grader_proc!=nil
+            -
-            -       grade(task.submission_id)
-            -       task.status_complete
-            -     else
-            -       #grader_proc.report_active if grader_proc!=nil
+            +     task = engine.grade_oldest_task
+            +     if task==nil
                     sleep(5)
                   end
                 end
               when "prob"
                 grader_proc.report_active if grader_proc!=nil
                 prob = Problem.find_by_name(ARGV[2])
                 if prob==nil
                   puts "cannot find problem: #{ARGV[2]}"
-            -     exit(0)
+            +   else
+            +     engine.grade_problem(prob)
                 end
-            -   users = User.find(:all)
-            -   users.each do |u|
-            -     puts "user: #{u.login}"
-            -     last_sub = Submission.find(:first,
-            -                                :conditions => "user_id = #{u.id} and " +
-            -                                               "problem_id = #{prob.id}",
-            -                                :order => 'submitted_at DESC')
-            -     if last_sub!=nil
-            -       grade(last_sub.id)
-            -     end
-            -   end
+            +
               end
               # report inactive
               grader_proc.report_inactive if grader_proc!=nil
+            -
+            -

std-script/compile ¶ +17 -13

               #
               # Supported compilers:
               #   gcc, g++, and gpc.
               #
               ##############################
+            + talk ()
+            + {
+            +     if [ "$TALKATIVE" != "" ]; then
+            + 	echo "$1"
+            +     fi
+            + }
+            +
               export C_COMPILER=/usr/bin/gcc
               export CPLUSPLUS_COMPILER=/usr/bin/g++
               export PASCAL_COMPILER=/usr/bin/gpc
               export C_OPTIONS="-O2 -Wall"
               export CPLUSPLUS_OPTIONS="-O2 -Wall"
               fi
               # Retrieve the arguments.
               if [ $# -ge 1 ]
               then
                   export PROG_LANG=$1
-            -     echo "programming language: ${PROG_LANG}"
+            +     talk "programming language: ${PROG_LANG}"
               fi
               if [ $# -ge 2 ]
               then
                   export SOURCE_FILE=$2
               else
                   export SOURCE_FILE=source
               fi
-            - echo "         source file: $SOURCE_FILE"
+            + talk "         source file: $SOURCE_FILE"
               if [ $# -ge 3 ]
               then
                   export OUTPUT_FILE=$3
               else
                   export OUTPUT_FILE=a.out
               fi
-            - echo "         output file: $OUTPUT_FILE"
+            + talk "         output file: $OUTPUT_FILE"
               if [ $# -eq 4 ]
               then
                   export MESSAGE_FILE=$4
               else
                   export MESSAGE_FILE=compiler_message
               fi
-            - echo "        message file: $MESSAGE_FILE"
+            -
-            - echo
+            + 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
-            -     echo "ERROR: The source file does not exist!"
+            +     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
                   $CPLUSPLUS_COMPILER $CPLUSPLUS_OPTIONS -o $OUTPUT_FILE $SOURCE_FILE 2>$MESSAGE_FILE
               elif [ $PROG_LANG = "pascal" ]
               then
                   $PASCAL_COMPILER $PASCAL_OPTIONS -o $OUTPUT_FILE $SOURCE_FILE 2>$MESSAGE_FILE
               else
-            -     echo "ERROR: Invalid language specified!"
+            +     talk "ERROR: Invalid language specified!"
                   echo "ERROR: Invalid language specified!" > $MESSAGE_FILE
                   exit 127
               fi
               # Report success or failure.
               if [ -f $OUTPUT_FILE ]
               then
-            -     echo "Compilation was successful!"
+            +     talk "Compilation was successful!"
               else
-            -     echo "ERROR: Something was wrong during the compilation!"
-            -     echo "Dumping compiler message:"
-            -     echo
-            -     cat $MESSAGE_FILE
+            +     talk "ERROR: Something was wrong during the compilation!"
+            +     talk "Dumping compiler message:"
+            +     #cat $MESSAGE_FILE
               fi
  No newline at end of file

std-script/grade ¶ +15 -2

               #!/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("grade: #{Time.new.strftime("%H:%M")} #{str}")
+            +     fp.close
+            +   end
+            + end
+            +
               def char_comment(comment)
                 if comment =~ /[iI]ncorrect/
                   '-'
                 elsif comment =~ /[Cc]orrect/
                   'P'
                 elsif comment =~ /[Tt]ime/
               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
-            -   puts "The problem specification is not well formed."
+            +   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 = 0
                 run_comment = ''
                 run_comment_short = ''
                 run.tests.each do |test_num|
                   result_file_name = "#{test_num}/result"
                   if not File.exists?(result_file_name)
-            -       puts "Cannot find the file #{test_num}/result!"
+            +       log "Cannot find the file #{test_num}/result!"
                     exit(127)
                   end
                   result_file = File.new(result_file_name, "r")
                   result_file_lines = result_file.readlines
                   run_score = run_score + result_file_lines[1].to_i

std-script/judge ¶ +28 -16

               #!/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)
                   puts "ERROR: #{error_message}"
                   exit(127)
                 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 != "pascal"
-            -   puts "You specified a language that is not supported."
+            +   log "You specified a language that is not supported."
                 exit(127)
               end
               source_file = ARGV[1]
               if File.exist?(source_file) == false
-            -   puts "The source file does not exist."
+            +   log "The source file does not exist."
                 exit(127)
               end
-            - puts "Making test result and sandbox directories..."
+            + 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
-            - puts "Test result directory: #{test_result_dir}"
+            + 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
-            - puts "Sandbox directory: #{sandbox_dir}"
+            + log "Sandbox directory: #{sandbox_dir}"
               system("rm -Rf #{sandbox_dir}")
               execute("mkdir #{sandbox_dir}", "Cannot make directory #{sandbox_dir}")
               # Compile
-            - puts
-            - puts "Compiling..."
+            + log
+            + log "Compiling..."
               execute("cp #{source_file} #{sandbox_dir}", "Cannot copy the source file to #{sandbox_dir}")
               begin
                 Dir.chdir sandbox_dir
               rescue
-            -   puts "ERROR: Cannot change directory to #{sandbox_dir}."
+            +   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")
-            -   puts "Cannot compile the source code. See message in #{test_result_dir}/compile_message"
+            +   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
-            -   puts "The problem specification is not well formed."
+            +   log "The problem specification is not well formed."
                 exit(127)
               end
               # Doing the testing.
               (1..(problem.num_tests)).each do |test_num|
-            -   puts
+            +   log "Test number: #{test_num}"
                 execute("cp #{test_result_dir}/a.out #{sandbox_dir}", "Cannot copy the compiled program into #{sandbox_dir}")
                 execute("#{problem_home}/script/run #{language} #{test_num}", "Error occured during execution of the run script")
                 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
               # Grade
-            - puts
-            - puts "Grading..."
+            + log
+            + log "Grading..."
               begin
                 Dir.chdir test_result_dir
               rescue
-            -   puts "ERROR: Cannot change directory to #{test_result_dir}."
+            +   log "ERROR: Cannot change directory to #{test_result_dir}."
                 exit(127)
               end
               execute("#{problem_home}/script/grade", "An error occured during grading!")
-            - puts
-            - puts "All done!"
+            + log
+            + log "All done!"

std-script/run ¶ +21 -10

               #!/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
+            +
               if ARGV.length < 2 || ARGV.length > 3
                 puts "Usage: run <language> <test-num> [<program-name>]"
                 exit(127)
               end
               language = ARGV[0]
               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
-            -   puts "The problem specification is not well formed."
+            +   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
-            -   puts "You have specified a wrong test number."
+            +   log "You have specified a wrong test number."
                 exit(127)
               end
               #####################################
               # Set the relavant file names here. #
               #####################################
               # Copy the input file.
               #`cp #{problem_home}/test_cases/#{test_num}/#{input_file_name} .`
               # Run the program.
               run_command = "/usr/bin/time -f \"%E\" 2>run_result #{problem_home}/script/box -a 2 -f -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name}"
-            - puts "Running test #{test_num}..."
-            - puts run_command
-            - puts
+            + log "Running test #{test_num}..."
+            + log run_command
+            + log
               system(run_command)
               # Create the result file.
               result_file = File.new("result", "w")
               comment_file = File.new("comment", "w")
                 comment_file.write "--run-result--\n"
                 run_result.each do |l|
                   comment_file.write l
                 end
                 comment_file.close
-            -   puts
-            -   puts "Done!"
+            +   log "Done!"
                 exit(0)
               }
               if run_result[0][0,2] != "OK"
-            -   puts "There was a runtime error."
+            +   log "There was a runtime error."
                 report.call(run_result[0], 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}"
-            - puts "Checking the output..."
-            - puts check_command
+            + log "Checking the output..."
+            + log check_command
               if not system(check_command)
                 exit(127)
               end
               check_file = File.new("check_result", "r")
               check_file_lines = check_file.readlines

env_exam.rb.SAMPLE removed ¶ -17

deleted file

env_grading.rb.SAMPLE removed ¶ -13

deleted file

environment.rb.SAMPLE removed ¶ -6

deleted file

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r22:a8f2ad67d212 - Mon, 03 Mar 2008 18:03:00 - 52 files changed: 851 inserted, 236 deleted

Sign in to your account

Commit r22:a8f2ad67d212 public

Author

r22:a8f2ad67d212 - Mon, 03 Mar 2008 18:03:00 - 52 files changed: 851 inserted, 236 deleted

Commit `r22:a8f2ad67d212` public