Merge branch 'fresh_java' of https://github.com/prathamesh920/online_test into deploy_server

Conflicts:
	testapp/templates/exam/question.html

20 files changed, 1107 insertions, 107 deletions

diff --git a/testapp/c_cpp_files/main.cpp b/testapp/c_cpp_files/main.cpp
new file mode 100755
index 0000000..ebe1f08
--- /dev/null
+++ b/testapp/c_cpp_files/main.cpp
@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+extern int add(int, int);
+
+template <class T>
+
+void check(T expect, T result)
+{
+    if (expect == result)
+    {
+	printf("\nCorrect:\n Expected %d got %d \n",expect,result);
+    }
+    else 
+    {
+	printf("\nIncorrect:\n Expected %d got %d \n",expect,result);
+	exit (1);
+   }
+}
+
+int main(void)
+{
+	int result;
+	result = add(0,0);
+        printf("Input submitted to the function: 0, 0");
+	check(0, result);
+	result = add(2,3);
+        printf("Input submitted to the function: 2 3");
+	check(5,result);
+	printf("All Correct\n");
+	return 0;
+}
diff --git a/testapp/c_cpp_files/main2.c b/testapp/c_cpp_files/main2.c
new file mode 100755
index 0000000..ccd1768
--- /dev/null
+++ b/testapp/c_cpp_files/main2.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+extern int add(int, int, int);
+
+template <class T>
+void check(T expect,T result)
+{
+    if (expect == result)
+    {
+	printf("\nCorrect:\n Expected %d got %d \n",expect,result);
+    }
+    else 
+    {
+	printf("\nIncorrect:\n Expected %d got %d \n",expect,result);
+	exit (0);
+   }
+}
+
+int main(void)
+{
+	int result;
+	result = add(0,0,0);
+        printf("Input submitted to the function: 0, 0, 0");
+	check(0, result);
+	result = add(2,3,3);
+        printf("Input submitted to the function: 2, 3, 3");
+	check(8,result);
+	printf("All Correct\n");
+}
diff --git a/testapp/c_cpp_files/main_array_sum.cpp b/testapp/c_cpp_files/main_array_sum.cpp
new file mode 100755
index 0000000..55b2ebf
--- /dev/null
+++ b/testapp/c_cpp_files/main_array_sum.cpp
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+extern int array_sum(int []);
+
+template <class T>
+
+void check(T expect,T result)
+{
+    if (expect == result)
+    {
+	printf("\nCorrect:\n Expected %d got %d \n",expect,result);
+    }
+    else 
+    {
+	printf("\nIncorrect:\n Expected %d got %d \n",expect,result);
+	exit (1);
+   }
+}
+
+int main(void)
+{
+	int result;
+        int a[] = {1,2,3,0,0};
+	result = array_sum(a);
+        printf("Input submitted to the function: {1, 2, 3, 0, 0}");
+	check(6, result);
+	int b[] = {1,2,3,4,5};
+       	result = array_sum(b);
+        printf("Input submitted to the function: {1, 2, 3, 4, 5}");
+	check(15,result);
+	printf("All Correct\n");
+	return 0;
+}
diff --git a/testapp/c_cpp_files/main_fact.cpp b/testapp/c_cpp_files/main_fact.cpp
new file mode 100755
index 0000000..a4ff230
--- /dev/null
+++ b/testapp/c_cpp_files/main_fact.cpp
@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+extern int factorial(int);
+
+template <class T>
+
+void check(T expect, T result)
+{
+    if (expect == result)
+    {
+	printf("\nCorrect:\n Expected %d got %d \n",expect,result);
+    }
+    else 
+    {
+	printf("\nIncorrect:\n Expected %d got %d \n",expect,result);
+	exit (1);
+   }
+}
+
+int main(void)
+{
+	int result;
+	result = factorial(0);
+        printf("Input submitted to the function: 0");
+	check(1, result);
+	result = factorial(3);
+        printf("Input submitted to the function: 3");
+	check(6, result);
+	printf("All Correct\n");
+	return 0;
+}
diff --git a/testapp/c_cpp_files/main_greatest.cpp b/testapp/c_cpp_files/main_greatest.cpp
new file mode 100755
index 0000000..6d0a7c2
--- /dev/null
+++ b/testapp/c_cpp_files/main_greatest.cpp
@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+extern int greatest(int, int, int);
+
+template <class T>
+
+void check(T expect, T result)
+{
+    if (expect == result)
+    {
+	printf("\nCorrect:\n Expected %d got %d \n",expect,result);
+    }
+    else 
+    {
+	printf("\nIncorrect:\n Expected %d got %d \n",expect,result);
+	exit (1);
+   }
+}
+
+int main(void)
+{
+	int result;
+	result = greatest(1, 2, 3);
+        printf("Input submitted to the function: 1, 2, 3");
+	check(3, result);
+	result = greatest(5, 9, 2);
+        printf("Input submitted to the function: 5, 9, 2");
+	check(9, result);
+	result = greatest(7, 2, 4);
+        printf("Input submitted to the function: 7, 2, 4");
+	check(7, result);
+        result = greatest(11, 2, 45);
+        printf("Input submitted to the function: 11, 2, 45");
+        check(45, result);
+        result = greatest(2, 7, 0);
+        printf("Input submitted to the function: 2, 7, 0");
+        check(7, result);
+        result = greatest(9, 6, 5);
+        printf("Input submitted to the function: 9, 6, 5");
+        check(9, result);
+	printf("All Correct\n");
+	return 0;
+}
diff --git a/testapp/c_cpp_files/main_hello_name.c b/testapp/c_cpp_files/main_hello_name.c
new file mode 100755
index 0000000..71b83a2
--- /dev/null
+++ b/testapp/c_cpp_files/main_hello_name.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+
+void check(char expect[], char result[])
+{
+    if (expect == result)
+    {
+	printf("Correct:expected %s got %s \n",expect,result);
+    }
+    else 
+    {
+	printf("ERROR:expected %s got %s \n",expect,result);
+	exit (0);
+   }
+}
+
+int main(void)
+{
+	char result[20];
+	char A[20]=" pratham";
+	char B[20]=" sir";
+ 	result[20] = message(A);
+        printf("%s",result);
+	check("hello pratham", result);
+	result[20] = message(B);
+	check("hello sir",result);
+	printf("All Correct\n");
+}
diff --git a/testapp/c_cpp_files/main_palindrome.cpp b/testapp/c_cpp_files/main_palindrome.cpp
new file mode 100755
index 0000000..0e66928
--- /dev/null
+++ b/testapp/c_cpp_files/main_palindrome.cpp
@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+extern bool palindrome(int);
+
+template <class T>
+
+void check(T expect, T result)
+{
+    if (expect == result)
+    {
+	printf("\nCorrect:\n Expected %d got %d \n",expect,result);
+    }
+    else 
+    {
+	printf("\nIncorrect:\n Expected %d got %d \n",expect,result);
+	exit (1);
+   }
+}
+
+int main(void)
+{
+	bool result;
+	result = palindrome(123);
+        printf("Input submitted to the function: 123");
+	check(false, result);
+	result = palindrome(121);
+        printf("Input submitted to the function: 121");
+	check(true, result);
+	printf("All Correct\n");
+	return 0;
+}
diff --git a/testapp/code_server.py b/testapp/code_server.py
index 1276c76..8b3f8f1 100755
--- a/testapp/code_server.py
+++ b/testapp/code_server.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python
 """This server runs an XMLRPC server that can be submitted code and tests
-and returns the output.  It *should* be run as root and will run as the user 
-'nobody' so as to minimize any damange by errant code.  This can be configured 
+and returns the output.  It *should* be run as root and will run as the user
+'nobody' so as to minimize any damange by errant code.  This can be configured
 by editing settings.py to run as many servers as desired.  One can also
 specify the ports on the command line.  Here are examples::
 
   $ sudo ./code_server.py
   # Runs servers based on settings.py:SERVER_PORTS one server per port given.
-  
+
 or::
 
   $ sudo ./code_server.py 8001 8002 8003 8004 8005
@@ -34,6 +34,7 @@ from settings import SERVER_PORTS, SERVER_TIMEOUT, SERVER_POOL_PORT
 
 MY_DIR = abspath(dirname(__file__))
 
+
 def run_as_nobody():
     """Runs the current process as nobody."""
     # Set the effective uid and to that of nobody.
@@ -46,15 +47,16 @@ def run_as_nobody():
 # c.f. http://pguides.net/python/timeout-a-function
 class TimeoutException(Exception):
     pass
-    
+
+
 def timeout_handler(signum, frame):
     """A handler for the ALARM signal."""
     raise TimeoutException('Code took too long to run.')
 
 
-################################################################################
+###############################################################################
 # `CodeServer` class.
-################################################################################
+###############################################################################
 class CodeServer(object):
     """A code server that executes user submitted test code, tests it and
     reports if the code was correct or not.
