Kategorien
Java

EasyMock, Unitils and a mixture of both

So, we do use unitils and easymock for quite a while now. We do our mocking with easymock and use the unitils-inject and unitils-easymock modules to simplify our tests.

But, there was a very weird behaviour. So I tried to boil it down to the reason why it fails. Here is some code that we actually want to test:

package de.matthiascoy.easymock.easymockprimitivetest;
public interface InterfaceB {
    void foobar(boolean b);
}
package de.matthiascoy.easymock.easymockprimitivetest;
public class TestedObjectClass {
    private InterfaceB interfaceB;
    public void runMe(boolean b) {
        interfaceB.foobar(b);
        interfaceB.foobar(b);
    }
}

So, obviously we want to test toe runMe-method and want to verify that the two calls on the interfaceB are actually done with the given arguments. Our first try was this code:

package de.matthiascoy.easymock.easymockprimitivetest;
import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.unitils.UnitilsJUnit4TestClassRunner;
import org.unitils.easymock.EasyMockUnitils;
import org.unitils.inject.annotation.InjectIntoByType;
import org.unitils.inject.annotation.TestedObject;

@RunWith(UnitilsJUnit4TestClassRunner.class)
public class EasyMockAndUnitilsTest {

    @TestedObject
    private TestedObjectClass testedObject;

    @InjectIntoByType
    private InterfaceB interfaceB;

    @Before
    public void setUp() {
        this.interfaceB = EasyMock.createMock(InterfaceB.class);
    }

    @Test(expected = AssertionError.class)
    public void testPrimitiveBoolean() {
        boolean B = true;

        interfaceB.foobar(B);
        EasyMock.expectLastCall();
        interfaceB.foobar(!B);
        EasyMock.expectLastCall();
        EasyMockUnitils.replay();

        testedObject.runMe(B);

        EasyMockUnitils.verify();
    }
}

What you can see is, that we do expect first TRUE and then FALSE, but that should fail. We do test that with the „expected=AssertionError“ value in the @Test annotation. But actually this tests fails, because there is no AssertionError. With just a „@Test“ the test just runs and shows us a green light. That’s very strange. So, we thought: must be a bug in the testingframework, but which one?

So, we created a EasyMock 3.2 only test

package de.matthiascoy.easymock.easymockprimitivetest;

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.EasyMockSupport;

import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(EasyMockRunner.class)
public class PureEasyMockTest extends EasyMockSupport {

    @TestSubject
    private TestedObjectClass testedObject = new TestedObjectClass();

    @Mock
    private InterfaceB interfaceBMock;

    @Test(expected = AssertionError.class)
    public void testPrimitiveBoolean() {
        boolean B = true;

        interfaceBMock.foobar(B);
        EasyMock.expectLastCall();
        interfaceBMock.foobar(!B);
        EasyMock.expectLastCall();

        replayAll();

        testedObject.runMe(B);

        verifyAll();
    }

    @Test(expected = AssertionError.class)
    public void testPrimitiveBooleanWithEq() {
        boolean B = true;

        interfaceBMock.foobar(EasyMock.eq(B));
        EasyMock.expectLastCall();
        interfaceBMock.foobar(EasyMock.eq(!B));
        EasyMock.expectLastCall();

        replayAll();

        testedObject.runMe(B);

        verifyAll();
    }
}

This test does work. So, easymock seems not to be the problem. Now, to unitils:

package de.matthiascoy.easymock.easymockprimitivetest;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.unitils.UnitilsJUnit4TestClassRunner;
import org.unitils.inject.annotation.InjectIntoByType;
import org.unitils.inject.annotation.TestedObject;
import org.unitils.mock.Mock;

@RunWith(UnitilsJUnit4TestClassRunner.class)
public class UnitilsTest {

    @TestedObject
    private TestedObjectClass testedObject;

    @InjectIntoByType
    private Mock<InterfaceB> interfaceB;

    @Test(expected = AssertionError.class)
    public void testPrimitiveBoolean() {
        boolean B = true;

        testedObject.runMe(B);

        interfaceB.assertInvoked().foobar(B);
        interfaceB.assertInvoked().foobar(!B);
    }
}

And this test just works fine as well. So, the problem must be somewhere in the middle. I’m still not sure where exactly, but the second call to interfaceB.foobar in EasyMockAndUnitilsTest.testPrimitiveBoolean does not care about the arguments. It does care about if it’s called or not, but the argument is ignored.

So, we decided to migrate all our tests to pure easymock. Maybe, somehow we will move to mockito at the end … maybe.

Kategorien
Java Programmiersprachen

Android programming for beginners

http://en.miui.com/thread-1766-1-1.html

hauptsächlich für mich als Linkablage 🙂

Kategorien
Java Linux

ant + bad version

