Overview On Developing An Online Examination System Computer Science Essay

Published: Last Edited:

This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.

Online examinations, sometimes referred as e-examinations, are the examinations conducted through the internet or in an intranet (if within the Organization) for a remote candidate(s). Most of the examinations issue results as the candidate finish the examination, when there is an answer processing module also included with the system.

They can be used to efficiently evaluate the candidate thoroughly through a fully automated system that not only saves lot of time but also gives fast results.

For students they give papers according to their convenience and time and there is no need of using extra thing like paper, pen etc.

These examinations are conducted as open-book type examinations. Candidate is given a limited time to answer the questions and after the time expiry the answer paper is disabled automatically and answers is sent to the examiner. The examiner will evaluate answers, either through automated process or manually and the results will be sent to the candidate through email or made available in the web site.

Today many organizations are conducting online examinations worldwide successfully and issue results online.

There are advantages and disadvantages in online examinations. The main advantage is that it can be conducted for remote candidates and evaluation of answers can be fully automated for Multiple Choice questions and other essay type questions can be evaluated manually or through automated system, depending on the nature of the questions and the requirements. Also online examinations can be conducted at any time and does not incur higher cost as traditional exam scenario as there is no paper work involved(eg: printing exam papers, prepare paper admissions etc) , there is no invigilators, also no need of arrangement of exam centers. When comparing with traditional exam scenario the cost for an online examination will be almost zero after the online exam system is establishment and if maintenance cost is not considered.

The disadvantage of the e-examination is the inability of invigilating. There are methodologies used in these examinations, when registering candidates and presentation of questions, so that to test candidates knowledge and skills. However with a limited time, candidate is not capable of totally depend on the reference materials or a supporting person.


The aim of this project is to develop an online examination system by applying software engineering principles and best practices. The system will be built using popular Java/J2EE web technologies and framework available for web development. The system will be designed to be scalable, secure and robust.

The online examination system will help in speeding up the process of conducting examination. Teachers will be able to create examinations by composing a set of questions. The questions can be multiple choice questions or single (text) answer question. The system will have the ability to automatically process the results of examination based on the question database. The system will have intelligent capabilities to mark the text based answers not only when there is an exact match, but it will also recognize similar answers by finding the synonyms of the words used in the answer. The system will also provide manual override feature where in the teacher can manually mark or update the result for an exam. The system will also have the capability to resume the examination from last save point, i.e., a student can stop the examination in the middle and can start again at any other time. When the student will start the same examination again, the exam will start from the same point where it was stopped.

The system will present a easy to use interface for Teachers, Students and Administrators. Once logged in, students will be able to see the examinations due and can take the examination.



Paper -Based Examination:

Paper -based examination are carrried out on fixed days and according to a fixed schedule. Therefore, the absentees rarely have another chance to take up the exam again. Moreover, they involve a lot of paper work (e.g. printing of exam papers, arranging answer sheets, etc ). The evaluation of these exam is also very tedious job,after the students complete their exams, theteacher has to mark each paper manually and then consolidate the result. This process is very cumbersome and takes a lot of time and hard work.

Web- Based Examination:

With the emergence of online examinations, the World Wide Web opens up the possibility of giving the exams online.

The online examination system helps in speeding up the process of conducting examination. Teachers will be able to create examinations by composing a set of questions.

The system will have intelligent capabilities to mark the text based answers not only when there is an exact match, but it will also recognize similar answers by finding the synonyms of the words used in the answer. The system will also provide manual override feature where in the teacher can manually mark or update the result for an exam.

The system will also have the capability to resume the examination from last save point, i.e., a student can stop the examination in the middle and can start again at any other time. When the student will start the same examination again, the exam will start from the same point where it was stopped.

The system will present a easy to use interface for Teachers, Students and Administrators. Once logged in, students will be able to see the examinations due and can take the examination.


Web applications are either service oriented or presentation oriented. A presentation oriented web application involves generally mark up languages (e.g. XML and HTML) with dynamic contents responding to requests. On the other hand, a service oriented web applications implements the endpoint of the web service. Below is an analysis on Postgres, Hibernate, Spring and Wicket used to implement my project.


