With JBPM 3 it worked as shown in the example below. But this way does not work any more with JBPM 4.

What am I doing wrong?

package org.jbpm.tutorial.db;

import java.util.List;

import junit.framework.TestCase;

import org.jbpm.db.GraphSession;
import org.jbpm.db.JbpmSession;
import org.jbpm.db.JbpmSessionFactory;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;

public class HelloWorldDbTest extends TestCase {

  // We need one JbpmSessionFactory per application.  So we put it in
  // a static variable. The JbpmSessionFactory will be used in the
  // test methods to create JbpmSession's.
  static JbpmSessionFactory jbpmSessionFactory =
      JbpmSessionFactory.buildJbpmSessionFactory();
 
  static {
    // Since the hypersonic in-memory database is a new, fresh database,
    // we need to create the schema at runtime before we start the tests.
    // The next line creates the database tables and foreign key
    // constraints.
    jbpmSessionFactory.getJbpmSchema().createSchema();
  }

  public void testSimplePersistence() {
    // Between the 3 method calls below, all data is passed via the
    // database.  Here, in this unit test, these 3 methods are executed
    // right after each other because we want to test a complete process
    // scenario.  But in reality, these methods represent different
    // requests to a server.
   
    // Since we start with a clean, empty in-memory database, we have to
    // deploy the process first.  In reality, this is done once by the
    // process developer.
    deployProcessDefinition();

    // Suppose we want to start a process instance (=process execution)
    // when a user submits a form in a web application...
    processInstanceIsCreatedWhenUserSubmitsWebappForm();

    // Then, the arrival of an asynchronous message will continue
    // execution.
    theProcessInstanceContinuesWhenAnAsyncMessageIsReceived();
  }

  public void deployProcessDefinition() {
    // This test shows a process definition and one execution
    // of the process definition.  The process definition has
    // 3 nodes: an unnamed start-state, a state 's' and an
    // end-state named 'end'.
    ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
      "<process-definition name='hello world'>" +
      "  <start-state name='start'>" +
      "    <transition to='s' />" +
      "  </start-state>" +
      "  <state name='s'>" +
      "    <transition to='end' />" +
      "  </state>" +
      "  <end-state name='end' />" +
      "</process-definition>"
    );
   
    // Let's open a new persistence session
    JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
    // ... and begin a transaction on the persistence session
    jbpmSession.beginTransaction();
   
    // Save the process definition in the database
    jbpmSession
        .getGraphSession()
        .saveProcessDefinition(processDefinition);
   
    // Commit the transaction
    jbpmSession.commitTransaction();
    // And close the jbpmSession.
    jbpmSession.close();
  }

  public void processInstanceIsCreatedWhenUserSubmitsWebappForm() {
    // The code in this method could be inside a struts-action
    // or a JSF managed bean.
   
    // Let's open a new persistence session
    JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
    // ... and begin a transaction on the persistence session.
    jbpmSession.beginTransaction();
   
    // Now we can query the database for the process definition that we
    // deployed above.
    ProcessDefinition processDefinition =
        jbpmSession
          .getGraphSession()
          .findLatestProcessDefinition("hello world");
   
    // With the processDefinition that we retrieved from the database, we
    // can create an execution of the process definition just like in the
    // hello world example (which was without persistence).
    ProcessInstance processInstance =
        new ProcessInstance(processDefinition);
   
    Token token = processInstance.getRootToken();
    assertEquals("start", token.getNode().getName());
    // Let's start the process execution
    token.signal();
    // Now the process is in the state 's'.
    assertEquals("s", token.getNode().getName());
   
    // Now the processInstance is saved in the database.  So the
    // current state of the execution of the process is stored in the
    // database. 
    jbpmSession
        .getGraphSession()
        .saveProcessInstance(processInstance);
    // The method below will get the process instance back out
    // of the database and resume execution by providing another
    // external signal.

    // At the end of the webapp action, the transaction is committed.
    jbpmSession.commitTransaction();
    // And close the jbpmSession.
    jbpmSession.close();
  }

  public void theProcessInstanceContinuesWhenAnAsyncMessageIsReceived() {
    // The code in this method could be the content of a message driven bean.
   
    // Let's open a new persistence session.
    JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
    // ... and begin a transaction on the persistence session
    // note that it's also possible to use a jdbc connection from a
    // DataSource in your application server.
    jbpmSession.beginTransaction();
    GraphSession graphSession = jbpmSession.getGraphSession();

    // First, we need to get the process instance back out of the database.
    // There are several options to know what process instance we are dealing
    // with here.  The easiest in this simple test case is just to look for
    // the full list of process instances.  That should give us only one
    // result.  So let's look up the process definition.
    ProcessDefinition processDefinition =
        graphSession.findLatestProcessDefinition("hello world");

    // Now, we search for all process instances of this process definition.
    List processInstances =
        graphSession.findProcessInstances(processDefinition.getId());
   
    // Because we know that in the context of this unit test, there is
    // only one execution.  In real life, the processInstanceId can be
    // extracted from the content of the message that arrived or from
    // the user making a choice.
    ProcessInstance processInstance =
        (ProcessInstance) processInstances.get(0);
   
    // Now we can continue the execution.  Note that the processInstance
    // delegates signals to the main path of execution (=the root token).
    processInstance.signal();
   
    // After this signal, we know the process execution should have
    // arrived in the end-state.
    assertTrue(processInstance.hasEnded());
   
    // Now we can update the state of the execution in the database
    graphSession.saveProcessInstance(processInstance);

    // At the end of the MDB, the transaction is committed.
    jbpmSession.commitTransaction();
    // And the jbpmSession is closed.
    jbpmSession.close();
  }
}

In the meantime I found the cause of the problem:

I had to comment out the following line of file jbpm.hibernate.xfg.xml:

<!-- property name="hibernate.hbm2ddl.auto">create-drop</property-->