Ich  hatte die ganze Zeit ein Problem, dass wenn ich mein JAVA_HOME auf java5 gebogen habe, dass sich ant verabschiedet hat mit

java.lang.UnsupportedClassVersionError: Bad version number in .class file

Also noch bevor überhaupt das build.xml ins Spiel kam. Nach ein bissle recherche liegt es daran, das die xerces-XML-lib in ubuntu ohne target gebaut ist und somit auf 1.6 steht. Das klappt dann natürlich nicht mit 1.5.

Der Fix den ich jetzt gemacht habe ist relativ trivial:

http://packages.ubuntu.com/de/quantal/all/libxerces2-java/download

dort, eigentlich vor seiner Zeit (Quantal ist ja noch nicht stable) wurde das target wieder auf 1.4 gesetzt und somit klappts auch mit den Nachbarn.

Kategorien
Java

Parallele jUnit-Tests ausführen

Hatte ich gestern mal gesucht und folgendes gefunden:

Scheduling Junit tests with RunnerScheduler for a concurrent execution | junit.org

Kategorien
Arbeit Java Sonstiges

Fehlermeldung des Tages

svn: Cannot create new file ‚/home/myuser/programs/eclipse/workspace-java/someservice/somemodule/src/test/config/default/datasets/.svn/tmp/prop-base/toller.langer.package.name.deutlich.laenger.als.hier.angegben.xml.svn-base.76854713-2901-0010-b32d-edbcf3a145b9.tmp‘: File name too long

Super.

Kategorien
Arbeit Java Sonstiges Spass

Fast schon Weihnachten

Jaja, wie die Zeit rumgeht. Schon wieder über einen Monat her das ich was geschrieben habe. Nunja, was kann ich erzählen … nicht soviel und das auch erstmal nur in Kurzform:

  • SCJP: Ich  hab mal angefangen da das Buch durchzulesen und werd das dann mit Marc und Stephan auch durchziehen, inkl. Prüfung. Mein Chef hat mir dann noch BlackBelt empfohlen.
  • SingStar: Ich bin ja stolzer Besitzer einer Playstation und wir (d.h. meine Arbeitskollegen und ich) haben schon eine Party veranstaltet. Morgen findet die nächste Iteration statt und, so wie es aussieht, werden wir das alle zwei Wochen durchziehen 🙂
  • Code Review: Haben wir jetzt schon zweimal durchgeführt. Gibt immer wieder spannende Diskussionen, manchmal auf Quellcode-Ebene, manchmal eher auf Prozess-Ebene. Aber immer gut und hitzig 🙂
  • Speeddating: Einmal durchgeführt. Mal schauen wie es sich entwickelt 🙂

Das wars auch schon. Da ich vermutlich bis Weihnachten nichts Neues schreiben werden, wünsche ich einfach mal:

FROHE WEIHNACHTEN

Kategorien
Arbeit Java

W-Jax 2009: Donnerstag

Historisch gewachsen? Architekturen dokumentieren und kommunizieren
Prinzipiell ein interessanter Vortrag, wie man Architekturen dokumentieren kann. Verweist ziemlich häuft wieder auf arc42-Template, aber das macht ja nichts. Sonst halt viel UML und BlaBla, wobei UML hier nur gewählt wurde, weil sich der Vortragende damit auskennt (kommt ja von Oose)

Details des Java-Memory-Modells: volatile-, final- und atomic-Felder – Angelika Langer
Das war ein spannender Vortrag. Was genau bewirken eigentlich diese Felder? Inwiefern geben sie Garantien ab? Was können Sie leisten und was nicht? Welche kann man in manchen Fällen als synchronised-Ersatz verwenden? Da ich diese drei Felderbezeichner bisher noch nie wirklich verwendet hatte (ausser final), fand ich es unglaublich faszinierend mal ein bißchen stärker in Thread-/Parallelprogrammierung reinzuschnuppern. Ich empfehle als Lektüre da auch mal

WJAX-Challenge
http://it-republik.de/jaxenter/wjax09/challenge

Kategorien
Arbeit Java Sonstiges

W-Jax 2009: Dienstag

Die W-Jax ist meine erste Konferenz, dementsprechend faszinierend finde ich die. Lauter Leute, alles Entwickler, bekannte Gesichter der Branche und fast nur gute Vorträge. Ich bin begeistert. Aber jetzt komm ich mal gleich zu den gehörten Vorträgen:

Why the next five years will be about languages – Ted Neward

Sehr witziger Vortrag über Sprachen an sich. Natürlich auch über den Hype namens DSL (Domain Specific Languages), aber prinzipiell darüber das nicht jede Sprache die Endlösung ist, das viele Sprachen überleben werden, obwohl sie keiner will und das es neue Sprachen geben wird, die jetzt noch keiner kennt. Quintessenz am Ende: Wer sich jetzt nicht um Sprachen kümmert, brauch später auch nur noch einen Satz: „Would you like fries with that“.

