# EclEmma: the free Java code coverage tool for Eclipse

Unit testing has a lot of aspects which are more or less equally important but code coverage is something on what you really have to pay attention. Depending on the complexity of our methods, more combinations are possible on arbitrary test inputs. Considering every permutation in some not-so-obvious cases takes some time and effort, and the chance to make a mistake – which will result in an uncovered piece of code – is even higher.

EclEmma is the right tool to measure the coverage of your code and to make sure that every single line is executed properly. It has plenty of useful features from which I’ll present only the Coverage tool. In this post you will:

• see how to run your unit tests through EclEmma
• how to interpret the output of the Coverage tool

I’m using EclEmma with JUnit4 but it will run with JUnit3 too. You will find any neccessary information regarding to the installation on EclEmma site: http://eclemma.org/.

So lets take a look at an example from the source of Qt Jambi. QPair of the com.trolltech.qt package is used to hold two generic values. There are 3 methods to test: public boolean equals(Object o), public String toString() and public QPair clone().

I won’t give any detailed explanations about the test methods since the main goal of this post is to introduce EclEmma. However if you are new in unit testing too you could take a look at one of my old posts Unit testing with Qt Jambi. There are a lot of resources about unit testing but that post is directly related with the currently studied examples.

Let’s take a look at public boolean equals(Object o) which is a method to check the equality of two objects (beware, it could be very tricky!). If you can’t access the resource above, don’t worry the code is reproduced here:

    /**
* Returns true if this pair is the same as the other pair. If any
* of the first or second members are null the result is false regardless.
* @param The other parameter
* @return True if they are equal.
*/
@Override
public boolean equals(Object o) {
QPair<?, ?> other = o instanceof QPair ? (QPair<?, ?>) o : null;
if (other == null || first == null || second == null || other.first == null || other.second == null)
return false;
return first.equals(other.first) && second.equals(other.second);
}


Our test case for this particular method is:

	@org.junit.Test
public void testEquals() {
assertTrue("qp1", qp1.equals(qp1));
assertFalse("qp2", qp1.equals(qp2));
assertFalse("qp3", qp1.equals(qp3));
}

@org.junit.Before
public void setUp() {

qp1 = new QPair<Integer, Integer>(3, 5);
qp2 = new QPair<Integer, Integer>(5, 3);
qp3 = new QPair<Integer, Boolean>(1, null);
qp4 = new QPair<Integer, Boolean>(null, true);
}


While the test case is opened, from the Run menu select Coverage As > JUnit Test. The JUnit test starts and EclEmma is calculating some measurable properties of your code. Now you should see something like this:

As EclEmma finished its job you can see the coverage result of your unit test code:

and the code of the tested class too:

But some of the lines appeared in yellow instead of green, what happened? If you take a closer look to these lines EclEmma will tell you that there are some uncovered branches in your code. In this particular case we have 5, 3 on line 79 and 2 on line 81:

Lets take a look again at our test and study it carefully:

	@org.junit.Test
public void testEquals() {
assertTrue("qp1", qp1.equals(qp1));
assertFalse("qp2", qp1.equals(qp2));
assertFalse("qp3", qp1.equals(qp3));
}

@org.junit.Before
public void setUp() {

qp1 = new QPair<Integer, Integer>(3, 5);
qp2 = new QPair<Integer, Integer>(5, 3);
qp3 = new QPair<Integer, Boolean>(1, null);
qp4 = new QPair<Integer, Boolean>(null, true);
}


Is there any assertion in our test which is running through this if:

               if (other == null || first == null || second == null || other.first == null || other.second == null)


Lets see: the expression inside if will be true iff at least one of those conditions between || is true. Our only assertion which involves null is this one:

               assertFalse("qp3", qp1.equals(qp3));


which is, obviously, won’t cover all the possible candidates in which the above if will be executed. This assertion covers exactly one case. Remember QPair(T, S), and because qp3 was constructed with (1, null) it covers:

               if (other == null || first == null || second == null || other.first == null || other.second == null)


Thanks EclEmma for pointing out this obvious mistake! After adding more assertions to cover all the possible cases you will see something like this:

All branches are covered properly! \o/

Of course this is just one from EclEmmma’s useful features. In case of big projects it is good to see how your overall coverage is forwarding, you can check that too:

As you can see we have a lots of work to do.

This was a very short but fair introduction about EclEmma’s main feature, using it on regular basis to check your unit tests functionality will save you lots of time.

# Generating color palettes – based on the Fibonacci sequence

We are continuously facing with complicated mathematical concepts every day, even without knowing about their existence.

Just take a look at the range of IP addresses. In ideal case an IP address tends to be closer to another IP address even when adding some new addresses between, the concept of the Hilbert curve:

The previous theory is highly applicable from machine point of view, but there are also plenty of theories applicable from human point of view. Maybe the most famous is the Golden Ratio or Divine Proportion:

In mathematics and the arts, two quantities are in the golden ratio if the ratio of the sum of the quantities to the larger quantity is equal to the ratio of the larger quantity to the smaller one.

=====|===
a    b


meaning, a+b is to a as a is to b. From the machine’s point of view, nothing particularly happens, it’s just a “constant” which values is 1.6180339887… (yes, with quotes, the value of this proportion is an irrational number therefore I’m not sure about using the term “constant” when talking about irrational numbers, if you think otherwise, leave a comment below). However this “constant” is really important when talking about beauty and perfection generally. It appears in everything which is aesthetic to us, humans:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, … as you may have already realized, the next number in this sequence should be 55+89=144. The numbers of the Fibonacci sequence, or the Fibonacci numbers. What could be so interesting in this sequence other than describing the growth of an idealized rabbit population?
If you don’t know yet, let me show you. Divide the current and the previous number of the Fibonacci sequence above, starting from the second element, repeating infinite times:

$\frac{1}{1} =1\newline\newline \frac{2}{1}=2\newline\newline \frac{3}{2}=1.5\newline\newline \frac{5}{3}=1.66..\newline\newline \frac{8}{5}=1.6\newline\newline \frac{13}{8}=1.625\newline\newline \frac{21}{13}=1.615\newline\newline \frac{34}{21}=1.61904...$

As you may have already discovered the results of these iterations are approaching to the value of the Golden Ratio (see above, it was: 1.6180339887…).

The question is appropriate: Is there any way to apply this abstract representation of the golden ration?

Let’s take a look at the hexadecimal representation of a color “from the web”, a0ff11. Each color consist of three components, the red: a0, the green: ff and the blue component: 11. The idea is very simple: increment every component by the elements of the Fibonacci sequence.

The implementation happened in JSP, because everyone needs to know JSP!!1 currently I’m advancing in JSP. 🙂
Nothing fancy just a simple opening page to gather the required parameters, like the base color, number of color in the palette and the component which have to be modified:

<html>
<title>Color Palette Generator</title>
<body>
<form action="generator.jsp" method="get">
<table>
<tr>
<td>Base color:</td><td><input name="baseColor" type="text" /></td>
</tr>
<tr>
<td>Palette size:</td><td><input name="sequence" type="number" /></td>
</tr>
<tr valign=top>
<td>Component to modify:</td><td>
<input type="checkbox" name="red" value="r" />Red
<br/>
<input type="checkbox" name="green" value="g" />Green
<br/>
<input type="checkbox" name="blue" value="b" />Blue
<br/>
<input type="submit" value="Generate" />
</td>
</tr>
</table>
</form>
</body>
</html>


modifying only by blue component

click to enlarge

Now some green magic:

click to enlarge

…and some red:

click to enlarge

And finally some of the colors I picked up randomly, all three modified components are rendered at once:

#2d9b27

#412c84

#24577b

d5f800

The code itself is quite simple.

<%@ page language="java" import="java.awt.Color,java.util.*"%>
<%!/* Some members of the mighty Fibonacci sequence
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987
*/
// and some of them what I found useful:

int fib[] = { 13, 21, 34, 55, 89, 144 };

//int fib[] = new int[] { 2, 3, 5, 8, 13, 21, 34 };
//int fib[] = new int[] { 5, 8, 13, 21, 34, 55, 89 };