PostgreSQL is an object-relational database management system (ORDBMS) based on POSTGRES,Version 4.2 (http://s2k-ftp.CS.Berkeley.EDU:8000/postgres/postgres.html), developed at the University of California at Berkeley Computer Science Department. The POSTGRES project, led by Professor Michael Stonebraker, was sponsored by the Defense Advanced Research Projects Agency (DARPA),the Army Research Office (ARO), the National Science Foundation (NSF), and ESL, Inc.

PostgreSQL is an open-source descendant of this original Berkeley code. It provides SQL92/SQL99language support and other modern features.

POSTGRES pioneered many of the object-relational concepts now becoming available in some

commercial databases. Traditional relational database management systems (RDBMS) support a data model consisting of a collection of named relations, containing attributes of a specific type. In current commercial systems, possible types include floating point numbers, integers, character strings, money,and dates. It is commonly recognized that this model is inadequate for future data processing applications. The relational model successfully replaced previous models in part because of its simplicity. However, as mentioned, this simplicity often makes the implementation of certainapplications very difficult. Postgres offers substantial additional power by incorporating the following additional concepts in such a way that users can easily extend the system: inheritance data types functions

Other features provide additional power and flexibility:




transaction integrity

These features put Postgres into the category of databases referred to as object-relational.


Spring Features

Spring is a layered Java/J2EE application platform, based on code published in Expert One-on-One J2EE Design and Development by Rod Johnson (Wrox, 2002).

Spring includes:

The most complete lightweight container, providing centralized, automated configuration and wiring of your application objects. The container is non-invasive, capable of assembling a complex system from a set of loosely-coupled components (POJOs) in a consistent and transparent fashion. The container brings agility and leverage, and improves application testability and scalability by allowing software components to be first developed and tested in isolation, then scaled up for deployment in any environment (J2SE or J2EE).


A common abstraction layer for transaction management, allowing for pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Generic strategies for JTA and a single JDBC DataSource are included. In contrast to plain JTA or EJB CMT, Spring's transaction support is not tied to J2EE environments.


A JDBC abstraction layer that offers a meaningful exception hierarchy (no more pulling vendor codes out of SQLException), simplifies error handling, and greatly reduces the amount of code you'll need to write. You'll never need to write another finally block to use JDBC again. The JDBC-oriented exceptions comply to Spring's generic DAO exception hierarchy.


Integration with Toplink, Hibernate, JDO, and iBATIS SQL Maps: in terms of resource holders, DAO implementation support, and transaction strategies. First-class Hibernate support with lots of IoC convenience features, addressing many typical Hibernate integration issues. All of these comply to Spring's generic transaction and DAO exception hierarchies.


AOP functionality, fully integrated into Spring configuration management. You can AOP-enable any object managed by Spring, adding aspects such as declarative transaction management. With Spring, you can have declarative transaction management without EJB... even without JTA, if you're using a single database in Tomcat or another web container without JTA support.


A flexible MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. Note that a Spring middle tier can easily be combined with a web tier based on any other web MVC framework, like Struts, WebWork, or Tapestry.


Hibernate is popular open source object relational mapping tool for Java platform. It provides powerful, ultra-high performance object/relational persistence and query service for Java. Hibernate lets you develop persistent classes following common Java idiom - including association, inheritance, polymorphism, composition and the Java collections framework. The Hibernate Query Language, designed as a "minimal" object-oriented extension to SQL, provides an elegant bridge between the object and relational worlds. Hibernate also allows you to express queries using native SQL or Java-based Criteria and Example queries. Hibernate is now the most popular object/relational mapping solution for Java.

Hibernate maps the Java classes to the database tables. It also provides the data query and retrieval facilities that significantly reduces the development time. Hibernate is not the best solutions for data centric applications that only uses the stored-procedures to implement the business logic in database. It is most useful with object-oriented domain modes and business logic in the Java-based middle-tier. Hibernate allows transparent persistence that enables the applications to switch any database. Hibernate can be used in Java Swing applications, Java Servlet-based applications, or J2EE applications using EJB session beans.

Features of Hibernate

Hibernate 3.0 provides three full-featured query facilities: Hibernate Query Language, the newly enhanced Hibernate Criteria Query API, and enhanced support for queries expressed in the native SQL dialect of the database.

Filters for working with temporal (historical), regional or permissioned data.

Enhanced Criteria query API: with full support for projection/aggregation and subselects.

Runtime performance monitoring: via JMX or local Java API, including a second-level cache browser.

Eclipse support, including a suite of Eclipse plug-ins for working with Hibernate 3.0, including mapping editor, interactive query prototyping, schema reverse engineering tool.

Hibernate is Free under LGPL: Hibernate can be used to develop/package and distribute the applications for free.

Hibernate is Scalable: Hibernate is very performant and due to its dual-layer architecture can be used in the clustered environments.

Less Development Time: Hibernate reduces the development timings as it supports inheritance, polymorphism, composition and the Java Collection framework.

Automatic Key Generation: Hibernate supports the automatic generation of primary key for your.

JDK 1.5 Enhancements: The new JDK has been released as a preview earlier this year and we expect a slow migration to the new 1.5 platform throughout 2004. While Hibernate3 still runs perfectly with JDK 1.2, Hibernate3 will make use of some new JDK features. JSR 175 annotations, for example, are a perfect fit for Hibernate metadata and we will embrace them aggressively. We will also support Java generics, which basically boils down to allowing type safe collections.

EJB3-style persistence operations: EJB3 defines the create() and merge() operations, which are slightly different to Hibernate's saveOrUpdate() and saveOrUpdateCopy() operations. Hibernate3 will support all four operations as methods of the Session interface.

Hibernate XML binding enables data to be represented as XML and POJOs interchangeably.

The EJB3 draft specification support for POJO persistence and annotations.



Swing-like OO Component Model : Pages and Components in Wicket are real Java objects that support encapsulation, inheritance and events.

Ease of Development : Because Wicket is Java and HTML, you can leverage what you know about Java or your favorite HTML editor to write Wicket applications.

Separation of Concerns : Wicket does not mix markup with Java code and adds no special syntax to your markup files. The worlds of HTML and Java are parallel and associated only by Wicket ids, which are attributes in HTML and Component properties in Java. Since Wicket HTML is just HTML and Wicket Java is just Java, coders and designers can work independently to a large degree and without relying on any special tools.

Secure : Wicket is secure by default. URLs do not expose sensitive information and all component paths are session-relative. Explicit steps must be taken to share information between sessions. There are plans for the next version of Wicket to add URL encryption to support highly secure web sites.

Transparent, Scalable Clustering Support : All Wicket applications will work on a cluster automatically and without additional work. Once bottlenecks are understood, Wicket enables tuning of page state replication. The next version of Wicket will support client-side models for zero-state scalability.

Transparent Back Button Support : Wicket supports configurable page version management. When users submit a form or follow a link from a page they accessed with the back button in their browser, Wicket is able to revert the page object to the state it was in when the page was originally rendered. This means you can write web applications that support the back button with very little work.

Multi-tab and multi-window support : Wicket provides an easy way to write application that supports multi-window and multi-tab usage allowing developer to react properly when users open new browser window or tab

Reusable Components : Reusable components in Wicket are particularly easy to create. Not only can you extend existing components with the Java extends keyword, but you can also create Panel components which associate a group of components as a reusable unit.

Simple, Flexible, Localizable Form Validation : It is trivial to write and use validators in Wicket. It is also quite easy to customize and localize the display and content of validation error messages.

Typesafe Sessions : Wicket eliminates the need to manage HttpSession attributes by hand. Page and component objects are transparently stored in the session and your application can create a custom session subclass with typesafe properties as well. All objects stored in the session can automatically participate in clustering replication.

Factory Customizable : Wicket is very extensible. Most operations are customizable through factories or factory methods.

Detachable Models : Model objects in Wicket can be very lightweight in terms of memory and network use in a cluster. When a model is used, it can "attach", populating itself with information from persistent storage. When the model is no longer in use, transient information can be reset, reducing the size of the object.

Border Components : Wicket Border components enable the decoration of pages in a reusable fashion. This is especially useful for inheritance of common navigational structures or layout.

Support for All Basic HTML Features : Wicket supports image tags, links, forms and everything else that you're used to using in your web application development.

Programmatic Manipulation of Attributes : Wicket Components can programmatically change any HTML tag attribute.

Automatic Conversions : Once a Form validates, the model can be updated using Wicket converters. Most ordinary conversions are built-in and it is easy to write new converters.

Dynamic Images : Wicket makes image use, sharing and generation very easy. Dynamic images can be created by simply implementing a paint method.

Pageable ListView : ListViews in Wicket are extremely powerful. You can nest any kind of component in a ListView row, even other ListViews. PageableListView supports navigation links for large lists.

Tree Component : Out of the box tree component for navigating and selecting nodes.

Localization : HTML pages, images and resource strings can all be localized.


The requirement analysis stage consists in collecting and analyzing information about the part of the organization that is supported by the application.

This information helps us to identify the users' requirements for the new system. This will enable us to define the various functionalities of the new system. The identification of the requirements is important as a system with incomplete functionality can lead to a project failure.



Users of the system can be categorized as :





The system aims to be an improvement on the existing one, the paper based system by :

Fully automated system.

Less time and effort consuming.

Database should be well maintained with well structured database tables.

The system should be scalable.

Allow student and teachers to view the available exams.

Allow student and teacher to view marks.

Allow admin to manage the user system and exam system


Security : Each user is required to log into the system. This is done using a valid username and password. Login and password should be kept secret.

Reliability : The system would be used by more than 200 students in the Computer Science Department, which includes academic and administrative staff. The system should ensure minimum downtime and be able to handle multiple requests.

Ease of Use : All the user screens should be easy to use and intuitive. Contact details should be provided in order to get in touch with the administrator.

Scalability : It is possible to extend the current features for future use of the system.

Performance : The system should have a quick response time .


Specific functionality provided to the Admin:

Manage User System : Admin can create a new user. Activate/deactivate an existing user.Admin can delete and edit a user.

Manage Examination : Admin can edit an exam and assign exam to students. Admin can activate/deactivate any exam. Admin can also delete an exam.

Specific functionality provided to the Teacher:

Manage Examination : Teacher can create a new exam, edit existing exam. Create questions is one of the important functionality. Question can be textual or it can be single/multiple choice.

Mark Exam : Teacher can do the marking of the exam either manually or it can be automated.

Specific functionality provided to the Student :

Answer Exam : Student can answer the exam assigned.

View Point : Student can view the point of a question. He can also view his marks in a particular exam.


Task no.

Task Name




Project Proposal


Deadline 30th September 2010


Requirements & Specifications


Identify the user's needs.


Research For technologies required by the system


Investigate the technologies to be used, the data structure.

Identify important features which can be applied to the project implementation.


Architectural Design


Define different layers of the system and apply appropriate technologies to each layer.


Database Design


Apply Database schema provided by the School IT support team. Add necessary tables and relationships between them to make the application functional.




Design Mock Interfaces of the application.


First Inspection


Start on 10th October 2010


Design Model


Class Diagrams

Sequence Diagrams


Coding Phase


It will include connections to the database server. Develop the interfaces. And implement the functionalities of the system.

Deadline 10th December 2010




Test all the features of the web application.


Final Inspection


Start on 20th December 2010




Write the dissertation.


Dissertation Submission


Deadline 7th January 2011



Table Name



Answer table is used to save all answer of student and right answer of teacher for each question


Configuration is used to save configuration information such as: term & condition, mark ratio


Examination table is used to save exam


ExamUser table is used to save user


Question table is used to save question


Role table is used to save role information


StudentExamination table is used to save the students which are assigned a particular exam. One student can have many examination and one examination can belongs to many students.


UserRole table is used for linking many-to-many relationship between user and role.


At the start of the application , a Welcome Page is displayed. On the left side there are three buttons namely Home, Help and Log in.

To log into the application , the user has to press the log in button.

It displays a login page.

The user is prompted to enter a username and a password. Any wrong login using invalid username and password will generate error message requiring the user to try again.

During the user authentication check, the system will determine the type of user (admin, student,teacher) and redirect the user to the correct page with appropriate features.


If the user logged in is admin, then Adminpage shows up. It has the following links

Manage Examination : Admin can manage the Examination System. It can view all the examinations created. The Admin can assign students the exams.

Manage User : Admin can manage the User System. This is used to manage the user data. Admin can create a new user, edit an existing , delete a user, enable / disable a user.

Configuration : This is used to change the configuration of the exam like terms & conditions and the marks ratio.



When the admin opts to create a new user, he inputs the user information like firstname, lastname, e-mail , username, password, course, role in the user management system.

There it is checked whether the user exists or not, and the user information entered is valid or not.

If it is valid it is saved into the database.

Otherwise, an error message is displayed.


Admin can activate/deactivate any user.

For this admin chooses a user from the user system, activate/deactivate the user.

Then save it into the database.


Admin can assign a particular exam to students.

Admin can activate or deactivate any exam.


If the user logged in is teacher, Teacherpage shows up. It has the following links :

Manage Examination : This is used to manage the existing exams in the database. A teacher can edit exam, create questions for a particular exam, view questions of a exam and mark a exam manually.

Create Question : This is used to create question. A question can be textual, single choice or multiple choice. A teacher can also edit the existing questions in the database.

Create Examination : This is used to create a new exam.

Help : This is to help the teacher in creating a question.



When the teacher opts to create an exam, he inputs the exam name, duration of the exam, description of the exam, mark type into the exam system.

There it is checked whether exam name exists or not, duration of the exam is valid or not.

If all is valid it is saved into the data base otherwise an error message is returned back to the teacher.

A teacher can also edit the existing exam in the database.


When the teacher opts to create a question for an exam.

He chooses the exam from the exam system and creates a question for it.

In the question management system it is checked whether the question content is correct or not.

If it is correct, it is saved into the database otherwise an error message is returned to the teacher.


When the teacher opts to mark an exam manually, he chooses the exam to be marked from the exam system.

He iterates each question and marks them.

Then he saves the marks into database.


If the user logged in is a student, studentpage shows up. It has the following link :

View Point : This is used to view the point assigned to a particular student.

Answer Exam : This is used to answer the exam assigned to the student.



A student can view his marks in any exam .


A student can answer any particular exam assigned to him. He can view point assigned to a question also.


Figure: Welcome Screen

This is the Welcome Screen of our application. On the left hand side there are three buttons : Home, Help, Log in. These enable the user to get to Home Page, Help and Log in helps the user to get logged into the system.

The same header and footer will be applicable to every page to preserve the consistency and integrity of the application.

We use the ApplicationContext.xml file to define some Java beans like dataSource, SessionFactory, etc so that we can retrieve them in the application. In this way we can reimplement the classes and use alternatively different implementations by just changing the configuration in the ApplicationContext.xml file.

Once you have a sessionfactory, your application asks the factory for a session. Your application will use Hibernate sessions to manage the persistent objects.

An application context configuration file is created for the entire application named applicationcontext.xml

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"


<property name="driverClassName" value="${jdbc.classname}" />

<property name="url" value="${jdbc.url}${jdbc.database}" />

<property name="username" value="${jdbc.username}" />

<property name="password" value="${jdbc.password}" />

<property name="initialSize" value="1" />

<property name="maxActive" value="50" />

<property name="maxIdle" value="1" />


<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"/>

<property name="configLocations" value="classpath:hibernate-model.xml"/>

<property name="dataSource" ref="dataSource"/>

<property name="hibernateProperties">


<prop key="hibernate.dialect">${hibernate.dialect}</prop>

<prop key="hibernate.show_sql">${hibernate.show-sql}</prop>

<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl-auto}</prop>




