After removing Eclipse from my system, then realizing that writing JUnit
tests will be on the exam
this year I figured that it would be faster just running the tests like I run normal .java
files.
After counsel from the elders telling me that running JUnit
tests without an IDE was stupid, I
figured that I had to run the tests without an IDE. After dealing with some export PATH
problems, I
finally got it working fine.
The first step is heading over to the junit
git repository, and downloading junit.jar
and hamcrest-core.jar
.
There are two ways of using these .jar
files.
- The
quick setup-slow run
way. This way use theno-global-path
folder as root. - The
slow setup-fast run
way. This way use theglobal-path
folder as root.
The skill of writing JUnit tests is not for me to teach, but for this example, I will show a basic FizzBuzz program with a few tests.
The full implementation of both files are in the directory of this repository.
Java class
that returns the result of the FizzBuzz word game using the method getResult()
.
// FizzBuzz.java
public class FizzBuzz {
public String getResult(int i) {
switch(i % 15) {
// logic ...
}
}
}
JUnit test class
that implement different test methods for testing the getResult()
method.
// FizzBuzzTest.java
import org.junit.Test;
import static org.junit.Assert.assertEquls;
public class FizzBuzzTest {
@Test
public void test_getResult_returnBuzz() {
String result = new FizzBuzz().getResult(15);
assertEquals("FizzBuzz", result):
}
// more tests
}
When choosing the easy path all you need to do is adding the two .jar
files to the root of your
project, like done in no-global-path
. Then you can write your test, and head down to the "Running
easy tests" section.
After writing all the test cases, we want to check we are ready to compile. We cant compile like
normal using javac FizzBuzzTest.java
. We need to compile while referencing the .jar
files. So to
compile the tests, we will make sure to include the classpath.
javac -cp .:junit-4.12.jar FizzbuzzTest.java
This will tell the java compiler to run using the path .:junit-4.12.jar
. If everything works, you
should get no input, but find two fresh .class
files in your current directory. Then you should be
able to run the tests. When running the test, we need to set the classpath to both JUnit
and additionally, we need to set the classpath to hamcrest-core
. Then lastly we need to tell java to use the JUnitCore runner
on the FizzBuzzTest file.
java -cp .:junit-4.12.jar:hamcrest-core-1.3.jar org.junit.runner.JUnitCore FizzbuzzTest
JUnit should then output the test results. OK
for a good test or FAILURE
for a wrong test.
Each period( . )
represent one test.
JUnit version 4.12
.....
Time: 0.003
OK (5 tests)
When choosing the advanced you need to do some stuff before you are ready to go, to the end result is a lot better, and tests can be run with ease. Here the setup may change due to differences in operation system/shell/setup and so forth. The gist of it is that two things must be done.
- A global path needs to point to a location where the
.jar
files are located. - A shell script needs to be written to make life easy.
So in your stock shell config file you need to export the path of junit
export CLASSPATH=.:$CLASSPATH:~/JUnit/junit-4.12.jar:~/JUnit/hamcrest-core-1.3.jar
Then as seen in the path files, the CLASSPATH
point to a folder in the root directory of the
system called JUnit where both of the .jar
files are located.
Now you should be able to compile and run your tests with.
javac FizzBuzz.java FizzBuzzTest.java
java org.junit.runner.JUnitCore FizzBuzzTest
But this only runs one file and you will go mad if you have a big project with lots of tests. So a
script is due. Currently I have this script as a shortcut in my zshrc.sh
config file.
javat() {
printf "\n"
echo Compiling source/test code...
f=$(javac $(find . -name '*.java') -d $PWD)
if [[ $? != 0 ]]; then
echo "Compiling of code failed..."
else
echo Compiling of code success...
for f in *Test*.class
do
printf "\n------------------\n"
echo ${f%.*}
printf "------------------\n"
java org.junit.runner.JUnitCore ${f%.*}
done
echo Cleaning up...
rm *.class
fi
}
To make it short, the script removes all old .class
files, then tries to compile everything in the
project. If the compile is a success it runs each test file and outputs the result. Then it cleans
up by removing all the .class
files.
All you need to do then is run javat
in the root of your project.