public ArrayList generatePalette(Color baseColor, int n, String modifier) {
ArrayList<Color> colorVector = new ArrayList<Color>();
Color tmp = baseColor;
for (int i = 0; i < n; i++) {
tmp = generateColor(tmp, fib[i % 6], modifier);
}
return colorVector;
}

public Color generateColor(Color color, int delta, String modifier) {
int r = -1;
int g = -1;
int b = -1;

if (modifier.equals("r")) {
g = color.getGreen();
b = color.getBlue();
} else if (modifier.equals("g")) {
r = color.getRed();
b = color.getBlue();
} else if (modifier.equals("b")) {
r = color.getRed();
g = color.getGreen();
}

return new Color(r, g, b);
}

public String colorToStr(Color color) {
String r = Integer.toHexString(color.getRed());
String g = Integer.toHexString(color.getGreen());
String b = Integer.toHexString(color.getBlue());
r = r.length() < 2 ? "0" + r : r;
g = g.length() < 2 ? "0" + g : g;
b = b.length() < 2 ? "0" + b : b;
return r + g + b;
}

// if > 255 restart from 0
public int add(int old, int d) {
if (old + d > 255)
return old + d - 255;
else
return old + d;
}%>
<%
String baseColor = (String) request.getParameter("baseColor");
int colorToInt = Integer.parseInt(baseColor, 16);
Color newColor = new Color(colorToInt);
String sequence = (String) request.getParameter("sequence");
int times = Integer.parseInt(sequence);
String[] modifiers = new String[3];
modifiers[0] = (String) request.getParameter("red");
modifiers[1] = (String) request.getParameter("green");
modifiers[2] = (String) request.getParameter("blue");
%>
<html>
<title>Color Sequence Generator</title>
<body>
<%
for (int j = 0; j < modifiers.length; j++) {
if (modifiers[j] == null)
continue;
%>
<table class="main">
<tr>
<%
ArrayList palette = generatePalette(newColor, times,
modifiers[j]);
for (int i = 0; i < palette.size(); i++) {
String current = colorToStr((Color) palette.get(i));
%>
<td class="colorDiv" bgcolor="#<%=current%>"><font
class="colorName">#<%=current%></font></td>
<%
}
%>
</tr>
</table>
<%
}
%>
</body>
</html>


# Getting started with KDE development on openSUSE

Hi!

In this guide I’ll share my experiences and show you how to get started with KDE development. This article is based on the opensuse-wiki article on my personal solutions and on the helpful suggestions from the guys on #kde-devel channel.

If you are looking for something more official take a look to KDE TechBase.

Requirements:

1) Space required for source files, executables, etc. is ~6.5GB (yes, pretty huge because building with full debugging symbols).
2) Build dependencies: Here is the list for several distributions.
3) an svn client

The openSUSE KDE team also provides two scripts kde4-run-env, kde4-build-env to set up the environment variables for the build dependencies (2).

• Set up the environment

Some guides are suggesting the use of different startup scripts also. However I’ve created a new user for KDE development to protect my stable KDE configurations from my mistakes:

useradd -m -G users,audio,video -s /bin/bash kde-devel

you can do it without the -G option – like I did – If you want to create a user with default groups. And finally set a password for this user:

passwd kde-devel

Now you can continue your work on different ways, I did the following: my graphical session is running on tty6 and i started a new terminal session on tty1. To switch between terminal sessions use the <Ctrl>+<Alt>+<Fn>, n = 1,…,12 key combinations. This isn’t the best solution from the view of debugging because you can’t use clipboard between your terminal and graphical session and if something goes wrong and you need to copy+paste an output to the IRC channel/forums then this operation takes extra time.

su kde-devel cd ~

Copy the scripts kde4-run-env, kde4-build-env into kde-devel‘s home directory. and add the following line to the~/.profile:

. ~/kde4-build-env

Now execute the script kde4-build-env with

 . kde4-build-env

– actually re-logging with kde-devel have the same effect.

We’ll store everything what is related to KDE sources/build in the directory kde. Under kde create a subdirectory for the sources, and finally jump into the sources directory:
 mkdir ~/kde/sources cd ~/kde/sources