@@ -63,29 +65,29 @@ class CodeServer(object):
         self.port = port
         self.queue = queue
         msg = 'Code took more than %s seconds to run. You probably '\
-              'have an infinite loop in your code.'%SERVER_TIMEOUT
+              'have an infinite loop in your code.' % SERVER_TIMEOUT
         self.timeout_msg = msg
 
     def run_python_code(self, answer, test_code, in_dir=None):
-        """Tests given Python function (`answer`) with the `test_code` supplied.  
-        If the optional `in_dir` keyword argument is supplied it changes the 
-        directory to that directory (it does not change it back to the original when
-        done).  This function also timesout when the function takes more than 
-        SERVER_TIMEOUT seconds to run to prevent runaway code.
-
+        """Tests given Python function (`answer`) with the `test_code`
+        supplied. If the optional `in_dir` keyword argument is supplied
+        it changes the directory to that directory (it does not change
+        it back to the original when done). This function also timesout
+        when the function takes more than SERVER_TIMEOUT seconds to run
+        to prevent runaway code.
         Returns
         -------
-        
+
         A tuple: (success, error message).
-        
+
         """
         if in_dir is not None and isdir(in_dir):
             os.chdir(in_dir)
-            
+
         # Add a new signal handler for the execution of this code.
         old_handler = signal.signal(signal.SIGALRM, timeout_handler)
         signal.alarm(SERVER_TIMEOUT)
-         
+
         success = False
         tb = None
         try:
@@ -111,8 +113,8 @@ class CodeServer(object):
         finally:
             del tb
             # Set back any original signal handler.
-            signal.signal(signal.SIGALRM, old_handler) 
-            
+            signal.signal(signal.SIGALRM, old_handler)
+
         # Cancel the signal if any, see signal.alarm documentation.
         signal.alarm(0)
 
@@ -133,25 +135,26 @@ class CodeServer(object):
         If not, we assume they are relative paths w.r.t. the location of this
         code_server script.
 
-        If the optional `in_dir` keyword argument is supplied it changes the 
-        directory to that directory (it does not change it back to the original when
-        done).
+        If the optional `in_dir` keyword argument is supplied it changes the
+        directory to that directory (it does not change it back to the original
+        when done).
 
         Returns
         -------
-        
+
         A tuple: (success, error message).
-        
+
         """
         if in_dir is not None and isdir(in_dir):
             os.chdir(in_dir)
 
         def _set_exec(fname):
-            os.chmod(fname,  stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR
-                             |stat.S_IRGRP|stat.S_IWGRP|stat.S_IXGRP
-                             |stat.S_IROTH|stat.S_IWOTH|stat.S_IXOTH)
+            os.chmod(fname,  stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
+                     | stat.S_IRGRP | stat.S_IWGRP | stat.S_IXGRP
+                     | stat.S_IROTH | stat.S_IWOTH | stat.S_IXOTH)
         submit_f = open('submit.sh', 'w')
-        submit_f.write(answer.lstrip()); submit_f.close()
+        submit_f.write(answer.lstrip())
+        submit_f.close()
         submit_path = abspath(submit_f.name)
         _set_exec(submit_path)
 
@@ -168,7 +171,8 @@ class CodeServer(object):
         # Do whatever testing needed.
         success = False
         try:
-            success, err = self.check_bash_script(ref_path, submit_path, test_case_path)
+            success, err = self.check_bash_script(ref_path, submit_path,
+                                                  test_case_path)
         except TimeoutException:
             err = self.timeout_msg
         except:
@@ -176,7 +180,7 @@ class CodeServer(object):
             err = "Error: {0}".format(repr(value))
         finally:
             # Set back any original signal handler.
-            signal.signal(signal.SIGALRM, old_handler) 
+            signal.signal(signal.SIGALRM, old_handler)
 
         # Delete the created file.
         os.remove(submit_path)
@@ -204,7 +208,7 @@ class CodeServer(object):
             raise
         return proc, stdout, stderr
 
