cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r124:20e4101950cb` public

parent | child

Description:

Merge branch 'master' of gitorious.org:cafe-grader/cafe-grader-judge-scripts into windows

Commit status:

[Not Reviewed]

References:

merge default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r124:20e4101950cb - Sun, 02 May 2010 07:42:47 - 8 files changed: 264 inserted, 123 deleted

test/.gitignore created 644 ¶ +3

@@ -0,0 +1,3
	1	+ sandbox
	2	+ coverage
	3	+

test/data/test1_correct_cc.cc created 644 ¶ +13

@@ -0,0 +1,13
	1	+ /*
	2	+ LANG: C++
	3	+ */
	4	+ #include <cstdio>
	5	+
	6	+ int main()
	7	+ {
	8	+ int a,b,r;
	9	+ r = scanf("%d %d",&a,&b);
	10	+ printf("%d\n",a+b);
	11	+ return 0;
	12	+ }
	13	+

test/rakefile created 644 ¶ +14

@@ -0,0 +1,14
	1	+ require 'rake'
	2	+ require 'spec/rake/spectask'
	3	+
	4	+ desc "Run all examples"
	5	+ Spec::Rake::SpecTask.new('spec') do \|t\|
	6	+ t.spec_files = FileList['*spec.rb']
	7	+ end
	8	+
	9	+ desc "Run all examples with RCov"
	10	+ Spec::Rake::SpecTask.new('spec_with_rcov') do \|t\|
	11	+ t.spec_files = FileList['*spec.rb']
	12	+ t.rcov = true
	13	+ t.rcov_opts = ['--exclude', '.*_spec\.rb']
	14	+ end

grader ¶ +214 -118

@@ -29,49 +29,49
29	end	29	end
30	config.log_dir +	30	config.log_dir +
31	"/#{GRADER_ENV}_#{config.grader_mode}.#{Process.pid}"	31	"/#{GRADER_ENV}_#{config.grader_mode}.#{Process.pid}"
32	end	32	end
33		33
34	def log(str)	34	def log(str)
35	if config.talkative	35	if config.talkative
36	puts str	36	puts str
37	end	37	end
38	if config.logging	38	if config.logging
39	fp = File.open(log_file_name,"a")	39	fp = File.open(log_file_name,"a")
40	fp.puts("GRADER: #{Time.new.strftime("%H:%M")} #{str}")	40	fp.puts("GRADER: #{Time.new.strftime("%H:%M")} #{str}")
41	fp.close	41	fp.close
42	end	42	end
43	end	43	end
44		44
45	def display_manual	45	def display_manual
46	puts <<USAGE	46	puts <<USAGE
47	Grader.	47	Grader.
48	using: (1) grader	48	using: (1) grader
49	(2) grader environment [mode]	49	(2) grader environment [mode]
50	(3) grader stop [all\|pids-list]	50	(3) grader stop [all\|pids-list]
51	(4) grader --help	51	(4) grader --help
52	(1) call grader with environment = 'exam', mode = 'queue'	52	(1) call grader with environment = 'exam', mode = 'queue'
53	- (2) possible modes are: 'queue', 'prob', '~~test_request~~'	53	+ (2) possible modes are: 'queue', 'test_request', 'prob', 'sub', 'contest', and 'autonew'
54	(3) create stop-file to stop running grader in queue mode	54	(3) create stop-file to stop running grader in queue mode
55	(4) You are here.	55	(4) You are here.
56	USAGE	56	USAGE
57	end	57	end
58		58
59	def process_options_and_stop_file	59	def process_options_and_stop_file
60	# The list of options are:	60	# The list of options are:
61	# - stop [all\|process ids]	61	# - stop [all\|process ids]
62	# -	62	# -
63		63
64	# Process 'help' option	64	# Process 'help' option
65	if (ARGV.length==1) and (/help/.match(ARGV[0]))	65	if (ARGV.length==1) and (/help/.match(ARGV[0]))
66	display_manual	66	display_manual
67	exit(0)	67	exit(0)
68	end	68	end
69		69
70	# Process 'stop' option.	70	# Process 'stop' option.
71	if (ARGV.length >= 1) and (ARGV[0]=='stop')	71	if (ARGV.length >= 1) and (ARGV[0]=='stop')
72	if ARGV.length==1	72	if ARGV.length==1
73	puts "you should specify pid-list or 'all'"	73	puts "you should specify pid-list or 'all'"
74	display_manual	74	display_manual
75	elsif (ARGV.length==2) and (ARGV[1]=='all')	75	elsif (ARGV.length==2) and (ARGV[1]=='all')
76	stop_grader(:all)	76	stop_grader(:all)
77	puts "A global stop file ('stop.all') created."	77	puts "A global stop file ('stop.all') created."
@@ -87,104 +87,305
87		87
88	# Check stop file.	88	# Check stop file.
89	if check_stopfile	89	if check_stopfile
90	puts "Stop file exists. Terminated."	90	puts "Stop file exists. Terminated."
91	clear_stopfile	91	clear_stopfile
92	exit(0)	92	exit(0)
93	end	93	end
94		94
95	#default options	95	#default options
96	options = {	96	options = {
97	:mode => 'queue',	97	:mode => 'queue',
98	:environment => 'exam',	98	:environment => 'exam',
99	:dry_run => false,	99	:dry_run => false,
100	}	100	}
101		101
102	# Process mode and environment option	102	# Process mode and environment option
103	if ARGV.length >= 1	103	if ARGV.length >= 1
104	options[:environment] = ARGV.shift	104	options[:environment] = ARGV.shift
105	if ARGV.length >=1	105	if ARGV.length >=1
106	options[:mode] = ARGV.shift	106	options[:mode] = ARGV.shift
107	end	107	end
108	end	108	end
109		109
110	options[:dry_run] = (ARGV.delete('--dry') != nil)	110	options[:dry_run] = (ARGV.delete('--dry') != nil)
111	- if options[:dry_run] and (not ['prob','contest'].include? options[:mode])	111	+ if options[:dry_run] and (not ['prob','contest','autonew'].include? options[:mode])
112	puts "Dry run currently works only for 'prob' or 'contest' modes."	112	puts "Dry run currently works only for 'prob' or 'contest' modes."
113	exit(0)	113	exit(0)
114	end	114	end
115		115
116	options[:report] = (ARGV.delete('--report') != nil)	116	options[:report] = (ARGV.delete('--report') != nil)
117	- if options[:report] and (not ['prob','contest'].include? options[:mode])	117	+ if options[:report] and (not ['prob','contest','autonew'].include? options[:mode])
118	puts "Report currently works only for 'prob' or 'contest' modes."	118	puts "Report currently works only for 'prob' or 'contest' modes."
119	exit(0)	119	exit(0)
120	end	120	end
121		121
122	return options	122	return options
123	end	123	end
124		124
125	class ResultCollector	125	class ResultCollector
126	def initialize	126	def initialize
127	@results = {}	127	@results = {}
128	@problems = {}	128	@problems = {}
129	@users = {}	129	@users = {}
130	end	130	end
131		131
132	- def ~~save(user, problem~~, grading_result)	132	+ def after_save_hook(submission, grading_result)
		133	+ end
		134	+
		135	+ def save(submission, grading_result)
		136	+ user = submission.user
		137	+ problem = submission.problem
133	if not @problems.has_key? problem.id	138	if not @problems.has_key? problem.id
134	@problems[problem.id] = problem	139	@problems[problem.id] = problem
135	end	140	end
136	if not @users.has_key? user.id	141	if not @users.has_key? user.id
137	@users[user.id] = user	142	@users[user.id] = user
138	end	143	end
139	@results[[user.id, problem.id]] = grading_result	144	@results[[user.id, problem.id]] = grading_result
		145	+
		146	+ after_save_hook(submission, grading_result)
140	end	147	end
141		148
142	def print_report_by_user	149	def print_report_by_user
143	puts "---------------------"	150	puts "---------------------"
144	puts " REPORT"	151	puts " REPORT"
145	puts "---------------------"	152	puts "---------------------"
146		153
147	print "login,email"	154	print "login,email"
148	@problems.each_value do \|problem\|	155	@problems.each_value do \|problem\|
149	print ",#{problem.name}"	156	print ",#{problem.name}"
150	end	157	end
151	print "\n"	158	print "\n"
152		159
153	@users.each_value do \|user\|	160	@users.each_value do \|user\|
154	print "#{user.login},#{user.email}"	161	print "#{user.login},#{user.email}"
155	@problems.each_value do \|problem\|	162	@problems.each_value do \|problem\|
156	if @results.has_key? [user.id, problem.id]	163	if @results.has_key? [user.id, problem.id]
157	print ",#{@results[[user.id,problem.id]][:points]}"	164	print ",#{@results[[user.id,problem.id]][:points]}"
158	else	165	else
159	print ","	166	print ","
160	end	167	end
161	end	168	end
162	print "\n"	169	print "\n"
163	end	170	end
164	end	171	end
165	end	172	end
166		173
		174	+ def grader_general_loop(engine, grader_proc, options)
		175	+ runner = Grader::Runner.new(engine, grader_proc)
		176	+ while true
		177	+
		178	+ if check_stopfile # created by calling grader stop
		179	+ clear_stopfile
		180	+ log "stopped (with stop file)"
		181	+ break
		182	+ end
		183	+
		184	+ task = yield(runner)
		185	+
		186	+ if task==nil
		187	+ sleep(1)
		188	+ end
		189	+ end
		190	+ end
		191	+
		192	+ def grader_queue_loop(grader_proc, options)
		193	+ log "Grader: queue"
		194	+ engine = Grader::Engine.new
		195	+ grader_general_loop(engine, grader_proc, options) do \|runner\|
		196	+ runner.grade_oldest_task
		197	+ end
		198	+ end
		199	+
		200	+ def grader_test_request_loop(grader_proc, options)
		201	+ log "Grader: test_request"
		202	+ engine = Grader::Engine.new(:room_maker => Grader::TestRequestRoomMaker.new,
		203	+ :reporter => Grader::TestRequestReporter.new)
		204	+ grader_general_loop(engine, grader_proc, options) do \|runner\|
		205	+ runner.grade_oldest_test_request
		206	+ end
		207	+ end
		208	+
		209	+ def grader_autonew_loop(grader_proc, options)
		210	+ log "Grader: autonew"
		211	+
		212	+ if options[:report]
		213	+ result_collector = ResultCollector.new
		214	+ else
		215	+ result_collector = nil
		216	+ end
		217	+
		218	+ if options[:dry_run]
		219	+ puts "Running in dry mode"
		220	+ end
		221	+
		222	+ prob_reporter = Grader::SubmissionReporter.new(:dry_run => options[:dry_run],
		223	+ :result_collector => result_collector)
		224	+
		225	+ engine = Grader::Engine.new(:reporter => prob_reporter)
		226	+ runner = Grader::Runner.new(engine, grader_proc)
		227	+
		228	+ grader_proc.report_active if grader_proc!=nil
		229	+
		230	+ latest_submitted_at = nil
		231	+ graded_submission_ids = {}
		232	+
		233	+ while true
		234	+
		235	+ if check_stopfile # created by calling grader stop
		236	+ clear_stopfile
		237	+ log "stopped (with stop file)"
		238	+ break
		239	+ end
		240	+
		241	+ if latest_submitted_at==nil
		242	+ submissions = Submission.all
		243	+ else
		244	+ submissions = Submission.all(:conditions => ["submitted_at >= :latest",
		245	+ {:latest => latest_submitted_at}])
		246	+ end
		247	+
		248	+ graded_any = false
		249	+
		250	+ if submissions.length != 0
		251	+ submissions.each do \|submission\|
		252	+ if ! graded_submission_ids[submission.id]
		253	+ runner.grade_submission(submission)
		254	+ graded_submission_ids[submission.id] = true
		255	+ if (!latest_submitted_at or
		256	+ latest_submitted_at < submission.submitted_at)
		257	+ latest_submitted_at = submission.submitted_at
		258	+ end
		259	+ puts "graded: #{submission.id}"
		260	+ puts "latest: #{latest_submitted_at}"
		261	+ graded_any = true
		262	+ end
		263	+ end
		264	+ end
		265	+
		266	+ if ! graded_any
		267	+ sleep(1)
		268	+ end
		269	+ end
		270	+ end
		271	+
		272	+ def grader_grade_problems(grader_proc, options)
		273	+ if options[:report]
		274	+ result_collector = ResultCollector.new
		275	+ else
		276	+ result_collector = nil
		277	+ end
		278	+
		279	+ if options[:dry_run]
		280	+ puts "Running in dry mode"
		281	+ end
		282	+
		283	+ prob_reporter = Grader::SubmissionReporter.new(:dry_run => options[:dry_run],
		284	+ :result_collector => result_collector)
		285	+ engine = Grader::Engine.new(:reporter => prob_reporter)
		286	+ runner = Grader::Runner.new(engine, grader_proc)
		287	+
		288	+ grader_proc.report_active if grader_proc!=nil
		289	+
		290	+ ARGV.each do \|prob_name\|
		291	+ prob = Problem.find_by_name(prob_name)
		292	+ if prob==nil
		293	+ puts "cannot find problem: #{prob_name}"
		294	+ else
		295	+ runner.grade_problem(prob)
		296	+ end
		297	+ end
		298	+
		299	+ if options[:report]
		300	+ result_collector.print_report_by_user
		301	+ end
		302	+ end
		303	+
		304	+ def grader_grade_contests(grader_proc, options)
		305	+ # always use dry run when grading during contest
		306	+ dry_run = options[:dry_run] = true
		307	+
		308	+ contest_name = ARGV.shift
		309	+
		310	+ contest = Contest.find_by_name(contest_name)
		311	+ if contest==nil
		312	+ puts "cannot find contest: #{contest_name}"
		313	+ exit(0)
		314	+ end
		315	+
		316	+ if options[:report]
		317	+ result_collector = ResultCollector.new
		318	+ else
		319	+ result_collector = nil
		320	+ end
		321	+
		322	+ if options[:dry_run]
		323	+ puts "Running in dry mode"
		324	+ end
		325	+
		326	+ prob_reporter = Grader::SubmissionReporter.new(:dry_run => dry_run,
		327	+ :result_collector => result_collector)
		328	+ engine = Grader::Engine.new(:reporter => prob_reporter)
		329	+ runner = Grader::Runner.new(engine, grader_proc)
		330	+
		331	+ grader_proc.report_active if grader_proc!=nil
		332	+
		333	+ contest.problems.each do \|problem\|
		334	+ puts "Grading: #{problem.name}"
		335	+ runner.grade_problem(problem,
		336	+ :user_conditions => lambda do \|u\|
		337	+ u.contest_finished? and
		338	+ u.contest_ids.include?(contest.id)
		339	+ end)
		340	+ end
		341	+
		342	+ if options[:report]
		343	+ result_collector.print_report_by_user
		344	+ end
		345	+ end
		346	+
		347	+ def grader_grade_submissions(grader_proc, options)
		348	+ engine = Grader::Engine.new
		349	+ runner = Grader::Runner.new(engine, grader_proc)
		350	+
		351	+ grader_proc.report_active if grader_proc!=nil
		352	+
		353	+ ARGV.each do \|sub_id\|
		354	+ puts "Grading #{sub_id}"
		355	+ begin
		356	+ submission = Submission.find(sub_id.to_i)
		357	+ rescue ActiveRecord::RecordNotFound
		358	+ puts "Record not found"
		359	+ submission = nil
		360	+ end
		361	+
		362	+ if submission!=nil
		363	+ runner.grade_submission(submission)
		364	+ end
		365	+ end
		366	+ end
		367	+
167	#########################################	368	#########################################
168	# main program	369	# main program
169	#########################################	370	#########################################
170		371
171	options = process_options_and_stop_file	372	options = process_options_and_stop_file
172	GRADER_ENV = options[:environment]	373	GRADER_ENV = options[:environment]
173	grader_mode = options[:mode]	374	grader_mode = options[:mode]
174	dry_run = options[:dry_run]	375	dry_run = options[:dry_run]
175		376
176	puts "environment: #{GRADER_ENV}"	377	puts "environment: #{GRADER_ENV}"
177	require File.join(File.dirname(__FILE__),'config/environment')	378	require File.join(File.dirname(__FILE__),'config/environment')
178		379
179	# add grader_mode to config	380	# add grader_mode to config
180	# this is needed because method log needs it. TODO: clean this up	381	# this is needed because method log needs it. TODO: clean this up
181	class << config	382	class << config
182	attr_accessor :grader_mode	383	attr_accessor :grader_mode
183	end	384	end
184	config.grader_mode = grader_mode	385	config.grader_mode = grader_mode
185		386
186	# reading rails environment	387	# reading rails environment
187	log 'Reading rails environment'	388	log 'Reading rails environment'
188		389
189	RAILS_ENV = config.rails_env	390	RAILS_ENV = config.rails_env
190	require RAILS_ROOT + '/config/environment'	391	require RAILS_ROOT + '/config/environment'
@@ -193,152 +394,47
193	if config.report_grader	394	if config.report_grader
194	grader_proc = GraderProcess.register(config.grader_hostname,	395	grader_proc = GraderProcess.register(config.grader_hostname,
195	Process.pid,	396	Process.pid,
196	grader_mode)	397	grader_mode)
197	else	398	else
198	grader_proc = nil	399	grader_proc = nil
199	end	400	end
200		401
201	#set loggin environment	402	#set loggin environment
202	ENV['GRADER_LOGGING'] = log_file_name	403	ENV['GRADER_LOGGING'] = log_file_name
203		404
204	# register exit handler to report inactive, and terminated	405	# register exit handler to report inactive, and terminated
205	at_exit do	406	at_exit do
206	if grader_proc!=nil	407	if grader_proc!=nil
207	grader_proc.report_inactive	408	grader_proc.report_inactive
208	grader_proc.terminate	409	grader_proc.terminate
209	end	410	end
210	end	411	end
211		412
212	#	413	#
213	# MAIN LOOP	414	# MAIN LOOP
214	#	415	#
215		416
216	case grader_mode	417	case grader_mode
217	- when "queue"~~, "test_request"~~	418	+ when "queue"
218	- log "Grader: #{grader_mode}"	419	+ grader_queue_loop(grader_proc, options)
219	- if grader_mode=="queue"
220	- engine = Grader::Engine.new
221	- else
222	- engine = Grader::Engine.new(:room_maker => Grader::TestRequestRoomMaker.new,
223	- :reporter => Grader::TestRequestReporter.new)
224	- end
225	-
226	- runner = Grader::Runner.new(engine, grader_proc)
227	- while true
228		420
229	- if check_stopfile # created by calling grader stop	421	+ when "test_request"
230	- clear_stopfile	422	+ grader_test_request_loop(grader_proc, options)
231	- log "stopped (with stop file)"
232	- break
233	- end
234	-
235	- if grader_mode=="queue"
236	- task = runner.grade_oldest_task
237	- else
238	- task = runner.grade_oldest_test_request
239	- end
240	- if task==nil
241	- sleep(1)
242	- end
243	- end
244		423
245	when "prob"	424	when "prob"
246	- if options[:report]	425	+ grader_grade_problems(grader_proc, options)
247	- result_collector = ResultCollector.new
248	- else
249	- result_collector = nil
250	- end
251	-
252	- if options[:dry_run]
253	- puts "Running in dry mode"
254	- end
255	-
256	- prob_reporter = Grader::SubmissionReporter.new(:dry_run => dry_run,
257	- :result_collector => result_collector)
258	- engine = Grader::Engine.new(:reporter => prob_reporter)
259	- runner = Grader::Runner.new(engine, grader_proc)
260	-
261	- grader_proc.report_active if grader_proc!=nil
262	-
263	- ARGV.each do \|prob_name\|
264	- prob = Problem.find_by_name(prob_name)
265	- if prob==nil
266	- puts "cannot find problem: #{prob_name}"
267	- else
268	- runner.grade_problem(prob)
269	- end
270	- end
271	-
272	- if options[:report]
273	- result_collector.print_report_by_user
274	- end
275		426
276	when "contest"	427	when "contest"
277	- # always use dry run when grading during contest	428	+ grader_grade_contests(grader_proc, options)
278	- contest_name = ARGV.shift
279	-
280	- dry_run = options[:dry_run] = true
281	-
282	- contest = Contest.find_by_name(contest_name)
283	- if contest==nil
284	- puts "cannot find contest: #{contest_name}"
285	- exit(0)
286	- end
287	-
288	- if options[:report]
289	- result_collector = ResultCollector.new
290	- else
291	- result_collector = nil
292	- end
293	-
294	- if options[:dry_run]
295	- puts "Running in dry mode"
296	- end
297	-
298	- prob_reporter = Grader::SubmissionReporter.new(:dry_run => dry_run,
299	- :result_collector => result_collector)
300	- engine = Grader::Engine.new(:reporter => prob_reporter)
301	- runner = Grader::Runner.new(engine, grader_proc)
302	-
303	- grader_proc.report_active if grader_proc!=nil
304	-
305	- contest.problems.each do \|problem\|
306	- puts "Grading: #{problem.name}"
307	- runner.grade_problem(problem,
308	- :user_conditions => lambda do \|u\|
309	- u.contest_finished? and
310	- u.contest_ids.include?(contest.id)
311	- end)
312	- end
313	-
314	- if options[:report]
315	- result_collector.print_report_by_user
316	- end
317		429
318	when "sub"	430	when "sub"
319	- engine = Grader::Engine.new	431	+ grader_grade_submissions(grader_proc, options)
320	- runner = Grader::Runner.new(engine, grader_proc)
321	-
322	- grader_proc.report_active if grader_proc!=nil
323		432
324	- ARGV.each do \|sub_id\|	433	+ when "autonew"
325	- puts "Grading #{sub_id}"	434	+ grader_autonew_loop(grader_proc, options)
326	- begin
327	- submission = Submission.find(sub_id.to_i)
328	- rescue ActiveRecord::RecordNotFound
329	- puts "Record not found"
330	- submission = nil
331	- end
332	-
333	- if submission!=nil
334	- runner.grade_submission(submission)
335	- end
336	- end
337	-
338	-
339		435
340	else	436	else
341	display_manual	437	display_manual
342	exit(0)	438	exit(0)
343	end	439	end
344		440

lib/engine.rb ¶ +2 -2

                   # 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 = FileUtils.pwd
                     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
+            +       # This is needed because older version of std-scripts/compile
-            -       talk 'some hack on language'
+            +       # only look for c++.
                     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}"
                       if !FileTest.exist?(problem_home)
                         raise "No test data."
                       end
                       dinit = DirInit::Manager.new(problem_home)

lib/submission_helper.rb ¶ +1 -2

                   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(options={})
                     options = {:dry_run => false, :result_collector => nil}.merge(options)
                     @config = Grader::Configuration.get_instance
                     @dry_run = options[:dry_run]
                     @result_collector = options[:result_collector]
                   end
                   def report(sub,test_result_dir)
                     result = read_result(test_result_dir)
                     if @result_collector
-            -         @result_collector.save(sub.user,
+            +         @result_collector.save(sub,
-            -                                sub.problem,
                                              result)
                     end
                     save_result(sub,result)
                   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)

std-script/compile ¶ +4

                   params[param_name] = ARGV[index]
                 else
                   params[param_name] = default
                 end
                 talk "#{param_name}: #{params[param_name]}"
               end
               # Remove any remaining output files or message files.
               if FileTest.exists? params[:output_file]
                 FileUtils.rm(params[:output_file])
               end
               if FileTest.exists? params[:message_file]
                 FileUtils.rm(params[:message_file])
               end
               # Check if the source file exists before attempt compiling.
               if !FileTest.exists? params[:source_file]
                 talk("ERROR: The source file does not exist!")
                 open(params[:message_file],"w") do |f|
                   f.puts "ERROR: The source file did not exist."
                 end
                 exit(127)
               end
+            + if params[:prog_lang]=='cpp':
+            +     params[:prog_lang] = 'c++'
+            + end
+            +
               # Compile.
               case params[:prog_lang]
                 when "c"
                 command = "#{C_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{C_OPTIONS} 2> #{params[:message_file]}"
                 system(command)
                 when "c++"
                 command = "#{CPLUSPLUS_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{CPLUSPLUS_OPTIONS} 2> #{params[:message_file]}"
                 system(command)
                 when "pas"
                 command = "#{PASCAL_COMPILER} #{params[:source_file]} -ooutpas #{PASCAL_OPTIONS} > #{params[:message_file]}"
                 system(command)
                 FileUtils.mv("output", params[:output_file])
                 else
                 talk("ERROR: Invalid language specified!")
                 open(params[:message_file],"w") do |f|
                   f.puts "ERROR: Invalid language specified!"
                 end
                 exit(127)
               end

test/engine_spec.rb ¶ +13 -1

                 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 grade normal submission in C++" do
+            +     cpp_lang = stub(Language, :name => 'cpp', :ext => 'cpp')
+            +
+            +     grader_should(:grade => "test1_correct_cc.cc",
+            +                   :language => cpp_lang,
+            +                   :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)
                   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])
+            +       create_submission_from_file(1, @user1, args[:on], args[:grade], args[:language])
                   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

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

r124:20e4101950cb - Sun, 02 May 2010 07:42:47 - 8 files changed: 264 inserted, 123 deleted

Sign in to your account

Commit r124:20e4101950cb public

Author

r124:20e4101950cb - Sun, 02 May 2010 07:42:47 - 8 files changed: 264 inserted, 123 deleted

Commit `r124:20e4101950cb` public