I need to define a web.xml File








Deploying the application will create a database called exam as shown below in the Figure



Create User By Admin


String firstName = firstNameModel.getObject();

String lastName = lastNameModel.getObject();

String email = emailModel.getObject();

String course = courseModel.getObject();

ExamUser user = new ExamUser();


user.setPassword(passwordEncoder.encodePassword(password, null));





String selectedRoleName = roleModel.getObject().trim();


Manage User By Admin


List<IColumn<?>> columns = new ArrayList<IColumn<?>>();

columns.add(new PropertyColumn(new Model<String>("ID"), "id") {


public String getCssClass() {

return "numeric";



columns.add(new PropertyColumn(new Model<String>("Username"), "username"));

columns.add(new PropertyColumn(new Model<String>("First Name"), "firstName", "firstName"));

columns.add(new PropertyColumn(new Model<String>("Last Name"), "lastName"));

columns.add(new PropertyColumn(new Model<String>("Email"), "email"));

columns.add(new PropertyColumn(new Model<String>("Status"), "status"));

columns.add(new PropertyColumn(new Model<String>("Role"), "roles", "printableRoles") {


public String getCssClass() {

return "role";



columns.add(new AbstractColumn<ExamUser>(new Model<String>("Actions")) {

public void populateItem(Item<ICellPopulator<ExamUser>> cellItem, String componentId,

IModel<ExamUser> model) {

cellItem.add(new ActionPanel(componentId, model));


DataTable dataTable = new DefaultDataTable("users", columns, new SortableUserDataProvider(userService), 8);

border.add(new PagingNavigator("navigator", dataTable));

border.add(dataTable); }

Manage Examination By Admin

List<IColumn<?>> columns = new ArrayList<IColumn<?>>();

columns.add(new PropertyColumn(new Model<String>("ID"), "id") {


public String getCssClass() {

return "numeric";



columns.add(new PropertyColumn(new Model<String>("Name"), "name"));

columns.add(new PropertyColumn(new Model<String>("Description"), "description"));

columns.add(new PropertyColumn(new Model<String>("Status"), "status"));

columns.add(new PropertyColumn(new Model<String>("Teacher"), "teacher.username"));


columns.add(new PropertyColumn(new Model<String>("Duration"), "duration"));

columns.add(new PropertyColumn(new Model<String>("Number Of Question"), "questions.size()"));

columns.add(new AbstractColumn<Examination>(new Model<String>("Actions")) {

public void populateItem(Item<ICellPopulator<Examination>> cellItem, String componentId,

IModel<Examination> model) {

cellItem.add(new ActionPanel(componentId, model));



DataTable dataTable = new DefaultDataTable("exams", columns, new SortableExaminationDataProvider(examinationService), 8);

border.add(new PagingNavigator("navigator", dataTable));



Answer Examination By Student


questionWizard = new QuestionWizard("wizard", examination, StudentQuestionStep.class, ManageExamination.class);


long duration = examination.getDuration();

final Counter remainTime = new Counter("remainTime", duration);


add(new AbstractAjaxTimerBehavior(Duration.seconds(1)) {

protected void onTimer(AjaxRequestTarget target) {


Manage Question By Teacher

A teacher can create, edit, view or delete a question.

The question can be Textual , Single choice or Multiple choice.

I have used a Wizard to create the QuestionWizard Page


public QuestionWizard(String id, Examination examination, Class stepClass, Class returnClass)

throws InvocationTargetException, IllegalAccessException, InstantiationException, NoSuchMethodException {


this.returnClass = returnClass;

setDefaultModel(new CompoundPropertyModel<QuestionWizard>(this));


If the answerType is single choice or multiple choice a Textarea is displayed where the teacher can enter the choices otherwise the teacher enters the textual answer in the correct answer textarea as depicted in the following snippet of CreateQuestion.html

function onAnswerTypeChange(obj) { if (obj.value == 2) { document.getElementById('answerOptions').style.display = 'none'; } else { document.getElementById('answerOptions').style.display = ''; }

Mark Manually By Teacher


Answer rightAnswer = answerService.getRightAnswer(question);

String rightAnswerDisplay = null;

if (rightAnswer != null) {

rightAnswerDisplay = rightAnswer.getAnswer();


Label lblOrder = new Label("rightAnswer", rightAnswerDisplay);



List<String> rightOrWrong = Arrays.asList("Correct", "Wrong");

resultModel = new Model<String>();

RadioChoice<String> listChoice = new RadioChoice<String>("rightOrWrong", resultModel, rightOrWrong);


ExamUser student = ((HttpSession) getSession()).getSelectedStudent();

studentAnswer = answerService.getAnswerByStudent(question, student);

String studentAnswerText;

if (studentAnswer != null) {

studentAnswerText = studentAnswer.getAnswer();

} else {

studentAnswerText = "don't answer";


Label lblStudentAnswer = new Label("studentAnswer", studentAnswerText);



TextAnalysis Utility

This utility helps in the text analysis for the textual answers. It helps in finding the synonyms for the answer given by the student.


public Map<String, Integer> getSynonymsWord(String word, int index) {

Map<String, Integer> words = new HashMap<String, Integer>();

try {

URL url = new URL("http://watson.kmi.open.ac.uk/API/term/synonyms?term=" + word);

URLConnection connection = url.openConnection();

if (connection instanceof HttpURLConnection) {

((HttpURLConnection) connection).setInstanceFollowRedirects(false); }

connection.setRequestProperty("Accept", "application/xml");


BufferedInputStream inputStream = new BufferedInputStream(connection.getInputStream());

BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

String line = br.readLine();

while (line != null) {

String newLine = Html2Text.convert(line).trim();

StringTokenizer stringTokenizer = new StringTokenizer(newLine);

while (stringTokenizer.hasMoreTokens()) {

String nextWord = stringTokenizer.nextToken();

words.put(nextWord, index);

line = br.readLine();


} catch (IOException ignored) { }

if (words.isEmpty()) {

words.put(word, 1); }

return words; }

After finding out the synonyms of the answer, then it is checked whether it is correct or not.

public boolean isCorrect(String studentAnswer, String correctAnswer) {

studentAnswer = trimString(studentAnswer.trim().toLowerCase());

correctAnswer = trimString(correctAnswer.trim().toLowerCase());

List<Map<String, Integer>> correctAnswerMapping = new ArrayList<Map<String, Integer>>();

List<String> correctWords = new ArrayList<String>();

StringTokenizer stringTokenizer = new StringTokenizer(correctAnswer);

while (stringTokenizer.hasMoreTokens()) {

String nextWord = stringTokenizer.nextToken();

Map<String, Integer> synonymsWords = getSynonymsWord(nextWord, correctWords.size());




List<String> matchedStrings = new ArrayList<String>();

stringTokenizer = new StringTokenizer(studentAnswer);

String comparedString = "";

while (stringTokenizer.hasMoreTokens()) {

String nextWord = stringTokenizer.nextToken();

boolean exist = false;

int correctCount;

for(correctCount = 0; correctCount < correctAnswerMapping.size(); correctCount++ ) {

Map<String, Integer> synonyms = correctAnswerMapping.get(correctCount);

if(synonyms.containsKey(nextWord)) {

exist = true;

break; }

if(exist) { for(int j = 0; j <= correctCount; j ++) {


comparedString += nextWord + " ";

if(!stringTokenizer.hasMoreTokens()) {


comparedString = "";

break; }

} else {

if(comparedString.trim().length() != 0) {



if(!stringTokenizer.hasMoreTokens()) {

comparedString = nextWord;

} else {

comparedString = "";

} } }

if(comparedString.length() != 0) {

for (Map<String, Integer> synonyms : correctAnswerMapping) {

if (synonyms.containsKey(comparedString)) {


break; } } }

int sameCount = 0;

for(String matchedItem : matchedStrings) {

sameCount += countWord(matchedItem);

} float ratio = ((float) sameCount / correctWords.size()) * 100;

if (markRatio != 0) {

return markRatio <= ratio;

} else {

return ratio == 100;}}





The base of the Black box testing strategy lies in the selection of appropriate data as per functionality and testing it against the functional specifications in order to check for normal and abnormal behaviour of the system. Now a days, it is becoming common to route the Testing work to a third party as the developer of the system knows too much of the internal logic and coding of the system, which makes it unfit to test the application by the developer.

In order to implement Black Box Testing Strategy, the tester is needed to be thorough with the requirement specifications of the system and as a user, should know, how the system should behave in response to the particular action.

This is the approach we will be using for testing our application.


White box testing strategy deals with the internal logic and structure of the code. White box testing is also called as glass, structural, open box or clear box testing. The tests written based on the white box testing strategy incorporate coverage of the code written, branches, paths, statements and internal logic of the code etc.

In order to implement white box testing, the tester has to deal with the code and hence is needed to possess knowledge of coding and logic i.e. internal working of the code. White box test also needs the tester to look into the code and find out which unit/statement/chunk of the code is malfunctioning.

Advantages of White box testing are:

i) As the knowledge of internal coding structure is prerequisite, it becomes very easy to find out which type of input/data can help in testing the application effectively.

ii) The other advantage of white box testing is that it helps in optimizing the code

iii) It helps in removing the extra lines of code, which can bring in hidden defects.

Disadvantages of white box testing are:

i) As knowledge of code and internal structure is a prerequisite, a skilled tester is needed to carry out this type of testing, which increases the cost.

ii) And it is nearly impossible to look into every bit of code to find out hidden errors, which may create problems, resulting in failure of the application.

This strategy can be used for testing our application by writing test cases specific to each requirement and then executing the test cases and observing the behaviour of the application against expected results. The tester will need to possess Java programming skills.


Unit Testing is the process where individual blocks, functions, methods, or "units" of code are tested individually.

A pre-determined set of input is used to generate an output which is compared against an expected output

It is different from "Integration Testing" where the interaction between structures is tested.


Integration testing (sometimes called Integration and Testing, abbreviated "I&T") is the phase in software testing in which individual software modules are combined and tested as a group. It occurs after unit testing and before system testing. Integration testing takes as its input modules that have been unit tested, groups them in larger aggregates, applies tests defined in an integration test plan to those aggregates, and delivers as its output the integrated system ready for system testing.

The purpose of integration testing is to verify functional, performance, and reliability requirements placed on major design items. These "design items", i.e. assemblages (or groups of units), are exercised through their interfaces using Black box testing, success and error cases being simulated via appropriate parameter and data inputs. Simulated usage of shared data areas and inter-process communication is tested and individual subsystems are exercised through their input interface. Test cases are constructed to test that all components within assemblages interact correctly, for example across procedure calls or process activations, and this is done after testing individual modules, i.e. unit testing. The overall idea is a "building block" approach, in which verified assemblages are added to a verified base which is then used to support the integration testing of further assemblages.

We are using Integration Testing in our application as we are testing different modules(Create, Edit, View, Delete) collectively once they have been built.


A test run of the application was conducted on a group of 10 users .

Check the Login



Check The

user role

Admin enters

user information

and saves it.

Display User



Detect Admin's


(Create User)

Display the

features available

to Admin

Identification Of

User as Admin

Display error


Login Successful

Login failed

Detects Log out

Log out

Exit the System




Display Admin



Exit the System

Flowchart Depicting The Sequence of Action For Create User By Admin

Create User By Admin

Test Case Name: Create User By Admin

Preconditions: The database and application is started successfully and waiting for action from user.

Steps : The steps the tester must execute to test the feature.

Select Login

Enter Username and Password.

Click on Create User Button

Enter the user information

Click Save Button

Expected results: The system should create a User record in the database with corresponding values of First Name, Last Name, Course, Role, Username, Password OR the user should be informed in case any error occurs in creating the record.

Pass/Fail: Passed

The response time of each user for the above steps was noted and the data collected is depicted in the table below:

Page name


Response Time


Response Time


Response Time

















CreateUser - Save






It is essential that the system built meets all the requirements of the user , but it is also important to include ideas and functions that as a developer you know that it would have real impact on the system enhancement and make the system more useful. These considerations also affect the system built namely Online Exam Server.

The system implemented is a considerable improvement on the old paper based version prominent in the University. The new system helps even the remotely located student to appear for the exam. A lot of time and effort is also saved from the process of conducting exams, marking answer sheets and consolidating the result.

Because of the time constraints I was unable to implement all the extra features included in my system design. Below are the additional (non-implemented) features which would make the user's task easier.

Manage Assignments : This feature is similar to the exam. A teacher can create an assignment and upload it in the database. A student can take the assignment and send it after completion.

Custom made application for ipad/iphone: Although the current application will work in the browser of ipad still we can enhance it to be custom made for devices like ipad/iphone.