Now get the directory structure of KDE svn trunk:

svn checkout -N svn://anonsvn.kde.org/home/kde/trunk

with the -N option you are getting only the root directories without its contents. This will be useful later, after every checkout take a look to the current directory structure – just to see what are you doing.
So, you’ve checked out the trunk directory, go there

cd trunk

and check out the remaining directories.

svn up -N KDE cd KDE

KDE is the last directory on the svn before the three module directories: kdebase kdelibs kdepimlibs – containing: base runtime elements, Personal Information Management modules and the basic libraries. Check out the sources for every module with:

svn up kdelibs kdepimlibs kdebase.
*This may take some time depending on your network connection speed.

• Build the sources

We have all the sources just need to build them. The command cs is provided by the script kde4-build-env – if you’ve added the script properly to the .profile. First we need to build the kdelibs directory. Change the source patch to kdelibs with:

cs KDE/kdelibs

and start to build kdeblis:

cmakekde
*This may take some time depending on several factors, like systems load, CPU speed, etc.

Repeat this for the remaining modules:
 cs KDE/kdepimlibs cmakekde cs KDE/kdebase cmakekde 

Remember, you can pause the building/compiling with <Ctrl>+<Z>:
[1]+ Stopped cmakekde
and resume with:
fg 1.

• Run KDE 4

You can start from the terminal or with KDM. I started from a terminal session the KDM way is seems to be more complicated to implement.
Create a script runKDE:

 #!/bin/bash echo Setting up the KDE runtime environment. . kde4-run-env echo Starting the DBus session. eval dbus-launch --auto-syntax echo Starting the X server. export DISPLAY=:1 X -novtswitch \$DISPLAY & echo Starting KDE 4 on tty8 sleep 2 startkde 

and copy into /home/kde-devel/. Log out with kde-devel in your Konsole session. Switching between terminal sessions explained under “Set up the environment”. Now switch to tty1 and login as kde-devel and run the script runKDE:

 ./runKDE 
if the script doesn’t switch automatically to tty8 – where your KDE is starting – then switch manually. The first start takes more time because KDE is build the configuration from scratch.

• SVN Changes

For updating the sources just do:
 cs KDE svn up kdelibs kdepimlibs kdebase 
and repeat the steps under “Build the sources”.

It’s possbile that while trying to “svn up” your sources svn returns with an error like:
No such revision X. This happens because the synchronization between the mirrors providing the sources for the anonymous svn. Wait a few minutes and try again.

All comments and corrections are appreciated.

Happy hacking!

Plasmoids

Desktop

# Save the day

I planned a long weekend with my family. Right now there is around -15C out. After I realized that waiting to my train – which was late +100 minutes according to the schedule – without having heat in the waiting hall can be very unpleasant so I canceled my travel…

After arriving to my apartment I powered on our home server and… the power supply burned out! Great! I’ve already wasted 2 hours from my life in the city traffic+train station, lets go waste another 2 days without internet…

Fortunately, I forget to take home my old PII and it was sitting in my wardrobe. I took out it’s power supply – which was to big for my PIII in it’s size and to small in it’s capacity, but I’m sure that my server is totally unique now:

. Our systems are back online and everything worked perfectly so far. Actually I saved my whole weekend. 🙂

Nowadays Linux distributions are coming with a built in and precompiled kernel. They are: making the connection between your hardware and software, controlling softwares and resources on your PC/Laptop, they doing everything what is must-to-be for your system.
They have some positive and negative side-effects.
Generally the Linux “newbies” are happy with the precompiled kernel – no command line, no work, everything is up and running automatically. Nice! And you save a lot of time. But! You can compile kernel for your own requirements.
Positive side-effects of the own compiled kernel are:

• it may works faster then the precompiled
• you can save a lot of memory by unloading processes what you don’t need
• you are getting complete control of your system
• it is cool

Actually there are no negative side-effects, just some requirements. You need to know how to work under command line, how to compile, etc.
So i don’t want to waste your time, here is the link for the best/easiest kernel compiling how-to what I ever read.
It has been written by
How to compile your own Linux kernel for openSUSE.