-    def check_bash_script(self, ref_script_path, submit_script_path, 
+    def check_bash_script(self, ref_script_path, submit_script_path,
                           test_case_path=None):
         """ Function validates student script using instructor script as
         reference. Test cases can optionally be provided.  The first argument
@@ -214,72 +218,447 @@ class CodeServer(object):
         permission.  The Third optional argument is the path to test the
         scripts.  Each line in this file is a test case and each test case is
         passed to the script as standard arguments.
-        
+
         Returns
         --------
 
-        returns (True, "Correct answer") : If the student script passes all test
-        cases/have same output, when compared to the instructor script
-        
-        returns (False, error_msg): If
-        the student script fails a single test/have dissimilar output, when
-        compared to the instructor script.
-        
-        Returns (False, error_msg): If mandatory arguments are not files or if the
-        required permissions are not given to the file(s).
-        
+        returns (True, "Correct answer") : If the student script passes all
+        test cases/have same output, when compared to the instructor script
+
+        returns (False, error_msg): If the student script fails a single
+        test/have dissimilar output, when compared to the instructor script.
+
+        Returns (False, error_msg): If mandatory arguments are not files or if
+        the required permissions are not given to the file(s).
+
         """
         if not isfile(ref_script_path):
-            return False, "No file at %s"%ref_script_path
+            return False, "No file at %s" % ref_script_path
         if not isfile(submit_script_path):
-            return False, 'No file at %s'%submit_script_path
+            return False, 'No file at %s' % submit_script_path
         if not os.access(ref_script_path, os.X_OK):
-            return False, 'Script %s is not executable'%ref_script_path
+            return False, 'Script %s is not executable' % ref_script_path
         if not os.access(submit_script_path, os.X_OK):
-            return False, 'Script %s is not executable'%submit_script_path
-        
+            return False, 'Script %s is not executable' % submit_script_path
+
         if test_case_path is None:
             ret = self._run_command(ref_script_path, stdin=None,
-                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                                    stdout=subprocess.PIPE,
+                                    stderr=subprocess.PIPE)
             proc, inst_stdout, inst_stderr = ret
-            ret  = self._run_command(submit_script_path, stdin=None,
-                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            ret = self._run_command(submit_script_path, stdin=None,
+                                    stdout=subprocess.PIPE,
+                                    stderr=subprocess.PIPE)
             proc, stdnt_stdout, stdnt_stderr = ret
             if inst_stdout == stdnt_stdout:
                 return True, 'Correct answer'
             else:
-                err = "Error: expected %s, got %s"%(inst_stderr, stdnt_stderr)
+                err = "Error: expected %s, got %s" % (inst_stderr,
+                                                      stdnt_stderr)
                 return False, err
         else:
             if not isfile(test_case_path):
-                return False, "No test case at %s"%test_case_path
+                return False, "No test case at %s" % test_case_path
             if not os.access(ref_script_path, os.R_OK):
-                return False, "Test script %s, not readable"%test_case_path
-            valid_answer = True  # We initially make it one, so that we can stop 
-                              # once a test case fails
-            loop_count = 0    # Loop count has to be greater than or equal to one.
-                              # Useful for caching things like empty test files,etc.
+                return False, "Test script %s, not readable" % test_case_path
+            valid_answer = True  # We initially make it one, so that we can
+                                 # stop once a test case fails
+            loop_count = 0  # Loop count has to be greater than or
+                            # equal to one.
+                            # Useful for caching things like empty
+                            # test files,etc.
             test_cases = open(test_case_path).readlines()
             num_lines = len(test_cases)
             for test_case in test_cases:
                 loop_count += 1
                 if valid_answer:
-                    args = [ ref_script_path ] + [x for x in test_case.split()]
-                    ret = self._run_command(args, stdin=None, 
-                                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                    args = [ref_script_path] + [x for x in test_case.split()]
+                    ret = self._run_command(args, stdin=None,
+                                            stdout=subprocess.PIPE,
+                                            stderr=subprocess.PIPE)
                     proc, inst_stdout, inst_stderr = ret
-                    args = [ submit_script_path ] + [x for x in test_case.split()]
-                    ret = self._run_command(args, stdin=None, 
-                                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                    args = [submit_script_path]+[x for x in test_case.split()]
+                    ret = self._run_command(args, stdin=None,
+                                            stdout=subprocess.PIPE,
+                                            stderr=subprocess.PIPE)
                     proc, stdnt_stdout, stdnt_stderr = ret
                     valid_answer = inst_stdout == stdnt_stdout
             if valid_answer and (num_lines == loop_count):
                 return True, "Correct answer"
             else:
-                err = "Error: expected %s, got %s"%(inst_stdout+inst_stderr,
-                                                    stdnt_stdout+stdnt_stderr)
+                err = "Error:expected %s, got %s" % (inst_stdout+inst_stderr,
+                                                     stdnt_stdout+stdnt_stderr)
                 return False, err
 
+    def run_c_code(self, answer, test_code, in_dir=None):
+        """Tests given C code  (`answer`) with the `test_code` supplied.
+
+        The testcode is a path to the reference code.
+        The reference code will call the function submitted by the student.
+        The reference code will check for the expected output.
+
+        If the path's start with a "/" then we assume they are absolute paths.
+        If not, we assume they are relative paths w.r.t. the location of this
+        code_server script.
+
+        If the optional `in_dir` keyword argument is supplied it changes the
+        directory to that directory (it does not change it back to the original
+        when done).
+
+        Returns
+        -------
+
+        A tuple: (success, error message).
+
+        """
+        if in_dir is not None and isdir(in_dir):
+            os.chdir(in_dir)
+
+        # File extension must be .c
+        submit_f = open('submit.c', 'w')
+        submit_f.write(answer.lstrip())
+        submit_f.close()
+        submit_path = abspath(submit_f.name)
+
+        ref_path = test_code.strip()
+        if not ref_path.startswith('/'):
+            ref_path = join(MY_DIR, ref_path)
+
+        # Add a new signal handler for the execution of this code.
+        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(SERVER_TIMEOUT)
+
+        # Do whatever testing needed.
+        success = False
+        try:
+            success, err = self._check_c_cpp_code(ref_path, submit_path)
+        except TimeoutException:
+            err = self.timeout_msg
+        except:
+            type, value = sys.exc_info()[:2]
+            err = "Error: {0}".format(repr(value))
+        finally:
+            # Set back any original signal handler.
+            signal.signal(signal.SIGALRM, old_handler)
+
+        # Delete the created file.
+        os.remove(submit_path)
+
+        # Cancel the signal if any, see signal.alarm documentation.
+        signal.alarm(0)
+
+        # Put us back into the server pool queue since we are free now.
+        self.queue.put(self.port)
+
+        return success, err
+
+    def _compile_command(self, cmd, *args, **kw):
+        """Compiles C/C++/java code and returns errors if any.
+        Run a command in a subprocess while blocking, the process is killed
+        if it takes more than 2 seconds to run.  Return the Popen object, the
+        stderr.
+        """
+        try:
+            proc_compile = subprocess.Popen(cmd, shell=True, stdin=None,
+                                            stdout=subprocess.PIPE,
+                                            stderr=subprocess.PIPE)
+            out, err = proc_compile.communicate()
+        except TimeoutException:
+            # Runaway code, so kill it.
+            proc_compile.kill()
+            # Re-raise exception.
+            raise
+        return proc_compile, err
+
+
+    def _check_c_cpp_code(self, ref_code_path, submit_code_path):
+        """ Function validates student code using instructor code as
+        reference.The first argument ref_code_path, is the path to
+        instructor code, it is assumed to have executable permission.
+        The second argument submit_code_path, is the path to the student
+        code, it is assumed to have executable permission.
+
+        Returns
+        --------
+
+        returns (True, "Correct answer") : If the student function returns
+        expected output when called by reference code.
+
+        returns (False, error_msg): If the student function fails to return
+        expected output when called by reference code.
+
+        Returns (False, error_msg): If mandatory arguments are not files or
+        if the required permissions are not given to the file(s).
+
+        """
+        if not isfile(ref_code_path):
+            return False, "No file at %s" % ref_code_path
+        if not isfile(submit_code_path):
+            return False, 'No file at %s' % submit_code_path
+
+        success = False
+        output_path = os.getcwd() + '/output'
+        compile_command = "g++  %s -c -o %s" % (submit_code_path, output_path)
+        ret = self._compile_command(compile_command)
+        proc, stdnt_stderr = ret
+
+        # Only if compilation is successful, the program is executed
+        # And tested with testcases
+        if stdnt_stderr == '':
+            executable = os.getcwd() + '/executable'
+            compile_main = "g++ %s %s -o %s" % (ref_code_path, output_path,
+                                                executable)
+            ret = self._compile_command(compile_main)
+            proc, main_err = ret
+            if main_err == '':
+                args = [executable]
+                ret = self._run_command(args, stdin=None,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.PIPE)
+                proc, stdout, stderr = ret
+                if proc.returncode == 0:
+                    success, err = True, "Correct answer"
+                else:
+                    err = stdout + "\n" + stderr
+                os.remove(executable)
+            else:
+                err = "Error:"
+                try:
+                    error_lines = main_err.splitlines()
+                    for e in error_lines:
+                        err = err + "\n" + e.split(":", 1)[1]
+                except:
+                        err = err + "\n" + main_err
+            os.remove(output_path)
+        else:
+            err = "Compilation Error:"
+            try:
+                error_lines = stdnt_stderr.splitlines()
+                for e in error_lines:
+                    if ':' in e:
+                        err = err + "\n" + e.split(":", 1)[1]
+                    else:
+                        err = err + "\n" + e
+            except:
+                err = err + "\n" + stdnt_stderr
+        return success, err
+
+    def run_cplus_code(self, answer, test_code, in_dir=None):
+        """Tests given C++ code  (`answer`) with the `test_code` supplied.
+
+        The testcode is a path to the reference code.
+        The reference code will call the function submitted by the student.
+        The reference code will check for the expected output.
+
+        If the path's start with a "/" then we assume they are absolute paths.
+        If not, we assume they are relative paths w.r.t. the location of this
+        code_server script.
+
+        If the optional `in_dir` keyword argument is supplied it changes the
+        directory to that directory (it does not change it back to the original
+        when done).
+
+        Returns
+        -------
+
+        A tuple: (success, error message).
+
+        """
+        if in_dir is not None and isdir(in_dir):
+            os.chdir(in_dir)
+
+        # The file extension must be .cpp
+        submit_f = open('submitstd.cpp', 'w')
+        submit_f.write(answer.lstrip())
+        submit_f.close()
+        submit_path = abspath(submit_f.name)
+
+        ref_path = test_code.strip()
+        if not ref_path.startswith('/'):
+            ref_path = join(MY_DIR, ref_path)
+
+        # Add a new signal handler for the execution of this code.
+        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(SERVER_TIMEOUT)
+
+        # Do whatever testing needed.
+        success = False
+        try:
+            success, err = self._check_c_cpp_code(ref_path, submit_path)
+        except TimeoutException:
+            err = self.timeout_msg
+        except:
+            type, value = sys.exc_info()[:2]
+            err = "Error: {0}".format(repr(value))
+        finally:
+            # Set back any original signal handler.
+            signal.signal(signal.SIGALRM, old_handler)
+
+        # Delete the created file.
+        os.remove(submit_path)
+
+        # Cancel the signal if any, see signal.alarm documentation.
+        signal.alarm(0)
+
+        # Put us back into the server pool queue since we are free now.
+        self.queue.put(self.port)
+
+        return success, err
+
+    def run_java_code(self, answer, test_code, in_dir=None):
+        """Tests given java code  (`answer`) with the `test_code` supplied.
+
+        The testcode is a path to the reference code.
+        The reference code will call the function submitted by the student.
+        The reference code will check for the expected output.
+
+        If the path's start with a "/" then we assume they are absolute paths.
+        If not, we assume they are relative paths w.r.t. the location of this
+        code_server script.
+
+        If the optional `in_dir` keyword argument is supplied it changes the
+        directory to that directory (it does not change it back to the original
+        when done).
+
+        Returns
+        -------
+
+        A tuple: (success, error message).
+
+        """
+        if in_dir is not None and isdir(in_dir):
+            os.chdir(in_dir)
+
+        # The file extension must be .java
+        # The class name and file name must be same in java
+        submit_f = open('Test.java', 'w')
+        submit_f.write(answer.lstrip())
+        submit_f.close()
+        submit_path = abspath(submit_f.name)
+
+        ref_path = test_code.strip()
+        if not ref_path.startswith('/'):
+            ref_path = join(MY_DIR, ref_path)
+
+        # Add a new signal handler for the execution of this code.
+        old_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(SERVER_TIMEOUT)
+
+        # Do whatever testing needed.
+        success = False
+        try:
+            success, err = self._check_java_code(ref_path, submit_path)
+        except TimeoutException:
+            err = self.timeout_msg
+        except:
+            type, value = sys.exc_info()[:2]
+            err = "Error: {0}".format(repr(value))
+        finally:
+            # Set back any original signal handler.
+            signal.signal(signal.SIGALRM, old_handler)
+
+        # Delete the created file.
+        os.remove(submit_path)
+
+        # Cancel the signal if any, see signal.alarm documentation.
+        signal.alarm(0)
+
+        # Put us back into the server pool queue since we are free now.
+        self.queue.put(self.port)
+
+        return success, err
+
+    def _check_java_code(self, ref_code_path, submit_code_path):
+        """ Function validates student code using instructor code as
+        reference.The first argument ref_code_path, is the path to
+        instructor code, it is assumed to have executable permission.
+        The second argument submit_code_path, is the path to the student
+        code, it is assumed to have executable permission.
+
+        Returns
+        --------
+
+        returns (True, "Correct answer") : If the student function returns
+        expected output when called by reference code.
+
+        returns (False, error_msg): If the student function fails to return
+        expected output when called by reference code.
+
+        Returns (False, error_msg): If mandatory arguments are not files or
+        if the required permissions are not given to the file(s).
+
+        """
+        if not isfile(ref_code_path):
+            return False, "No file at %s" % ref_code_path
+        if not isfile(submit_code_path):
+            return False, 'No file at %s' % submit_code_path
+
+        success = False
+        compile_command = "javac  %s" % (submit_code_path)
+        ret = self._compile_command(compile_command)
+        proc, stdnt_stderr = ret
+        stdnt_stderr = self._remove_null_substitute_char(stdnt_stderr)
+
+        # Only if compilation is successful, the program is executed
+        # And tested with testcases
+        if stdnt_stderr == '':
+            student_directory = os.getcwd() + '/'
+            student_file_name = "Test"
+            compile_main = "javac %s -classpath %s -d %s" % (ref_code_path,
+                                                             student_directory,
+                                                             student_directory)
+            ret = self._compile_command(compile_main)
+            proc, main_err = ret            
+            main_err = self._remove_null_substitute_char(main_err)
+
+            if main_err == '':
+                main_file_name = (ref_code_path.split('/')[-1]).split('.')[0]
+                run_command = "java -cp %s %s" % (student_directory,
+                                                  main_file_name)
+                ret = self._run_command(run_command,
+                                        stdin=None,
+                                        shell=True,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.PIPE)
+                proc, stdout, stderr = ret
+                if proc.returncode == 0:
+                    success, err = True, "Correct answer"
+                else:
+                    err = stdout + "\n" + stderr
+                    success = False
+                os.remove("%s%s.class" % (student_directory, main_file_name))
+            else:
+                err = "Error:\n"
+                try:
+                    error_lines = main_err.splitlines()
+                    for e in error_lines:
+                        if ':' in e:
+                            err = err + "\n" + e.split(":", 1)[1]
+                        else:
+                            err = err + "\n" + e
+                except:
+                        err = err + "\n" + main_err
+            os.remove("%s%s.class" % (student_directory, student_file_name))
+        else:
+            err = "Compilation Error:\n"
+            try:
+                error_lines = stdnt_stderr.splitlines()
+                for e in error_lines:
+                    if ':' in e:
+                        err = err + "\n" + e.split(":", 1)[1]
+                    else:
+                        err = err + "\n" + e
+            except:
+                err = err + "\n" + stdnt_stderr
+        return success, err
+
+    def _remove_null_substitute_char(self, string):
+        """Returns a string without any null and substitute characters"""
+        stripped = ""
+        for c in string:
+            if ord(c) is not 26 and ord(c) is not 0:
+                stripped = stripped + c
+        return ''.join(stripped)
 
     def run(self):
         """Run XMLRPC server, serving our methods.
@@ -291,9 +670,9 @@ class CodeServer(object):
         server.serve_forever()
 
 
-################################################################################
+###############################################################################
 # `ServerPool` class.
-################################################################################
+###############################################################################
 class ServerPool(object):
     """Manages a pool of CodeServer objects."""
     def __init__(self, ports, pool_port=50000):
@@ -330,7 +709,8 @@ class ServerPool(object):
         port = q.get()
         if was_waiting:
             print '*'*80
-            print "No available servers, was waiting but got server later at %d."%port
+            print "No available servers, was waiting but got server \
+                   later at %d." % port
             print '*'*80
             sys.stdout.flush()
         return port
@@ -345,7 +725,7 @@ class ServerPool(object):
         server.serve_forever()
 
 
-################################################################################
+###############################################################################
 def main():
     run_as_nobody()
     if len(sys.argv) == 1:
diff --git a/testapp/exam/forms.py b/testapp/exam/forms.py
index 7bbf601..8506de2 100644
--- a/testapp/exam/forms.py
+++ b/testapp/exam/forms.py
@@ -1,5 +1,5 @@
 from django import forms
-from exam.models import Profile,Quiz,Question
+from exam.models import Profile, Quiz, Question
 
 from django.contrib.auth import authenticate
 from django.contrib.auth.models import User
@@ -13,14 +13,18 @@ from string import letters, punctuation, digits
 import datetime
 
 QUESTION_TYPE_CHOICES = (
-       ("python", "Python"),
-       ("bash", "Bash"),
-       ("mcq", "MCQ"),
-       )
+        ("python", "Python"),
+        ("bash", "Bash"),
+        ("mcq", "MCQ"),
+        ("C", "C Language"),
+        ("C++", "C++ Language"),
+        ("java", "Java Language"),
+                        )
 
 UNAME_CHARS = letters + "._" + digits
 PWD_CHARS = letters + punctuation + digits
 
+
 class UserRegisterForm(forms.Form):
     """A Class to create new form for User's Registration.
     It has the various fields and functions required to register
@@ -28,7 +32,7 @@ class UserRegisterForm(forms.Form):
 
     username = forms.CharField\
                (max_length=30, help_text='Letters, digits,\
-               period and underscores only.')
+                period and underscores only.')
     email = forms.EmailField()
     password = forms.CharField(max_length=30, widget=forms.PasswordInput())
     confirm_password = forms.CharField\
@@ -114,20 +118,20 @@ class UserLoginForm(forms.Form):
 class QuizForm(forms.Form):
     """Creates a form to add or edit a Quiz.
     It has the related fields and functions required."""
-    
+
     start_date = forms.DateField(initial=datetime.date.today)
     duration = forms.IntegerField()
-    active = forms.BooleanField(required = False)
+    active = forms.BooleanField(required=False)
     tags = TagField(widget=TagAutocomplete())
     description = forms.CharField(max_length=256, widget=forms.Textarea\
-                                                (attrs={'cols':20,'rows':1}))
+                                  (attrs={'cols': 20, 'rows': 1}))
 
     def save(self):
         start_date = self.cleaned_data["start_date"]
         duration = self.cleaned_data["duration"]
         active = self.cleaned_data['active']
         description = self.cleaned_data["description"]
-        
+
         new_quiz = Quiz()
         new_quiz.start_date = start_date
         new_quiz.duration = duration
@@ -136,7 +140,7 @@ class QuizForm(forms.Form):
         new_quiz.save()
 
 class QuestionForm(forms.Form):
-    """Creates a form to add or edit a Question. 
+    """Creates a form to add or edit a Question.
     It has the related fields and functions required."""
 
     summary = forms.CharField(widget=forms.Textarea\
@@ -147,13 +151,13 @@ class QuestionForm(forms.Form):
     test = forms.CharField(widget=forms.Textarea\
                                     (attrs={'cols': 40, 'rows': 1}))
     options = forms.CharField(widget=forms.Textarea\
-                                (attrs={'cols': 40, 'rows': 1}),required=False)
+                              (attrs={'cols': 40, 'rows': 1}), required=False)
     type = forms.CharField(max_length=8, widget=forms.Select\
-                                        (choices=QUESTION_TYPE_CHOICES))
+                           (choices=QUESTION_TYPE_CHOICES))
     active = forms.BooleanField(required=False)
-    tags = TagField(widget=TagAutocomplete(),required=False)
+    tags = TagField(widget=TagAutocomplete(), required=False)
     snippet = forms.CharField(widget=forms.Textarea\
-                                (attrs={'cols': 40, 'rows': 1}),required=False)
+                              (attrs={'cols': 40, 'rows': 1}), required=False)
 
     def save(self):
         summary = self.cleaned_data["summary"]
diff --git a/testapp/exam/models.py b/testapp/exam/models.py
index da9bc0a..2aa02c9 100644
--- a/testapp/exam/models.py
+++ b/testapp/exam/models.py
@@ -18,7 +18,10 @@ QUESTION_TYPE_CHOICES = (
         ("python", "Python"),
         ("bash", "Bash"),
         ("mcq", "MultipleChoice"),
-        )
+        ("C", "C Language"),
+        ("C++", "C++ Language"),
+        ("java", "Java Language"),
+                        )
 
 ################################################################################
 class Question(models.Model):
@@ -234,4 +237,3 @@ the next."""
     def __unicode__(self):
         u = self.user
         return u'Question paper for {0} {1}'.format(u.first_name, u.last_name)
-
diff --git a/testapp/exam/views.py b/testapp/exam/views.py
index e2ff763..55ccd38 100644
--- a/testapp/exam/views.py
+++ b/testapp/exam/views.py
@@ -1016,7 +1016,7 @@ def user_data(request, username):
     """Render user data."""
 
     current_user = request.user
-    if not current_user.is_authenticated() or not is_moderator(user):
+    if not current_user.is_authenticated() or not is_moderator(current_user):
         raise Http404('You are not allowed to view this page!')
 
     data = get_user_data(username)
diff --git a/testapp/exam/xmlrpc_clients.py b/testapp/exam/xmlrpc_clients.py
index 817e37d..cc21e62 100644
--- a/testapp/exam/xmlrpc_clients.py
+++ b/testapp/exam/xmlrpc_clients.py
@@ -9,19 +9,25 @@ from settings import SERVER_PORTS, SERVER_POOL_PORT
 class ConnectionError(Exception):
     pass
 
-################################################################################
+###############################################################################
 # `CodeServerProxy` class.
-################################################################################
+###############################################################################
+
+
 class CodeServerProxy(object):
     """A class that manages accesing the farm of Python servers and making
     calls to them such that no one XMLRPC server is overloaded.
     """
     def __init__(self):
-        pool_url = 'http://localhost:%d'%(SERVER_POOL_PORT)
+        pool_url = 'http://localhost:%d' % (SERVER_POOL_PORT)
         self.pool_server = ServerProxy(pool_url)
         self.methods = {"python": 'run_python_code',
-                        "bash": 'run_bash_code'}
-    
+                        "bash": 'run_bash_code',
+                        "C": "run_c_code",
+                        "C++": "run_cplus_code",
+                        "java": "run_java_code",
+                        }
+
     def run_code(self, answer, test_code, user_dir, language):
         """Tests given code (`answer`) with the `test_code` supplied.  If the
         optional `in_dir` keyword argument is supplied it changes the directory
@@ -68,11 +74,10 @@ class CodeServerProxy(object):
             else:
                 done = True
         if not done:
-            raise ConnectionError("Couldn't connect to a server!") 
-        proxy = ServerProxy('http://localhost:%d'%port)
+            raise ConnectionError("Couldn't connect to a server!")
+        proxy = ServerProxy('http://localhost:%d' % port)
         return proxy
 
 # views.py calls this Python server which forwards the request to one
 # of the running servers.
 code_server = CodeServerProxy()
-
diff --git a/testapp/java_files/main_array_sum.java b/testapp/java_files/main_array_sum.java
new file mode 100644
index 0000000..5eae299
--- /dev/null
+++ b/testapp/java_files/main_array_sum.java
@@ -0,0 +1,36 @@
+class main_array_sum
+{
+    public static <E> void check(E expect, E result)
+    {
+        if(result.equals(expect))
+        {
+            System.out.println("Correct:\nOutput expected "+expect+" and got "+result);
+        }
+	else
+	{
+	    System.out.println("Incorrect:\nOutput expected "+expect+" but got "+result);
+	    System.exit(1);
+	}
+    }
+    public static void main(String arg[])
+    {
+       int result;
+       Test t = new Test();
+       int x[] = {0,0,0,0,0};
+       result = t.array_sum(x);
+       System.out.println("Input submitted to the function: {0,0,0,0,0}");
+       check(0, result);
+       int a[] = {1,2,3,4,5};
+       result = t.array_sum(a);
+       System.out.println("Input submitted to the function: {1,2,3,4,5}");
+       check(15, result);
+       int b[] = {1,2,3,0,0};
+       result = t.array_sum(b);
+       System.out.println("Input submitted to the function: {1,2,3,0,0}");
+       check(6, result);
+       int c[] = {1,1,1,1,1};
+       result = t.array_sum(c);
+       System.out.println("Input submitted to the function: {1,1,1,1,1}");
+       check(5, result);
+    }
+}
diff --git a/testapp/java_files/main_fact.java b/testapp/java_files/main_fact.java
new file mode 100644
index 0000000..325dab6
--- /dev/null
+++ b/testapp/java_files/main_fact.java
@@ -0,0 +1,29 @@
+class main_fact
+{
+    public static <E> void check(E expect, E result)
+    {
+        if(result.equals(expect))
+        {
+            System.out.println("Correct:\nOutput expected "+expect+" and got "+result);
+        }
+	else
+	{
+	    System.out.println("Incorrect:\nOutput expected "+expect+" but got "+result);
+	    System.exit(1);
+	}
+    }
+    public static void main(String arg[])
+    {
+       Test t = new Test();
+       int result;
+       result = t.factorial(0);
+       System.out.println("Input submitted to the function: 0");
+       check(1, result);
+       result = t.factorial(3);
+       System.out.println("Input submitted to the function: 3");
+       check(6, result);
+       result = t.factorial(4);
+       System.out.println("Input submitted to the function: 4");
+       check(24, result);
+    }
+}
diff --git a/testapp/java_files/main_great.java b/testapp/java_files/main_great.java
new file mode 100644
index 0000000..4bfcb1f
--- /dev/null
+++ b/testapp/java_files/main_great.java
@@ -0,0 +1,39 @@
+class main_great
+{
+    public static <E> void check(E expect, E result)
+    {
+        if(result.equals(expect))
+        {
+            System.out.println("Correct:\nOutput expected "+expect+" and got "+result);
+        }
+	else
+	{
+	    System.out.println("Incorrect:\nOutput expected "+expect+" but got "+result);
+	    System.exit(1);
+	}
+    }
+    public static void main(String arg[])
+    {
+       Test t = new Test();
+       int result;
+       result = t.greatest(1, 3, 4);
+       System.out.println("Input submitted to the function: 1, 3, 4");
+       check(4, result);
+       result = t.greatest(5, 10, 3);
+       System.out.println("Input submitted to the function: 5, 10, 3");
+       check(10, result);
+       result = t.greatest(6, 1, 4);
+       System.out.println("Input submitted to the function: 6, 1, 4");
+       check(6, result);
+       result = t.greatest(6, 11, 14);
+       System.out.println("Input submitted to the function: 6, 11, 14");
+       check(14, result);
+       result = t.greatest(3, 31, 4);
+       System.out.println("Input submitted to the function: 3, 31, 4");
+       check(31, result);
+       result = t.greatest(26, 13, 3);
+       System.out.println("Input submitted to the function: 26, 13, 3");
+       check(26, result);
+
+    }
+}
diff --git a/testapp/java_files/main_hello_name.java b/testapp/java_files/main_hello_name.java
new file mode 100644
index 0000000..84bb282
--- /dev/null
+++ b/testapp/java_files/main_hello_name.java
@@ -0,0 +1,29 @@
+class main_hello_name
+{
+    public static <E> void check(E expect, E result)
+    {
+        if(result.equals(expect))
+        {
+            System.out.println("Correct:\nOutput expected "+expect+" and got "+result);
+        }
+	else
+	{
+	    System.out.println("Incorrect:\nOutput expected "+expect+" but got "+result);
+	    System.exit(1);
+	}
+    }
+    public static void main(String arg[])
+    {
+       Test t = new Test();
+       String result;
+       result = t.hello_name("Raj");
+       System.out.println("Input submitted to the function: 'Raj'");
+       check("hello Raj", result);
+       result = t.hello_name("Pratham");
+       System.out.println("Input submitted to the function: 'Pratham'");
+       check("hello Pratham", result);
+       result = t.hello_name("Ram");
+       System.out.println("Input submitted to the function: 'Ram'");
+       check("hello Ram", result);
+    }
+}
diff --git a/testapp/java_files/main_palindrome.java b/testapp/java_files/main_palindrome.java
new file mode 100644
index 0000000..bd463e5
--- /dev/null
+++ b/testapp/java_files/main_palindrome.java
@@ -0,0 +1,29 @@
+class main_palindrome
+{
+    public static <E> void check(E expect, E result)
+    {
+        if(result.equals(expect))
+        {
+            System.out.println("Correct\n:Output expected "+expect+" and got "+result);
+        }
+	else
+	{
+	    System.out.println("Incorrect:\nOutput expected "+expect+" but got "+result);
+	    System.exit(1);
+	}
+    }
+    public static void main(String arg[])
+    {
+       Test t = new Test();
+       boolean result;
+       result= t.palindrome(123);
+       System.out.println("Input submitted to the function: 123");
+       check(false, result);
+       result = t.palindrome(151);
+       System.out.println("Input submitted to the function: 151");   
+       check(true, result);
+       result = t.palindrome(23432);
+       System.out.println("Input submitted to the function: 23432");
+       check(true, result);
+    }
+}
diff --git a/testapp/java_files/main_square.java b/testapp/java_files/main_square.java
new file mode 100644
index 0000000..5cb8c35
--- /dev/null
+++ b/testapp/java_files/main_square.java
@@ -0,0 +1,32 @@
+class main_square
+{
+    public static <E> void check(E expect, E result)
+    {
+        if(result.equals(expect))
+        {
+            System.out.println("Correct:\nOutput expected "+expect+" and got "+result);
+        }
+	else
+	{
+	    System.out.println("Incorrect:\nOutput expected "+expect+" but got "+result);
+	    System.exit(1);
+	}
+    }
+    public static void main(String arg[])
+    {
+       Test t = new Test();
+       int result, input, output;
+       input = 0; output = 0;
+       result = t.square_num(input);
+       System.out.println("Input submitted to the function: "+input);
+       check(output, result);
+       input = 5; output = 25;
+       result = t.square_num(input);
+       System.out.println("Input submitted to the function: "+input);
+       check(output, result);
+       input = 6; output = 36;
+       result = t.square_num(input);
+       System.out.println("Input submitted to the function: "+input);
+       check(output, result);
+    }
+}
diff --git a/testapp/templates/exam/question.html b/testapp/templates/exam/question.html
index 7260d15..529b620 100644
--- a/testapp/templates/exam/question.html
+++ b/testapp/templates/exam/question.html
@@ -76,8 +76,14 @@ function update_time()
          
      	 <h4><u> {{ question.summary }} </u><font class=pull-right>(Marks : {{ question.points }}) </font></h4><br> 
 	 <font size=3 face=arial>	{{ question.description|safe }} </font>
+         {% if error_message %}
+	 <div class="alert alert-error">
+	 {% for e in error_message.splitlines %}
+	 {{ e|join:"" }} 
+	 <br/>
+	 {% endfor%}
+	 </div>{% endif %}
 
-         {% if error_message %}<h5>ERROR:</h5><div class="alert alert-error">{{ error_message }}</div>{% endif %}
          {% if success_msg %}
          <script type="text/javascript">
             alert("Congratulations, that's correct. Let's go to next question");
diff --git a/testapp/test_server.py b/testapp/test_server.py
index 0790816..2a17739 100644
--- a/testapp/test_server.py
+++ b/testapp/test_server.py
@@ -6,6 +6,7 @@ up the code server as::
 """
 from exam.xmlrpc_clients import code_server
 
+
 def check_result(result, check='correct answer'):
     if check != 'correct answer':
         assert result[0] == False
@@ -15,33 +16,206 @@ def check_result(result, check='correct answer'):
         assert result[0], result[1]
     assert check in result[1].lower(), result[1]
 
+
 def test_python():
     """Test if server runs Python code as expected."""
     src = 'while True: pass'
     result = code_server.run_code(src, '', '/tmp', language="python")
     check_result(result, 'more than ')
-
     src = 'x = 1'
-    result = code_server.run_code(src, 'assert x == 1', '/tmp', 
+    result = code_server.run_code(src, 'assert x == 1', '/tmp',
                 language="python")
     check_result(result, 'correct answer')
 
-    result = code_server.run_code(src, 'assert x == 0', '/tmp', 
+    result = code_server.run_code(src, 'assert x == 0', '/tmp',
                 language="python")
     check_result(result, 'assertionerror')
 
     src = 'abracadabra'
-    result = code_server.run_code(src, 'assert x == 0', '/tmp', 
+    result = code_server.run_code(src, 'assert x == 0', '/tmp',
             language="python")
     check_result(result, 'nameerror')
 
+
+def test_c():
+    """Test if server runs c code as expected."""
+    src = """
+                #include<stdiol.h>
+                int ad(int a, int b)
+                {return a+b;}
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C")
+    check_result(result, 'error')
+
+    src = """
+                int add(int a, int b)
+                {return a+b}
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C")
+    check_result(result, 'compilation error')
+
+    src = """
+                int add(int a, int b)
+                {while(1>0){}
+                return a+b;}
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C")
+    check_result(result, 'more than')
+
+    src = """
+                int add(int a, int b)
+                {return a+b;}
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C")
+    check_result(result, 'correct answer')
+
+    src = """
+                #include<stdio.h>
+                int add(int a, int b)
+                {printf("All Correct");}
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C")
+    check_result(result, 'incorrect')
+
+
+def test_cpp():
+    """Test if server runs c code as expected."""
+    src = """
+                int add(int a, int b)
+                {
+                     return a+b
+                }
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C++")
+    check_result(result, 'error')
+
+    src = """
+                int add(int a, int b)
+                {
+                     return a+b;
+                }
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C++")
+    check_result(result, 'correct answer')
+
+    src = """
+                int dd(int a, int b)
+                {
+                      return a+b;
+                }
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C++")
+    check_result(result, 'error')
+
+    src = """
+                int add(int a, int b)
+                {
+                      while(0==0)
+                      {}
+                      return a+b;
+                }
+          """
+    result = code_server.run_code(src, 'c_cpp_files/main.cpp',
+                                  '/tmp', language="C++")
+    check_result(result, 'more than')
+
+
+def test_java():
+    """Test if server runs java code as expected."""
+    src = """
+                class Test
+                {
+                int square_num(int a)
+                {
+                     return a*a;
+                }
+                }
+          """
+    result = code_server.run_code(src, 'java_files/main_square.java',
+                                  '/tmp', language="java")
+    check_result(result, 'correct answer')
+
+    src = """
+                class Test
+                {
+                int square_num(int a)
+                {
+                     return b*b;
+                }
+                }
+          """
+    result = code_server.run_code(src, 'java_files/main_square.java',
+                                  '/tmp', language="java")
+    check_result(result, 'error')
+
+    src = """
+                class Test
+                {
+                int square_nu(int a)
+                {
+                      return a*a;
+                }
+                }
+          """
+    result = code_server.run_code(src, 'java_files/main_square.java',
+                                  '/tmp', language="java")
+    check_result(result, 'error')
+
+    src = """
+                class Test
+                {
+                int square_num(int a)
+                {
+                      while(0==0)
+                      {}
+                }
+                }
+          """
+    result = code_server.run_code(src, 'java_files/main_square.java',
+                                  '/tmp', language="java")
+    check_result(result, 'more than')
+
+    src = """
+                class Test
+                {
+                int square_num(int a)
+                {
+                      return a+b
+                }
+                }
+          """
+    result = code_server.run_code(src, 'java_files/main_square.java',
+                                  '/tmp', language="java")
+    check_result(result, 'error')
+
+    src = """
+                class Test
+                {
+                int square_num(int a)
+                {
+                      return a+b
+                
+          """
+    result = code_server.run_code(src, 'java_files/main_square.java',
+                                  '/tmp', language="java")
+    check_result(result, 'error')
+
+
 def test_bash():
     """Test if server runs Bash code as expected."""
     src = """
 #!/bin/bash
     [[ $# -eq 2 ]] && echo $(( $1 + $2 )) && exit $(( $1 + $2 ))
     """
-    result = code_server.run_code(src, 
+    result = code_server.run_code(src,
             'docs/sample.sh\ndocs/sample.args', '/tmp', language="bash")
     check_result(result)
 
@@ -49,15 +223,15 @@ def test_bash():
 #!/bin/bash
     [[ $# -eq 2 ]] && echo $(( $1 - $2 )) && exit $(( $1 - $2 ))
     """
-    result = code_server.run_code(src, 
-            'docs/sample.sh\ndocs/sample.args', '/tmp', language="bash")
+    result = code_server.run_code(src,
+           'docs/sample.sh\ndocs/sample.args', '/tmp', language="bash")
     check_result(result, 'error')
 
     src = """\
 #!/bin/bash
     while [ 1 ] ; do echo "" > /dev/null ; done
     """
-    result = code_server.run_code(src, 
+    result = code_server.run_code(src,
             'docs/sample.sh\ndocs/sample.args', '/tmp', language="bash")
     check_result(result, 'more than ')
 
@@ -65,15 +239,15 @@ def test_bash():
 #!/bin/bash
     while [ 1 ] ; do echo "" > /dev/null
     '''
-    result = code_server.run_code(src, 
-            'docs/sample.sh\ndocs/sample.args', '/tmp', language="bash")
+    result = code_server.run_code(src,
+           'docs/sample.sh\ndocs/sample.args', '/tmp', language="bash")
     check_result(result, 'error')
 
     src = '''# Enter your code here.
 #!/bin/bash
     while [ 1 ] ; do echo "" > /dev/null
     '''
-    result = code_server.run_code(src, 
+    result = code_server.run_code(src,
             'docs/sample.sh\ndocs/sample.args', '/tmp', language="bash")
     check_result(result, 'oserror')
 
@@ -81,3 +255,5 @@ if __name__ == '__main__':
     test_python()
     test_bash()
     test_c()
+    test_cpp()
+    test_java()