How to resolve admin page opening issue after tomcat configuration in eclipse


So often you would have noticed after tomcat configuration in eclipse, the admin start page never opens!


Eclipse doesn’t copy the default application folders (e.g. ROOT) when it creates the tomcat specific folder inside the workspace.


  1. Go to your “eclipse-workspace -> .metadata -> .plugins -> org.eclipse.wst.server.core -> tmp<number> -> wtpwebapps” directory
  2. Copy the ROOT folder from your “apache installation home -> webapps” directory to the directory mentioned in Step 1.  If prompted with overwrite dialog box, select yes and proceed.
  3. Reload http://localhost/ page. Admin start page should now open without any issues!

Different ways for exchanging data between two heterogeneous systems

YAML - YAML ain't Markup language
SDL  - Simple Declarative Language
JSON - JavaScript Object Notation
XML  - Extensible Markup Language


It is a human friendly data serialization standard for all programming languages. It is specially suited for tasks where humans are likely to view or edit data structures such as configuration files, log files, inter-process messaging, cross-language data sharing.

It uses unicode printable characters to show data in natural and more meaningful way.

JSON ‘n’ YAML have different priorities. JSON’s foremost design goal is simplicity ‘n’ universality. Thus, JSON is trivial to generate and parse at the cost of reduced human readability. In contrast, YAML’s foremost design goals are human readability and support for serializing arbitrary native data structures. Thus, YAML allows for extremely readable files, but is more complex  to generate and parse.  YAML is viewed as superset of JSON and hence every JSON file is also a valid YAML file.

Below is a snippet of how a yaml file looks like:

SnakeYAML is a YAML parser and emitter for java programming language.


If two systems need to exchange data, the easiest way to do this is to pass the data as text since most systems can parse and process a textual input. The format of the text (indenting, keywords, special characters) is used to describe the data being exchanged. SDL is one more such format.

The Simple Declarative Language provides an easy way to describe lists, maps, and trees of typed data in a compact, easy to read representation. The simple and intuitive API allows you to read, write, and access all the datastructures using a single class. For property files, configuration files, logs, and simple serialization requirements, SDL provides a compelling alternative to XML and Properties files. Implementations are available for Java and .NET with more languages on the way.

Note: SDL homepage is down! Seems no new developments happening here!

people location="Tokyo" {
    person "Akiko" friendly=true {
        hobbies {
            hobby "hiking" times_per_week=2
            hobby "swimming" times_per_week=1

    person "Jim" {
        hobbies {
            hobby "karate" times_per_week=5


JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. These properties make JSON an ideal data-interchange language.

JSON is built on two structures:

  • Object: An object is an unordered set of name-value pairs. An object begins with { (left brace) and ends with } (right brace). Each name is followed by : (colon) and the name/value pairs are separated by , (comma).

  • Array: An array is an ordered collection of values. An array begins with [ (left bracket) and ends with ] (right bracket). Values are separated by , (comma).

A value can be a string in double quotes, or a number, or true or false or null, or an object or an array. These structures can be nested.

Following is an XML representation of some data:

<menu id="file" value="File">
<menuitem value="New" onclick="CreateNewDoc()" />
<menuitem value="Open" onclick="OpenDoc()" />
<menuitem value="Close" onclick="CloseDoc()" />

and below is it’s corresponding JSON representation:

{"menu": {
  "id": "file",
  "value": "File",
  "popup": {
    "menuitem": [
      {"value": "New", "onclick": "CreateNewDoc()"},
      {"value": "Open", "onclick": "OpenDoc()"},
      {"value": "Close", "onclick": "CloseDoc()"}

A java implementation of JSON is JSON-lib.

Add the following dependency in pom.xml file of your maven project to get JSON-lib jars.



XML was created to structure, store, and transport information. It is just information wrapped in tags. Someone must write a piece of software to send, receive or display it.

<?xml version="1.0"?>
<body>Don't forget me this weekend!</body>

It is widely used for the representation of arbitrary data structures (mostly in web services).

Existing APIs for XML processing:

  • SAX:  Document is read serially and its contents are reported as callbacks to various methods on a handler object of the user’s design. SAX is fast and efficient to implement, but difficult to use for extracting information at random from the XML, since it tends to burden the application author with keeping track of what part of the document is being processed.
  • DOM:  Document Object Model is an interface oriented API that allows for navigation of the entire document as if it were a tree of node objects representing the document’s contents. DOM implementations tend to be memory intensive, as they generally require the entire document to be loaded into memory and constructed as a tree of objects before access is allowed.

Mocking db calls in unit test

Here is my java class which is accessing DB to fetch movie names and then it validates if the fetched movie name has a movie called ‘Sangam’.

package com.sanjit;

import java.sql.*;

* Class accessing the DB to fetch some data, which is then used for some
* validation
* @author Sanjit Mohanty
* @version 0.1
*          <pre>
* Revision History:
* VERSION  DATE           AUTHOR            COMMENT
* 0.1      21-Jul-2010    Sanjit Mohanty    initial create
* </pre>

public class DBCallClass {

static Connection con;

public boolean isMovieSangam() throws SQLException {
ResultSet rs = fetchData();

while ( {
String movieName = rs.getString("moviename");

if (movieName == "Sangam") {
return true;

return false;

public ResultSet fetchData() throws SQLException {

String connectionURL = "jdbc:postgresql://localhost:123456/movies;user=java;password=samples";

try {
con = DriverManager.getConnection(connectionURL);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select moviename from movies");

return rs;
} catch (SQLException e) {
} catch (Exception e) {
} finally {

return null;

In order to unit test the above class, i’ve to mock the actual DB call and then return the test data. I’ve used powermock (with easymock api) library to achieve this.

So, the JUnit class for the above looks as below:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import static org.easymock.EasyMock.expect;
import static org.powermock.api.easymock.PowerMock.*;

import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import com.sanjit.DBCallClass;

* Example: Mocking the DB calls using powermock. Main Class:
* {@link com.sanjit.DBCallClass}
* @author Sanjit Mohanty
* @version 0.1
*          <pre>
* Revision History:
* VERSION  DATE           AUTHOR            COMMENT
* 0.1      21-Jul-2010    Sanjit Mohanty    initial create
* </pre>

@PrepareForTest({ DBCallClass.class, DriverManager.class })
public class DBCallClassTest {

private String connectionURL;
private String sql;
private boolean isMovieSangam;

public void initialization() {
connectionURL = "jdbc:postgresql://localhost:123456/movies;user=java;password=samples";
sql = "select moviename from movies";
isMovieSangam = false;

public void testIsMovieSangam() throws Exception {

// Create mocks and set expectations

// Instantiate the class under test
DBCallClass dbCall = new DBCallClass();

// Invoke the method to test
isMovieSangam = dbCall.isMovieSangam();

// Verify the results

private void createMocksAndSetExpectations() throws Exception {

Connection mockConnection = createMock(Connection.class);
Statement mockStatement = createMock(Statement.class);
ResultSet mockResultSet = createMock(ResultSet.class);

// Mocking Static Class




private void doVerification() {
Assert.assertEquals(true, isMovieSangam);

To use powermock (with easymock api) in a maven project, include the following dependencies to the pom.xml file:


But if you are using a non-maven based java project then you need to place cglib-nodep-2.2.2.jar,
easymock-3.1.jar, javassist-3.16.1-GA.jar, powermock-easymock-1.4.12-full.jar, powermock-module-junit4-1.4.12.jar
and objenesis-1.2.jar in your classpath. Pl. note versions are just an indicator, you should use the latest
versions of these jars.