Back to the Basics: Anwendungen auf Basis von EJB 3.1 – Dirk Well

Ein kleiner Einführungskurs in EJB 3 mit Hinweisen was in EJB 3.1 noch dazu kommen wird. Im Prinzip nichts besonderes, da kann man auch einfach die Spezifikation lesen (wie fast immer :)), allerdings war es ganz nett mal eine Zusammenfassung zu sehen. Interessant könnte das @Asychnronous sein, das dann mit Future-Objekten arbeiten. Muss ich mir nochmal genauer anschauen. Weiterhin dazu kommt dann noch @Singleton, wobei diese leider nur Clusternode-eindeutig sind, bzw. JVM-eindeutig. Bißchen doof, wenn man fast nur mit Clustern arbeitet. Muss man halt schauen wie man die synchronisiert.
Weiterhin wurden cronjobs neu entdeckt. Nennt sich in EJB 3.1 dann Timer und lässt sich (fast) beliebig steuern. Find ich halt faszinierend wie man alten Wein einfach in neue Schläuche packt und das dann als „Feature“ verpackt. Wow. Timer 🙂

42 für Softwarearchitekten – Dr. Gernot Starke
Da verweis ich grad einfach mal auf http://arc42.de/. Im Prinzip ein sehr interessanter Vortrag über Projektdokumentation (also nicht nur das Benutzerhandbuch, sondern alles inkl. Requirements und Technische Konzepte). Da gibt’s ein Template zum Runterladen, das gerade mal 30 Seiten (oder so) hat, das einem eine Struktur vorgibt wie man ein Projekt beschreiben kann. In der Theorie eine super Sache, allerdings glaube ich nicht, das man irgendeinen Vorgesetzten davon überzeugen kann, dass man erstmal eine Woche lang ein Template ausfüllt um dann (weil agil und so), nochmals pro Woche einen Tag zu verbraten um das auf den neusten Stand zu bringen. Chefs wollen schnell was und das so billig wie möglich.

The Future of Enterprise Java – Adam Bien
Lange Keynote. Muss ich mir nochmal genau Gedanken machen was da alles gesagt wurde. Im Prinzip nix Überwältigendes, meist nette trends.google.com-Graphiken, gepaart mit ein paar Fakten „aus der Wirtschaft“. Klingt jetzt viel abfälliger als es war. An eine Sache erinnere ich mich noch: Single Vendor wird wohl (leider) kommen. Also, Cloud und so: Application Server, JPA-Implementation und/oder andere Libraries von einem Hersteller. Ich nenne hier einfach mal Red Hat aka Jboss.

Hibernate Search: Full-text search for Hibernate Applications – Emmanuel Bernard
Ein Hibernate Interface für Lucene. ’nough said. 🙂
Ne, ernsthaft: Eigentlich eine sehr abgefahrene Sache, weil es die Lucene-Machine einfach komplett wegkapselt. Man kann das quasi als normale DataSource sehen, die dann per EntityManager angesprochen wird und auch Query und ResultLists nutzt. Faszinierend. Ausserdem wird dann auch bei einem Datenbankupdate automatisch die Änderung in den Lucene-Index propagiert.

JCR: Java Content Repositories – Carsten Ziegeler
Da der Marc da bissle seine DA drüber geschrieben hat (oder so ähnlich), hab ich mir das auch mal angeguggt. Ist jetzt keine besondere Präsentation gewesen, eigentlich nur eine Beschreibung WAS ein Content Repository ist und das JCR 2.0 relativ frisch raus ist. Schaunmermal.

CouchDB, die REST-basierte Datenbankalternative fürs WEB 2.0 – Frank Pientka
Was ein komisches Ding. Eine JSON-Datenbank. Man erstellt einfach ein JSON-Dokument und packt das dann in die CouchDB. Nutzt das Map&Reduce das irgendwie wohl Google entwickelt hat. Das ist jetzt grobes Halbwissen, müsste man mal genauer recherchieren. Ich finds aber irgendwie komisch, weil das „eigentlich“ nur eine JSON-Datenbank ist, mit REST-Interface. Ein GET ist also ein SELECT, ein POST ist ein INSERT usw. Ohne Sicherheitsmechanismus, Login oder sonstirgendwas. Wer die URL kennt, darf alles machen. Doofes Konzept irgendwie.

NACHTRAG: Es gibt wohl doch ein Sicherheitsmodell. Es gibt Admin-Accounts, einen Lese- und einen Schreibzugriff. Allerdings wurde davon, soweit ich mich erinnere, nichts im Vortrag erwähnt. Nur das man halt einen HTTP-Proxy davor schalten sollte, um Sicherheitsfeatures reinzubringen. Quelle: http://couchdb.apache.org/docs/overview.html

Was schafft man in 60 Minuten – Live „on stage“ hacking for Java EE 6 – Adam Bien
Geile Sache. In 60 Minuten einfach mal EJB 3.1, JPA 2.0, JSF 2.0, JMS einen Junit-Test mit EJBContainer-Mockup und ein JSF-Redirect. Und das ganze dann noch per REST und Webservice erreichbar. Damit gewinnt dieser Beitrag das Bullshit-Bingo des Tages 🙂

Das wars dann erstmal für heute, ich geh mal mein Bier auffüllen 🙂

Kategorien
Arbeit Java

Fatjar-Plugin für Eclipse

Nun, ich hab das Plugin in meinem Eclipse gefunden und benutzt. Funktioniert prima. Gibt sogar nen Export, damit man das über einen Ant-Task aufrufen kann. Sieht dann ungefähr so aus:

<?xml version="1.0"?>
<project name="FatJar MySuperDuperClass.jar (experimental)" default="main" basedir=".">
    <!-- this file was created by Fat-Jar Eclipse Plug-in -->
    <!-- the ANT-Export is in a very early stage, so this -->
    <!-- is only experimental, ANT 1.6 or above is        -->
    <!-- required, feedback is always welcome:            -->
    <!--       http://sourceforge.net/projects/fjep       -->
    <!-- uncomment the following lines if using ANT outside Eclipse -->
    <!--
        <property name="fjepPath" value="plugins/net.sf.fjep.fatjar_0.0.31/fatjar.jar"/>
        <taskdef name="fatjar.build" classname="net.sf.fjep.anttask.FJBuildTask" classpath="${fjepPath}"/>
        <typedef name="fatjar.manifest" classname="net.sf.fjep.anttask.FJManifestType" classpath="${fjepPath}"/>
        <typedef name="fatjar.exclude" classname="net.sf.fjep.anttask.FJExcludeType" classpath="${fjepPath}"/>
        <typedef name="fatjar.jarsource" classname="net.sf.fjep.anttask.FJJarSourceType" classpath="${fjepPath}"/>
        <typedef name="fatjar.filesource" classname="net.sf.fjep.anttask.FJFileSourceType" classpath="${fjepPath}"/>
    -->
    <!-- uncomment the above lines to use ANT outside of Eclipse -->
    <target name="main">
      <fatjar.build output="MySuperDuperClass.jar">
        <fatjar.manifest mainclass="de.schwobeseggl.test.MySuperDuperClass"/>
        <fatjar.filesource path="bin" relpath=""/>
        <fatjar.jarsource file="lib/commons-cli.jar" relpath=""/>
        <fatjar.jarsource file="lib/jbossall-client.jar" relpath=""/>
        <fatjar.jarsource file="lib/junit.jar" relpath=""/>
        <fatjar.jarsource file="lib/log4j.jar" relpath=""/>
        <fatjar.jarsource file="lib/jdom.jar" relpath=""/>
       </fatjar.build>
    </target>
</project>

Schön und gut, das geht aber nur innerhalb von Eclipse. Auch wenn man obigen Hinweis folgt und die Zeilen einkommentiert, klappt es nicht, es kommt die Fehlermeldung:

BUILD FAILED
/my/path/MySuperDuperClass/build.xml:42: fatjar.build doesn't support the nested "fatjar.filesource" element.

Doof. Die Lösung ist relativ einfach, aber erst nach langer Suche hab ich sie gefunden: Einfach ein loaderref=“${fjepPath}“ in jedes typedef rein. Somit wird aus:

<typedef name="fatjar.manifest" classname="net.sf.fjep.anttask.FJManifestType" classpath="${fjepPath}"/>

ein

<typedef name="fatjar.manifest" classname="net.sf.fjep.anttask.FJManifestType" classpath="${fjepPath}" loaderref="${fjepPath}" />
Kategorien
Arbeit Java

Statische Maps

Wieder was gelernt. Arrays kann man ja wie folgt initialisieren:

String[] allowed = new String[] {"text/html", "text/json"};

Aber was ist mit Maps?

public class Router {
  public static final Map<String, Handler> routes;
 
  static {
    Map<String, Handler> map = new HashMap<String, Handler>();
    map.put("/account", new AccountHandler());
    map.put("/feed", new FeedHandler());
    map.put("/opml", new OpmlHandler());
    routes = Collections.unmodifiableMap(map);
  }
}

Find ich gut. Endlich weiß ich sowas auch. Noch schneller gehts mit:

public static final Map<String , Handler> routes = 
           new HashMap<String , Handler>() {{
    put("/account", new AccountHandler());
    put("/feed", new FeedHandler());
    put("/opml", new OpmlHandler());
}};