Attachment #200051 for bug #352696




import org.eclipse.emf.cdo.dawn.tests.ui.gmf.DawnBasicGMFUITest;
import org.eclipse.emf.cdo.dawn.tests.ui.gmf.DawnCreationWizardTest;
import org.eclipse.emf.cdo.tests.AllTests;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;

  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, MEM, TCP, NATIVE);
    testClasses.add(DawnBasicGMFUITest.class);
    testClasses.add(DawnBasicEMFUITest.class);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    testClasses.add(DawnCreationWizardTest.class);
    testClasses.add(DawnBasicGMFUITest.class);
    testClasses.add(DawnBasicEMFUITest.class);
  }
}





import org.eclipse.emf.cdo.tests.AllConfigs;
import org.eclipse.emf.cdo.tests.InitialTest;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;

  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, MEM_BRANCHES, TCP, NATIVE);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    testClasses.add(InitialTest.class);
  }
}




import org.eclipse.emf.cdo.dawn.tests.ui.gmf.MultipleResourcesTest;
import org.eclipse.emf.cdo.dawn.tests.ui.gmf.SimpleDiagramTest;
import org.eclipse.emf.cdo.tests.AllTests;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;


  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {

    /******************** GMF **********************/
    testClasses.add(DawnPreferencesTest.class);
    testClasses.add(DawnCreationWizardSWTBotTest.class);




import org.eclipse.emf.cdo.dawn.tests.common.GMFTest;
import org.eclipse.emf.cdo.dawn.tests.common.TestFrameworkTest;
import org.eclipse.emf.cdo.tests.AllTests;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;

  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, MEM, JVM, NATIVE);
    testClasses.add(GMFTest.class);
    testClasses.add(DawnWrapperResourceTest.class);
    testClasses.add(DawnCodeGenGMFFragmentTest.class);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    testClasses.add(TestFrameworkTest.class);
    testClasses.add(GMFTest.class);
    testClasses.add(DawnWrapperResourceTest.class);
    testClasses.add(DawnCodeGenGMFFragmentTest.class);
  }
}




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
import org.eclipse.emf.cdo.tests.db.verifier.DBStoreVerifier;
import org.eclipse.emf.cdo.tests.db.verifier.DBStoreVerifier.NonAudit;

import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new HsqldbConfig(false, false, IDGenerationLocation.STORE), TCP, NATIVE);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    super.initTestClasses(testClasses, scenario);

    // this takes ages - so for now, we disable it
    testClasses.remove(Bugzilla_261218_Test.class);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return false;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return false;
  }

  public static class HsqldbNonAudit extends AllTestsDBHsqldb.Hsqldb
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsDBHsqldbNonAudit.HsqldbNonAudit INSTANCE = new HsqldbNonAudit(
        "DBStore: Hsqldb (non audit)");

    public HsqldbNonAudit(String name)
    {
      super(name);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "false");
    }

    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      return CDODBUtil.createHorizontalMappingStrategy(false);
    }

    @Override
    protected DBStoreVerifier getVerifier(IRepository repository)
    {
      return new NonAudit(repository);
    }
  }
}




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;

/**
 * @author Eike Stepper
 */
public abstract class DBConfig extends RepositoryConfig
{
  private static final long serialVersionUID = 1L;

  private boolean withRanges;

  private boolean copyOnBranch;

  public DBConfig(String name, boolean supportingAudits, boolean supportingBranches, boolean withRanges,
      boolean copyOnBranch, IDGenerationLocation idGenerationLocation)
  {
    super(name, supportingAudits, supportingBranches, idGenerationLocation);
    this.withRanges = withRanges;
    this.copyOnBranch = copyOnBranch;
  }

  public boolean isWithRanges()
  {
    return withRanges;
  }

  public boolean isCopyOnBranch()
  {
    return copyOnBranch;
  }

  @Override

  {
    Map<String, String> props = new HashMap<String, String>();
    props.put(IMappingStrategy.PROP_QUALIFIED_NAMES, "true");
    props.put(CDODBUtil.PROP_COPY_ON_BRANCH, Boolean.toString(copyOnBranch));
    return props;
  }

  protected IMappingStrategy createMappingStrategy()
  {
    return CDODBUtil.createHorizontalMappingStrategy(isSupportingAudits(), isSupportingBranches(), withRanges);
  }

  @Override
  protected String getMappingStrategySpecialization()
  {
    return (withRanges ? "-ranges" : "") + (copyOnBranch ? "-copy" : "");
  }

  protected abstract IDBAdapter createDBAdapter();





 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.h2.H2Adapter;
import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.h2.jdbcx.JdbcDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new H2Config(false, false, false, false, IDGenerationLocation.STORE), JVM, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return false;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return false;
  }

  /**
   * @author Eike Stepper
   */
  public static class H2NonAudit extends DBStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsDBH2NonAudit.H2NonAudit INSTANCE = new H2NonAudit("DBStore: H2 (non-audit)");

    protected transient File dbFolder;

    public H2NonAudit(String name)
    {
      super(name);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "false");
    }

    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      return CDODBUtil.createHorizontalMappingStrategy(false);
    }

    @Override
    protected IDBAdapter createDBAdapter()
    {
      return new H2Adapter();
    }

    @Override
    protected DataSource createDataSource(String repoName)
    {
      if (dbFolder == null)
      {
        dbFolder = createDBFolder();
        tearDownClean();
      }

      JdbcDataSource dataSource = new JdbcDataSource();
      dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
      return dataSource;
    }

    protected void tearDownClean()
    {
      IOUtil.delete(dbFolder);
    }

    protected File createDBFolder()
    {
      return TMPUtil.createTempFolder("h2_", "_test");
    }

    /**
     * @author Eike Stepper
     */
    public static class ReusableFolder extends H2NonAudit
    {
      private static final long serialVersionUID = 1L;

      public static final ReusableFolder INSTANCE = new ReusableFolder("DBStore: H2 (non-audit)");

      private static File reusableFolder;

      private static JdbcDataSource defaultDataSource;

      private transient ArrayList<String> repoNames = new ArrayList<String>();

      public ReusableFolder(String name)
      {
        super(name);
      }

      @Override
      protected DataSource createDataSource(String repoName)
      {
        if (reusableFolder == null)
        {
          reusableFolder = createDBFolder();
          IOUtil.delete(reusableFolder);
        }

        dbFolder = reusableFolder;
        if (defaultDataSource == null)
        {
          defaultDataSource = new JdbcDataSource();
          defaultDataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test");
        }

        Connection conn = null;
        Statement stmt = null;

        try
        {
          conn = defaultDataSource.getConnection();
          stmt = conn.createStatement();

          if (!isRestarting())
          {
            stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
          }

          stmt.execute("CREATE SCHEMA IF NOT EXISTS " + repoName);
        }
        catch (Exception e)
        {
          e.printStackTrace();
        }
        finally
        {
          DBUtil.close(conn);
          DBUtil.close(stmt);
        }

        JdbcDataSource dataSource = new JdbcDataSource();
        dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
        return dataSource;
      }

      @Override
      protected void tearDownClean()
      {
        for (String repoName : repoNames)
        {
          tearDownClean(repoName);
        }
      }

      protected void tearDownClean(String repoName)
      {
        reusableFolder.deleteOnExit();
        Connection connection = null;
        Statement stmt = null;

        try
        {
          connection = defaultDataSource.getConnection();
          stmt = connection.createStatement();
          stmt.execute("DROP SCHEMA " + repoName);
        }
        catch (Exception ex)
        {
          throw WrappedException.wrap(ex);
        }
        finally
        {
          DBUtil.close(stmt);
          DBUtil.close(connection);
        }
      }
    }
  }
}




  public void testByteArray() throws Exception
  {
    // XXX disabled because of Bug 289445
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
    super.testByteArray();
  }


  public void testByteArrayEmpty() throws Exception
  {
    // XXX disabled because of Bug 289445
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
    super.testByteArrayEmpty();
  }


  public void testByteArrayNull() throws Exception
  {
    // XXX disabled because of Bug 289445
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
    super.testByteArrayNull();
  }
}




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.h2.H2Adapter;
import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.h2.jdbcx.JdbcDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new H2Config(true, true, false, false, IDGenerationLocation.STORE), JVM, NATIVE);
    addScenario(parent, COMBINED, new H2Config(true, true, true, false, IDGenerationLocation.STORE), JVM, NATIVE);
    addScenario(parent, COMBINED, new H2Config(true, true, true, true, IDGenerationLocation.STORE), JVM, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return true;
  }

  /**
   * @author Eike Stepper
   */
  public static class H2Branching extends DBStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final H2Branching INSTANCE = new H2Branching("DBStore: H2 (branching)",
        "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalBranchingMappingStrategy");

    protected transient File dbFolder;

    private String mappingStrategy;

    public H2Branching(String name, String mappingStrategy)
    {
      super(name);
      this.mappingStrategy = mappingStrategy;
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "true");
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "true");
    }

    @SuppressWarnings("unchecked")
    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      try
      {
        Class<IMappingStrategy> clazz = (Class<IMappingStrategy>)Class.forName(mappingStrategy);
        return clazz.newInstance();
      }
      catch (Exception ex)
      {
        throw WrappedException.wrap(ex);
      }
    }

    @Override
    protected IDBAdapter createDBAdapter()
    {
      return new H2Adapter();
    }

    @Override
    protected DataSource createDataSource(String repoName)
    {
      if (dbFolder == null)
      {
        dbFolder = createDBFolder();
        tearDownClean();
      }

      JdbcDataSource dataSource = new JdbcDataSource();
      dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);

      return dataSource;
    }

    protected void tearDownClean()
    {
      IOUtil.delete(dbFolder);
    }

    protected File createDBFolder()
    {
      return TMPUtil.createTempFolder("h2_", "_test");
    }

    /**
     * @author Eike Stepper
     */
    public static class ReusableFolder extends H2Branching
    {
      private static final long serialVersionUID = 1L;

      public static final ReusableFolder INSTANCE = new ReusableFolder("DBStore: H2 (branching)",
          "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalBranchingMappingStrategy");

      public static final ReusableFolder RANGE_INSTANCE = new ReusableFolder("DBStore: H2 (branching, range-based)",
          "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalBranchingMappingStrategyWithRanges");

      private static File reusableFolder;

      private static JdbcDataSource defaultDataSource;

      private transient ArrayList<String> repoNames = new ArrayList<String>();

      public ReusableFolder(String name, String mappingStrategy)
      {
        super(name, mappingStrategy);
      }

      @Override
      protected DataSource createDataSource(String repoName)
      {
        if (reusableFolder == null)
        {
          reusableFolder = createDBFolder();
          IOUtil.delete(reusableFolder);
        }

        dbFolder = reusableFolder;
        if (defaultDataSource == null)
        {
          defaultDataSource = new JdbcDataSource();
          defaultDataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test");
        }

        Connection conn = null;
        Statement stmt = null;

        try
        {
          conn = defaultDataSource.getConnection();
          stmt = conn.createStatement();

          if (!isRestarting())
          {
            stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
          }

          stmt.execute("CREATE SCHEMA IF NOT EXISTS " + repoName);

          /*
           * final WebServer webServer = new WebServer(); webServer.init(new String[] { "-webPort", "7778" });
           * webServer.start(); System.out.println("----------------------------------");
           * System.out.println("----------------------------------"); System.out.println(webServer.addSession(conn));
           * System.out.println("----------------------------------");
           * System.out.println("----------------------------------"); new Thread() {
           * @Override public void run() { webServer.listen(); } }.start();
           */
        }
        catch (Exception ex)
        {
          ex.printStackTrace();
        }
        finally
        {
          DBUtil.close(stmt);
          DBUtil.close(conn);
        }

        JdbcDataSource dataSource = new JdbcDataSource();
        dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
        return dataSource;
      }

      @Override
      protected void tearDownClean()
      {
        for (String repoName : repoNames)
        {
          tearDownClean(repoName);
        }
      }

      protected void tearDownClean(String repoName)
      {
        reusableFolder.deleteOnExit();
        Connection connection = null;
        Statement stmt = null;

        try
        {
          connection = defaultDataSource.getConnection();
          stmt = connection.createStatement();
          stmt.execute("DROP SCHEMA " + repoName);
        }
        catch (Exception ex)
        {
          throw WrappedException.wrap(ex);
        }
        finally
        {
          DBUtil.close(stmt);
          DBUtil.close(connection);
        }
      }

      public static class CopyOnBranch extends ReusableFolder
      {
        private static final long serialVersionUID = 1L;

        public static final ReusableFolder INSTANCE = new CopyOnBranch(
            "DBStore: H2 (branching, range-based, copyOnBranch)",
            "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalBranchingMappingStrategyWithRanges");

        public CopyOnBranch(String name, String ms)
        {
          super(name, ms);
        }

        @Override
        protected IMappingStrategy createMappingStrategy()
        {
          IMappingStrategy ms = super.createMappingStrategy();

          Map<String, String> properties = new HashMap<String, String>();
          properties.put("copyOnBranch", "true");
          ms.setProperties(properties);

          return ms;
        }
      }
    }
  }
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.IRepository.Props;
import org.eclipse.emf.cdo.tests.db.bundle.OM;
import org.eclipse.emf.cdo.tests.db.verifier.DBStoreVerifier;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.hsqldb.HSQLDBAdapter;
import org.eclipse.net4j.db.hsqldb.HSQLDBDataSource;

import org.eclipse.emf.common.util.WrappedException;

import javax.sql.DataSource;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Map;

/**
 * @author Eike Stepper
 */
public class HsqldbConfig extends DBConfig
{
  private static final long serialVersionUID = 1L;

  public static boolean USE_VERIFIER = false;

  private transient ArrayList<HSQLDBDataSource> dataSources;

  public HsqldbConfig(boolean supportingAudits, boolean supportingBranches, IDGenerationLocation idGenerationLocation)
  {
    super("Hsqldb", supportingAudits, supportingBranches, false, false, idGenerationLocation);
  }

  @Override
  protected IDBAdapter createDBAdapter()
  {
    return new HSQLDBAdapter();
  }

  @Override
  protected DataSource createDataSource(String repoName)
  {
    HSQLDBDataSource dataSource = new HSQLDBDataSource();
    dataSource.setDatabase("jdbc:hsqldb:mem:" + repoName);
    dataSource.setUser("sa");

    try
    {
      dataSource.setLogWriter(new PrintWriter(System.err));
    }
    catch (SQLException ex)
    {
      OM.LOG.warn(ex.getMessage());
    }

    if (dataSources == null)
    {
      dataSources = new ArrayList<HSQLDBDataSource>();
    }

    dataSources.add(dataSource);
    return dataSource;
  }

  @Override
  public void tearDown() throws Exception
  {
    try
    {
      if (USE_VERIFIER)
      {
        IRepository testRepository = getRepository(REPOSITORY_NAME);
        if (testRepository != null)
        {
          getVerifier(testRepository).verify();
        }
      }
    }
    finally
    {
      super.tearDown();
    }
  }

  @Override
  protected void deactivateRepositories()
  {
    try
    {
      shutDownHsqldb();
    }
    catch (SQLException e)
    {
      throw new WrappedException(e);
    }
    finally
    {
      super.deactivateRepositories();
    }
  }

  protected DBStoreVerifier getVerifier(IRepository repository)
  {
    return new DBStoreVerifier.Audit(repository);
  }

  private void shutDownHsqldb() throws SQLException
  {
    for (HSQLDBDataSource ds : dataSources)
    {
      Connection connection = null;
      Statement statement = null;

      try
      {
        connection = ds.getConnection();
        statement = connection.createStatement();
        statement.execute("SHUTDOWN");
      }
      finally
      {
        DBUtil.close(statement);
        DBUtil.close(connection);
      }
    }

    dataSources.clear();
  }

  @Override
  protected void initRepositoryProperties(Map<String, String> props)
  {
    super.initRepositoryProperties(props);
    props.put(Props.SUPPORTING_AUDITS, "true");
  }
}

Lines 21-27 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DISABLE_ExternalReferenceTest.java (-2 / +2 lines)
21	public void testOneXMIResourceManyViewsOnOneResourceSet() throws Exception	21	public void testOneXMIResourceManyViewsOnOneResourceSet() throws Exception
22	{	22	{
23	// XXX disabled because of Bug 290097	23	// XXX disabled because of Bug 290097
24	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	24	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
25	super.testOneXMIResourceManyViewsOnOneResourceSet();	25	super.testOneXMIResourceManyViewsOnOneResourceSet();
26	}	26	}
27		27
Lines 29-35 Link Here
29	public void testManyViewsOnOneResourceSet() throws Exception	29	public void testManyViewsOnOneResourceSet() throws Exception
30	{	30	{
31	// XXX disabled because of Bug 290097	31	// XXX disabled because of Bug 290097
32	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	32	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
33	super.testManyViewsOnOneResourceSet();	33	super.testManyViewsOnOneResourceSet();
34	}	34	}
35	}	35	}




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.IRepository.Props;
import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_266982_Test;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
import org.eclipse.emf.cdo.tests.db.bundle.OM;
import org.eclipse.emf.cdo.tests.db.verifier.DBStoreVerifier;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.hsqldb.HSQLDBAdapter;
import org.eclipse.net4j.db.hsqldb.HSQLDBDataSource;

import org.eclipse.emf.common.util.WrappedException;

import javax.sql.DataSource;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new HsqldbConfig(true, false, IDGenerationLocation.STORE), JVM, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    super.initTestClasses(testClasses, scenario);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)
  {
    super.initTestClasses(testClasses);

    // this takes ages ...
    testClasses.remove(Bugzilla_266982_Test.class);
  }

  /**
   * @author Eike Stepper
   */
  public static class Hsqldb extends DBStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsDBHsqldb.Hsqldb INSTANCE = new Hsqldb("HSQLDB");

    public static boolean USE_VERIFIER = false;

    private transient ArrayList<HSQLDBDataSource> dataSources;

    public Hsqldb(String name)
    {
      super(name);
    }

    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      return CDODBUtil.createHorizontalMappingStrategy(true);
    }

    @Override
    protected IDBAdapter createDBAdapter()
    {
      return new HSQLDBAdapter();
    }

    @Override
    protected DataSource createDataSource(String repoName)
    {
      HSQLDBDataSource dataSource = new HSQLDBDataSource();
      dataSource.setDatabase("jdbc:hsqldb:mem:" + repoName);
      dataSource.setUser("sa");

      try
      {
        dataSource.setLogWriter(new PrintWriter(System.err));
      }
      catch (SQLException ex)
      {
        OM.LOG.warn(ex.getMessage());
      }

      if (dataSources == null)
      {
        dataSources = new ArrayList<HSQLDBDataSource>();
      }
      dataSources.add(dataSource);
      return dataSource;
    }

    @Override
    public void tearDown() throws Exception
    {
      try
      {
        if (USE_VERIFIER)
        {
          IRepository testRepository = getRepository(REPOSITORY_NAME);
          if (testRepository != null)
          {
            getVerifier(testRepository).verify();
          }
        }
      }
      finally
      {
        super.tearDown();
      }
    }

    @Override
    protected void deactivateRepositories()
    {
      try
      {
        shutDownHsqldb();
      }
      catch (SQLException e)
      {
        throw new WrappedException(e);
      }
      finally
      {
        super.deactivateRepositories();
      }
    }

    protected DBStoreVerifier getVerifier(IRepository repository)
    {
      return new DBStoreVerifier.Audit(repository);
    }

    private void shutDownHsqldb() throws SQLException
    {
      for (HSQLDBDataSource ds : dataSources)
      {
        Connection connection = null;
        Statement statement = null;

        try
        {
          connection = ds.getConnection();
          statement = connection.createStatement();
          statement.execute("SHUTDOWN");
        }
        finally
        {
          DBUtil.close(statement);
          DBUtil.close(connection);
        }
      }

      dataSources.clear();
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(Props.SUPPORTING_AUDITS, "true");
    }
  }
}

Lines 21-27 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DISABLE_FeatureMapTest.java (-1 / +1 lines)
21	@Override	21	@Override
22	public void testFeatureMaps() throws Exception	22	public void testFeatureMaps() throws Exception
23	{	23	{
24	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	24	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
25	super.testFeatureMaps();	25	super.testFeatureMaps();
26	}	26	}
27	}	27	}




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig.OfflineConfig;
import org.eclipse.emf.cdo.tests.offline.Bugzilla_319552_Test;
import org.eclipse.emf.cdo.tests.offline.Bugzilla_325097_Test;
import org.eclipse.emf.cdo.tests.offline.Bugzilla_326047_Test;

import org.eclipse.emf.cdo.tests.offline.OfflineRawTest;
import org.eclipse.emf.cdo.tests.offline.OfflineTest;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.h2.H2Adapter;
import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.container.IPluginContainer;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.h2.jdbcx.JdbcDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return true;
  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new H2OfflineConfig(), JVM, NATIVE);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    // super.initTestClasses(testClasses);

    testClasses.add(OfflineTest.class);
    testClasses.add(OfflineRawTest.class);
    testClasses.add(OfflineDelayedTest.class);


    testClasses.add(FailoverTest.class);
  }

  /**
   * @author Eike Stepper
   */
  public static class H2Offline extends OfflineConfig
  {
    public static final H2Offline INSTANCE = new H2Offline("DBStore: H2 (offline)");

    private static final long serialVersionUID = 1L;

    protected transient File dbFolder;

    public H2Offline(String name)
    {
      super(name);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "true");
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "true");
    }

    public IStore createStore(String repoName)
    {
      IMappingStrategy mappingStrategy = createMappingStrategy();
      IDBAdapter dbAdapter = createDBAdapter();
      DataSource dataSource = createDataSource(repoName);
      return CDODBUtil.createStore(mappingStrategy, dbAdapter, DBUtil.createConnectionProvider(dataSource));
    }

    protected IMappingStrategy createMappingStrategy()
    {
      return CDODBUtil.createHorizontalMappingStrategy(true, true);
    }

    protected IDBAdapter createDBAdapter()
    {
      return new H2Adapter();
    }

    protected DataSource createDataSource(String repoName)
    {
      if (dbFolder == null)
      {
        dbFolder = createDBFolder();
        tearDownClean();
      }

      JdbcDataSource dataSource = new JdbcDataSource();
      dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
      return dataSource;
    }

    @Override
    public void setUp() throws Exception
    {
      CDODBUtil.prepareContainer(IPluginContainer.INSTANCE);
      super.setUp();
    }

    protected void tearDownClean()
    {
      IOUtil.delete(dbFolder);
    }

    protected File createDBFolder()
    {
      return TMPUtil.createTempFolder("h2_", "_test");
    }

    /**
     * @author Eike Stepper
     */
    public static class ReusableFolder extends H2Offline
    {
      private static final long serialVersionUID = 1L;

      public static final ReusableFolder INSTANCE = new ReusableFolder("DBStore: H2 (offline)");

      private static File reusableFolder;

      private static JdbcDataSource defaultDataSource;

      private transient ArrayList<String> repoNames = new ArrayList<String>();

      public ReusableFolder(String name)
      {
        super(name);
      }

      @Override
      protected DataSource createDataSource(String repoName)
      {
        if (reusableFolder == null)
        {
          reusableFolder = createDBFolder();
          IOUtil.delete(reusableFolder);
        }

        dbFolder = reusableFolder;
        if (defaultDataSource == null)
        {
          defaultDataSource = new JdbcDataSource();
          defaultDataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test");
        }

        Connection conn = null;
        Statement stmt = null;

        try
        {
          conn = defaultDataSource.getConnection();
          stmt = conn.createStatement();
          stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
          stmt.execute("CREATE SCHEMA " + repoName);
        }
        catch (Exception e)
        {
          e.printStackTrace();
        }
        finally
        {
          DBUtil.close(conn);
          DBUtil.close(stmt);
        }

        JdbcDataSource dataSource = new JdbcDataSource();
        dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
        return dataSource;
      }

      @Override
      protected void tearDownClean()
      {
        for (String repoName : repoNames)
        {
          tearDownClean(repoName);
        }
      }

      protected void tearDownClean(String repoName)
      {
        reusableFolder.deleteOnExit();
        Connection connection = null;
        Statement stmt = null;

        try
        {
          connection = defaultDataSource.getConnection();
          stmt = connection.createStatement();
          stmt.execute("DROP SCHEMA " + repoName);
        }
        catch (Exception ex)
        {
          throw WrappedException.wrap(ex);
        }
        finally
        {
          DBUtil.close(stmt);
          DBUtil.close(connection);
        }
      }
    }
  }
}

Lines 11-17 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DISABLE_XRefTest.java (-2 / +1 lines)
11	package org.eclipse.emf.cdo.tests.db;	11	package org.eclipse.emf.cdo.tests.db;
12		12
13	import org.eclipse.emf.cdo.tests.XRefTest;	13	import org.eclipse.emf.cdo.tests.XRefTest;
14	import org.eclipse.emf.cdo.tests.db.AllTestsDBH2.H2;
15		14
16	/**	15	/**
17	* @author Eike Stepper	16	* @author Eike Stepper
Lines 22-28 Link Here
22	protected void doSetUp() throws Exception	21	protected void doSetUp() throws Exception
23	{	22	{
24	super.doSetUp();	23	super.doSetUp();
25	skipConfig(H2.ReusableFolder.RANGE_INSTANCE);	24	// skipConfig(H2Config.RANGE_INSTANCE);
26	}	25	}
27		26
28	// @Override	27	// @Override

Lines 22-28 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/AutomatedTests.java (-1 / +1 lines)
22	{	22	{
23	TestSuite suite = new TestSuite(AutomatedTests.class.getName());	23	TestSuite suite = new TestSuite(AutomatedTests.class.getName());
24	suite.addTest(AllTestsDBH2NonAudit.suite());	24	suite.addTest(AllTestsDBH2NonAudit.suite());
25	suite.addTest(AllTestsDBH2.suite());	25	suite.addTest(AllTestsDBH2Audit.suite());
26	suite.addTest(AllTestsDBH2Branching.suite());	26	suite.addTest(AllTestsDBH2Branching.suite());
27	// suite.addTest(AllTestsDBH2Offline.suite());	27	// suite.addTest(AllTestsDBH2Offline.suite());
28	// suite.addTest(AllTestsDBHsqldb.suite());	28	// suite.addTest(AllTestsDBHsqldb.suite());




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.h2.H2Adapter;
import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.h2.jdbcx.JdbcDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * @author Eike Stepper
 */
public class AllTestsDBH2Audit extends DBConfigs
{
  public static Test suite()
  {
    return new AllTestsDBH2Audit().getTestSuite("CDO Tests (DBStore H2 Horizontal)");
  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new H2Config(true, false, false, false, IDGenerationLocation.STORE), JVM, NATIVE);
    addScenario(parent, COMBINED, new H2Config(true, false, true, false, IDGenerationLocation.STORE), JVM, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return false;
  }

  /**
   * @author Eike Stepper
   */
  public static class H2 extends DBStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsDBH2.H2 INSTANCE = new H2("DBStore: H2 (audit)",
        "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategy");

    protected transient File dbFolder;

    private String mappingStrategy;

    public H2(String name, String mappingStrategy)
    {
      super(name);
      this.mappingStrategy = mappingStrategy;
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "true");
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "false");
    }

    @SuppressWarnings("unchecked")
    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      try
      {
        Class<IMappingStrategy> clazz = (Class<IMappingStrategy>)Class.forName(mappingStrategy);
        return clazz.newInstance();
      }
      catch (Exception ex)
      {
        throw WrappedException.wrap(ex);
      }
    }

    @Override
    protected IDBAdapter createDBAdapter()
    {
      return new H2Adapter();
    }

    @Override
    protected DataSource createDataSource(String repoName)
    {
      if (dbFolder == null)
      {
        dbFolder = createDBFolder();
        tearDownClean();
      }

      JdbcDataSource dataSource = new JdbcDataSource();
      dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
      return dataSource;
    }

    protected void tearDownClean()
    {
      IOUtil.delete(dbFolder);
    }

    protected File createDBFolder()
    {
      return TMPUtil.createTempFolder("h2_", "_test");
    }

    /**
     * @author Eike Stepper
     */
    public static class ReusableFolder extends H2
    {
      private static final long serialVersionUID = 1L;

      public static final ReusableFolder AUDIT_INSTANCE = new ReusableFolder("DBStore: H2 (Reusable Folder, audit), ",
          "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategy");

      public static final ReusableFolder RANGE_INSTANCE = new ReusableFolder(
          "DBStore: H2 (Reusable Folder, audit, range-based mapping strategy)",
          "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategyWithRanges");

      private static File reusableFolder;

      private static JdbcDataSource defaultDataSource;

      private transient ArrayList<String> repoNames = new ArrayList<String>();

      public ReusableFolder(String name, String mappingStrategy)
      {
        super(name, mappingStrategy);
      }

      @Override
      protected DataSource createDataSource(String repoName)
      {
        if (reusableFolder == null)
        {
          reusableFolder = createDBFolder();
          IOUtil.delete(reusableFolder);
        }

        dbFolder = reusableFolder;
        if (defaultDataSource == null)
        {
          defaultDataSource = new JdbcDataSource();
          defaultDataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test");
        }

        Connection conn = null;
        Statement stmt = null;

        try
        {
          conn = defaultDataSource.getConnection();
          stmt = conn.createStatement();

          if (!isRestarting())
          {
            stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
          }

          stmt.execute("CREATE SCHEMA IF NOT EXISTS " + repoName);
        }
        catch (Exception e)
        {
          e.printStackTrace();
        }
        finally
        {
          DBUtil.close(conn);
          DBUtil.close(stmt);
        }

        JdbcDataSource dataSource = new JdbcDataSource();
        dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
        return dataSource;
      }

      @Override
      protected void tearDownClean()
      {
        for (String repoName : repoNames)
        {
          tearDownClean(repoName);
        }
      }

      protected void tearDownClean(String repoName)
      {
        reusableFolder.deleteOnExit();
        Connection connection = null;
        Statement stmt = null;

        try
        {
          connection = defaultDataSource.getConnection();
          stmt = connection.createStatement();
          stmt.execute("DROP SCHEMA " + repoName);
        }
        catch (Exception ex)
        {
          throw WrappedException.wrap(ex);
        }
        finally
        {
          DBUtil.close(stmt);
          DBUtil.close(connection);
        }
      }
    }
  }
}




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
import org.eclipse.emf.cdo.tests.db.bundle.OM;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.postgresql.PostgreSQLAdapter;
import org.eclipse.net4j.util.io.IOUtil;

import org.postgresql.jdbc3.Jdbc3SimpleDataSource;

import javax.sql.DataSource;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;

import junit.framework.Test;
import junit.framework.TestSuite;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new PostgresqlConfig(false, false, IDGenerationLocation.STORE), JVM, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return false;
  }

  /**
   * @author Victor Roldan Betancort
   */
  public static class Psql extends DBStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsDBPsql.Psql INSTANCE = new Psql("PostgreSQL");

    private transient Jdbc3SimpleDataSource dataSource;

    private transient Jdbc3SimpleDataSource setupDataSource;

    private String currentRepositoryName = "cdodb1";

    public Psql(String name)
    {
      super(name);
    }

    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      return CDODBUtil.createHorizontalMappingStrategy(false);
    }

    @Override
    protected IDBAdapter createDBAdapter()
    {
      return new PostgreSQLAdapter();
    }

    @Override
    protected DataSource createDataSource(String repoName)
    {
      currentRepositoryName = repoName;

      dataSource = new Jdbc3SimpleDataSource();
      dataSource.setServerName("localhost");
      dataSource.setDatabaseName(currentRepositoryName);
      dataSource.setUser("sa");
      dataSource.setPassword("sa");

      try
      {
        dataSource.setLogWriter(new PrintWriter(System.err));
      }
      catch (SQLException ex)
      {
        OM.LOG.warn(ex.getMessage());
      }

      dropDatabase();

      return dataSource;
    }

    @Override
    protected void deactivateRepositories()
    {
      super.deactivateRepositories();
      dataSource = null;
      setupDataSource = null;
      dropDatabase();
    }

    private void dropDatabase()
    {
      Connection connection = null;

      try
      {
        connection = getSetupDataSource().getConnection();
        DBUtil.dropAllTables(connection, currentRepositoryName);
      }
      catch (SQLException ignore)
      {
        IOUtil.ERR().println(ignore);
      }
      finally
      {
        DBUtil.close(connection);
      }
    }

    private DataSource getSetupDataSource()
    {
      if (setupDataSource == null)
      {
        setupDataSource = new Jdbc3SimpleDataSource();
        setupDataSource.setServerName("localhost");
        setupDataSource.setDatabaseName(currentRepositoryName);
        setupDataSource.setUser("sa");
        setupDataSource.setPassword("sa");
      }

      return setupDataSource;
    }
  }
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig.OfflineConfig;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.h2.H2Adapter;
import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.container.IPluginContainer;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.h2.jdbcx.JdbcDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.sql.Statement;

/**
 * @author Eike Stepper
 */
public class H2OfflineConfig extends OfflineConfig
{
  private static final long serialVersionUID = 1L;

  private static File reusableFolder;

  private static JdbcDataSource defaultDataSource;

  public H2OfflineConfig()
  {
    super("H2Offline");
  }

  public IStore createStore(String repoName)
  {
    IMappingStrategy mappingStrategy = createMappingStrategy();
    IDBAdapter dbAdapter = createDBAdapter();
    DataSource dataSource = createDataSource(repoName);
    return CDODBUtil.createStore(mappingStrategy, dbAdapter, DBUtil.createConnectionProvider(dataSource));
  }

  protected IMappingStrategy createMappingStrategy()
  {
    return CDODBUtil.createHorizontalMappingStrategy();
  }

  protected IDBAdapter createDBAdapter()
  {
    return new H2Adapter();
  }

  protected DataSource createDataSource(String repoName)
  {
    if (reusableFolder == null)
    {
      reusableFolder = createDBFolder();
      IOUtil.delete(reusableFolder);
    }

    if (defaultDataSource == null)
    {
      defaultDataSource = new JdbcDataSource();
      defaultDataSource.setURL("jdbc:h2:" + reusableFolder.getAbsolutePath() + "/h2test");
    }

    Connection conn = null;
    Statement stmt = null;

    try
    {
      conn = defaultDataSource.getConnection();
      stmt = conn.createStatement();
      stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
      stmt.execute("CREATE SCHEMA " + repoName);
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
    finally
    {
      DBUtil.close(conn);
      DBUtil.close(stmt);
    }

    JdbcDataSource dataSource = new JdbcDataSource();
    dataSource.setURL("jdbc:h2:" + reusableFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
    return dataSource;
  }

  @Override
  public void setUp() throws Exception
  {
    CDODBUtil.prepareContainer(IPluginContainer.INSTANCE);
    super.setUp();
  }

  protected File createDBFolder()
  {
    return TMPUtil.createTempFolder("h2_", "_test");
  }

  protected void tearDownClean(String repoName)
  {
    reusableFolder.deleteOnExit();
    Connection connection = null;
    Statement stmt = null;

    try
    {
      connection = defaultDataSource.getConnection();
      stmt = connection.createStatement();
      stmt.execute("DROP SCHEMA " + repoName);
    }
    catch (Exception ex)
    {
      throw WrappedException.wrap(ex);
    }
    finally
    {
      DBUtil.close(stmt);
      DBUtil.close(connection);
    }
  }
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.h2.H2Adapter;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.h2.jdbcx.JdbcDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.sql.Statement;

/**
 * @author Eike Stepper
 */
public class H2Config extends DBConfig
{
  private static final long serialVersionUID = 1L;

  private static File reusableFolder;

  private static JdbcDataSource defaultDataSource;

  protected transient File dbFolder;

  public H2Config(boolean supportingAudits, boolean supportingBranches, boolean withRanges, boolean copyOnBranch,
      IDGenerationLocation idGenerationLocation)
  {
    super("H2", supportingAudits, supportingBranches, withRanges, copyOnBranch, idGenerationLocation);
  }

  @Override
  protected IDBAdapter createDBAdapter()
  {
    return new H2Adapter();
  }

  @Override
  protected DataSource createDataSource(String repoName)
  {
    if (reusableFolder == null)
    {
      reusableFolder = createDBFolder();
      IOUtil.delete(reusableFolder);
    }

    dbFolder = reusableFolder;
    if (defaultDataSource == null)
    {
      defaultDataSource = new JdbcDataSource();
      defaultDataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test");
    }

    Connection conn = null;
    Statement stmt = null;

    try
    {
      conn = defaultDataSource.getConnection();
      stmt = conn.createStatement();

      if (!isRestarting())
      {
        stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
      }

      stmt.execute("CREATE SCHEMA IF NOT EXISTS " + repoName);
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    finally
    {
      DBUtil.close(conn);
      DBUtil.close(stmt);
    }

    JdbcDataSource dataSource = new JdbcDataSource();
    dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
    return dataSource;
  }

  protected File createDBFolder()
  {
    return TMPUtil.createTempFolder("h2_", "_test");
  }
}




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalBranchingMappingStrategyWithRanges;
import org.eclipse.emf.cdo.tests.BranchingSameSessionTest;
import org.eclipse.emf.cdo.tests.BranchingTest;
import org.eclipse.emf.cdo.tests.MergingTest;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.mysql.MYSQLAdapter;

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

import javax.sql.DataSource;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

 */
public class AllTestsDBMysql extends DBConfigs
{
  /**
   * Instructions to test with MySQL: - create a mysql instance - set HOST to the host where the DB is running
   * (listening on TCP) - set USER to a user who can create and drop databases (root, essentially) - set PASS to the
   * password of the said user
   */
  public static final String HOST = "localhost";

  public static final String USER = "root";

  public static final String PASS = "root";

  public static Test suite()
  {
    return new AllTestsDBMysql().getTestSuite("CDO Tests (DBStore MySql Horizontal)");

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new MysqlConfig(false, false, IDGenerationLocation.STORE), JVM, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    return true;
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)
  {
    // add branching tests for this testsuite
    testClasses.add(BranchingTest.class);
    testClasses.add(BranchingSameSessionTest.class);
    testClasses.add(MergingTest.class);

    super.initTestClasses(testClasses, scenario);
  }

  /**
   * @author Simon McDuff
   */
  public static class Mysql extends DBStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsDBMysql.Mysql INSTANCE = new Mysql("DBStore: Mysql");

    private transient DataSource setupDataSource;

    private transient List<String> databases = new ArrayList<String>();

    public Mysql(String name)
    {
      super(name);
    }

    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      return new HorizontalBranchingMappingStrategyWithRanges();
    }

    @Override
    protected IDBAdapter createDBAdapter()
    {
      return new MYSQLAdapter();
    }

    @Override
    protected DataSource createDataSource(String repoName)
    {
      MysqlDataSource ds = new MysqlDataSource();

      initDatabase("test_" + repoName);

      ds.setUrl("jdbc:mysql://" + HOST + "/test_" + repoName);
      ds.setUser(USER);
      if (PASS != null)
      {
        ds.setPassword(PASS);
      }

      return ds;
    }

    private void initDatabase(String dbName)
    {
      dropDatabase(dbName);
      Connection connection = null;
      Statement stmt = null;

      try
      {
        connection = getSetupDataSource().getConnection();
        stmt = connection.createStatement();
        stmt.execute("create database " + dbName);
      }
      catch (SQLException ignore)
      {
      }
      finally
      {
        DBUtil.close(stmt);
        DBUtil.close(connection);
      }
    }

    @Override
    protected void deactivateRepositories()
    {
      super.deactivateRepositories();
      for (String dbName : databases)
      {
        dropDatabase(dbName);
      }
    }

    private void dropDatabase(String dbName)
    {
      Connection connection = null;
      Statement stmt = null;

      try
      {
        connection = getSetupDataSource().getConnection();
        stmt = connection.createStatement();
        stmt.execute("DROP database " + dbName);
      }
      catch (SQLException ignore)
      {
      }
      finally
      {
        DBUtil.close(stmt);
        DBUtil.close(connection);
      }
    }

    private DataSource getSetupDataSource()
    {
      if (setupDataSource == null)
      {
        MysqlDataSource ds = new MysqlDataSource();
        ds.setUrl("jdbc:mysql://" + HOST);
        ds.setUser(USER);
        if (PASS != null)
        {
          ds.setPassword(PASS);
        }

        setupDataSource = ds;
      }

      return setupDataSource;
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(Props.SUPPORTING_AUDITS, "true");
      props.put(Props.SUPPORTING_BRANCHES, "true");
    }
  }
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.tests.db.bundle.OM;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.postgresql.PostgreSQLAdapter;
import org.eclipse.net4j.util.io.IOUtil;

import org.postgresql.jdbc3.Jdbc3SimpleDataSource;

import javax.sql.DataSource;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * @author Victor Roldan Betancort
 */
public class PostgresqlConfig extends DBConfig
{
  private static final long serialVersionUID = 1L;

  private transient Jdbc3SimpleDataSource dataSource;

  private transient Jdbc3SimpleDataSource setupDataSource;

  private String currentRepositoryName = "cdodb1";

  public PostgresqlConfig(boolean supportingAudits, boolean supportingBranches,
      IDGenerationLocation idGenerationLocation)
  {
    super("Postgresql", supportingAudits, supportingBranches, false, false, idGenerationLocation);
  }

  @Override
  protected IDBAdapter createDBAdapter()
  {
    return new PostgreSQLAdapter();
  }

  @Override
  protected DataSource createDataSource(String repoName)
  {
    currentRepositoryName = repoName;

    dataSource = new Jdbc3SimpleDataSource();
    dataSource.setServerName("localhost");
    dataSource.setDatabaseName(currentRepositoryName);
    dataSource.setUser("sa");
    dataSource.setPassword("sa");

    try
    {
      dataSource.setLogWriter(new PrintWriter(System.err));
    }
    catch (SQLException ex)
    {
      OM.LOG.warn(ex.getMessage());
    }

    dropDatabase();

    return dataSource;
  }

  @Override
  protected void deactivateRepositories()
  {
    super.deactivateRepositories();
    dataSource = null;
    setupDataSource = null;
    dropDatabase();
  }

  private void dropDatabase()
  {
    Connection connection = null;

    try
    {
      connection = getSetupDataSource().getConnection();
      DBUtil.dropAllTables(connection, currentRepositoryName);
    }
    catch (SQLException ignore)
    {
      IOUtil.ERR().println(ignore);
    }
    finally
    {
      DBUtil.close(connection);
    }
  }

  private DataSource getSetupDataSource()
  {
    if (setupDataSource == null)
    {
      setupDataSource = new Jdbc3SimpleDataSource();
      setupDataSource.setServerName("localhost");
      setupDataSource.setDatabaseName(currentRepositoryName);
      setupDataSource.setUser("sa");
      setupDataSource.setPassword("sa");
    }

    return setupDataSource;
  }
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 *    Stefan Winkler - introduced variable mapping strategies
 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.h2.H2Adapter;
import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.h2.jdbcx.JdbcDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * @author Eike Stepper
 */
public class AllTestsDBH2 extends DBConfigs
{
  public static Test suite()
  {
    return new AllTestsDBH2().getTestSuite("CDO Tests (DBStore H2 Horizontal)");
  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, AllTestsDBH2.H2.ReusableFolder.AUDIT_INSTANCE, JVM, NATIVE);
    addScenario(parent, COMBINED, AllTestsDBH2.H2.ReusableFolder.RANGE_INSTANCE, JVM, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return false;
  }

  /**
   * @author Eike Stepper
   */
  public static class H2 extends DBStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsDBH2.H2 INSTANCE = new H2("DBStore: H2 (audit)",
        "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategy");

    protected transient File dbFolder;

    private String mappingStrategy;

    public H2(String name, String mappingStrategy)
    {
      super(name);
      this.mappingStrategy = mappingStrategy;
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "true");
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "false");
    }

    @SuppressWarnings("unchecked")
    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      try
      {
        Class<IMappingStrategy> clazz = (Class<IMappingStrategy>)Class.forName(mappingStrategy);
        return clazz.newInstance();
      }
      catch (Exception ex)
      {
        throw WrappedException.wrap(ex);
      }
    }

    @Override
    protected IDBAdapter createDBAdapter()
    {
      return new H2Adapter();
    }

    @Override
    protected DataSource createDataSource(String repoName)
    {
      if (dbFolder == null)
      {
        dbFolder = createDBFolder();
        tearDownClean();
      }

      JdbcDataSource dataSource = new JdbcDataSource();
      dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
      return dataSource;
    }

    protected void tearDownClean()
    {
      IOUtil.delete(dbFolder);
    }

    protected File createDBFolder()
    {
      return TMPUtil.createTempFolder("h2_", "_test");
    }

    /**
     * @author Eike Stepper
     */
    public static class ReusableFolder extends H2
    {
      private static final long serialVersionUID = 1L;

      public static final ReusableFolder AUDIT_INSTANCE = new ReusableFolder("DBStore: H2 (Reusable Folder, audit), ",
          "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategy");

      public static final ReusableFolder RANGE_INSTANCE = new ReusableFolder(
          "DBStore: H2 (Reusable Folder, audit, range-based mapping strategy)",
          "org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategyWithRanges");

      private static File reusableFolder;

      private static JdbcDataSource defaultDataSource;

      private transient ArrayList<String> repoNames = new ArrayList<String>();

      public ReusableFolder(String name, String mappingStrategy)
      {
        super(name, mappingStrategy);
      }

      @Override
      protected DataSource createDataSource(String repoName)
      {
        if (reusableFolder == null)
        {
          reusableFolder = createDBFolder();
          IOUtil.delete(reusableFolder);
        }

        dbFolder = reusableFolder;
        if (defaultDataSource == null)
        {
          defaultDataSource = new JdbcDataSource();
          defaultDataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test");
        }

        Connection conn = null;
        Statement stmt = null;

        try
        {
          conn = defaultDataSource.getConnection();
          stmt = conn.createStatement();

          if (!isRestarting())
          {
            stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
          }

          stmt.execute("CREATE SCHEMA IF NOT EXISTS " + repoName);
        }
        catch (Exception e)
        {
          e.printStackTrace();
        }
        finally
        {
          DBUtil.close(conn);
          DBUtil.close(stmt);
        }

        JdbcDataSource dataSource = new JdbcDataSource();
        dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
        return dataSource;
      }

      @Override
      protected void tearDownClean()
      {
        for (String repoName : repoNames)
        {
          tearDownClean(repoName);
        }
      }

      protected void tearDownClean(String repoName)
      {
        reusableFolder.deleteOnExit();
        Connection connection = null;
        Statement stmt = null;

        try
        {
          connection = defaultDataSource.getConnection();
          stmt = connection.createStatement();
          stmt.execute("DROP SCHEMA " + repoName);
        }
        catch (Exception ex)
        {
          throw WrappedException.wrap(ex);
        }
        finally
        {
          DBUtil.close(stmt);
          DBUtil.close(connection);
        }
      }
    }
  }
}




  public void testLengthAnnotationNegative() throws Exception
  {
    // HSQL does not support length annotations
    skipTest(getRepositoryConfig() instanceof HsqldbConfig);

    // XXX PSQL fails, too - need to investigate
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);

    msg("Opening session");
    EPackage model1 = createModel();

  public void testLengthAnnotationByMetaData() throws CommitException
  {
    // XXX [PSQL] disabled because of Bug 290095
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);

    msg("Opening session");
    final EPackage model1 = createModel();

  public void testTypeAnnotationByMetaData() throws CommitException
  {
    // XXX [PSQL] disabled because of Bug 290095
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);

    // HSQL does not support type annotations
    skipTest(getRepositoryConfig() instanceof HsqldbConfig);
    skipConfig(AllTestsDBHsqldbNonAudit.HsqldbNonAudit.INSTANCE);

    msg("Opening session");
    final EPackage model1 = createModel();

  public void testTableNameAnnotationByMetaData() throws CommitException
  {
    // XXX [PSQL] disabled because of Bug 290095
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);

    msg("Opening session");
    EPackage model1 = createModel();

  public void testColumnNameAnnotationByMetaData() throws CommitException
  {
    // XXX [PSQL] disabled because of Bug 290095
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);

    msg("Opening session");
    final EPackage model1 = createModel();

  public void testColumnNameTypeAnnotationByMetaData() throws CommitException
  {
    // HSQL does not support type annotations
    skipTest(getRepositoryConfig() instanceof HsqldbConfig);
    skipConfig(AllTestsDBHsqldbNonAudit.HsqldbNonAudit.INSTANCE);

    // XXX [PSQL] disabled because of Bug 290095
    skipTest(getRepositoryConfig() instanceof PostgresqlConfig);

    msg("Opening session");
    final EPackage model1 = createModel();




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.derby.EmbeddedDerbyAdapter;
import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.apache.derby.jdbc.EmbeddedDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new DerbyConfig(true, true, IDGenerationLocation.STORE), JVM, NATIVE);
    // addScenario(parent, COMBINED, AllTestsDBDerby.Derby.INSTANCE, TCP, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return false;
  }

  /**
   * @author Eike Stepper
   */
  public static class Derby extends DBStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsDBDerby.Derby INSTANCE = new Derby("DBStore: Derby");

    private transient ArrayList<File> dbFolders = new ArrayList<File>();

    public Derby(String name)
    {
      super(name);
    }

    @Override
    protected IMappingStrategy createMappingStrategy()
    {
      return CDODBUtil.createHorizontalMappingStrategy(true);
    }

    @Override
    protected IDBAdapter createDBAdapter()
    {
      return new EmbeddedDerbyAdapter();
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "true");
    }

    @Override
    protected DataSource createDataSource(String repoName)
    {
      File dbFolder = createDBFolder(repoName);
      dbFolders.add(dbFolder);

      tearDownClean(dbFolder);

      EmbeddedDataSource dataSource = new EmbeddedDataSource();
      dataSource.setDatabaseName(dbFolder.getAbsolutePath());
      dataSource.setCreateDatabase("create");

      return dataSource;
    }

    public Collection<File> getDbFolders()
    {
      return dbFolders;
    }

    @Override
    protected void deactivateRepositories()
    {
      for (File folder : getDbFolders())
      {
        tearDownClean(folder);
      }

      super.deactivateRepositories();
    }

    protected void tearDownClean(File dbFolder)
    {
      IOUtil.delete(dbFolder);
    }

    protected File createDBFolder(String repo)
    {
      return TMPUtil.createTempFolder("derby_" + repo + "_", "_test");
    }

    /**
     * @author Eike Stepper
     */
    public static class ReusableFolder extends Derby
    {
      private static final long serialVersionUID = 1L;

      public static final ReusableFolder INSTANCE = new ReusableFolder("DBStore: Derby");

      private static HashMap<String, File> dbFolders = new HashMap<String, File>();

      private static HashMap<File, EmbeddedDataSource> dataSources = new HashMap<File, EmbeddedDataSource>();

      public ReusableFolder(String name)
      {
        super(name);
      }

      @Override
      protected DataSource createDataSource(String repoName)
      {
        File reusableFolder = dbFolders.get(repoName);

        boolean needsNewFolder = reusableFolder == null;
        if (needsNewFolder)
        {
          reusableFolder = createDBFolder(repoName);
          IOUtil.delete(reusableFolder);
          dbFolders.put(repoName, reusableFolder);
        }

        EmbeddedDataSource dataSource = new EmbeddedDataSource();
        dataSource.setDatabaseName(reusableFolder.getAbsolutePath());
        dataSource.setCreateDatabase("create");
        dataSources.put(reusableFolder, dataSource);

        if (!needsNewFolder)
        {
          tearDownClean(reusableFolder);
        }

        return dataSource;
      }

      @Override
      public Collection<File> getDbFolders()
      {
        return dbFolders.values();
      }

      @Override
      protected void tearDownClean(File folder)
      {
        folder.deleteOnExit();
        Connection connection = null;

        EmbeddedDataSource dataSource = dataSources.get(folder);

        try
        {
          connection = dataSource.getConnection();
          DBUtil.dropAllTables(connection, dataSource.getDatabaseName());
        }
        catch (RuntimeException ex)
        {
          throw ex;
        }
        catch (Exception ex)
        {
          throw WrappedException.wrap(ex);
        }
        finally
        {
          DBUtil.close(connection);
        }
      }
    }
  }
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
import org.eclipse.emf.cdo.server.db.mapping.ITypeMapping;
import org.eclipse.emf.cdo.server.internal.db.mapping.TypeMappingRegistry;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.util.container.IPluginContainer;

import javax.sql.DataSource;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Eike Stepper
 */
public abstract class DBStoreRepositoryConfig extends RepositoryConfig
{
  private static final long serialVersionUID = 1L;

  public DBStoreRepositoryConfig(String name)
  {
    super(name);
  }

  @Override
  public void setUp() throws Exception
  {
    CDODBUtil.prepareContainer(IPluginContainer.INSTANCE);
    super.setUp();
    ((TypeMappingRegistry)ITypeMapping.Registry.INSTANCE).init();
  }

  @Override
  protected boolean isOptimizing()
  {
    return true;
  }

  public IStore createStore(String repoName)
  {
    IMappingStrategy mappingStrategy = createMappingStrategy();
    mappingStrategy.setProperties(createMappingStrategyProperties());
    IDBAdapter dbAdapter = createDBAdapter();
    DataSource dataSource = createDataSource(repoName);
    return CDODBUtil.createStore(mappingStrategy, dbAdapter, DBUtil.createConnectionProvider(dataSource));
  }

  protected Map<String, String> createMappingStrategyProperties()
  {
    Map<String, String> props = new HashMap<String, String>();
    props.put(IMappingStrategy.PROP_QUALIFIED_NAMES, "true");
    return props;
  }

  protected abstract IMappingStrategy createMappingStrategy();

  protected abstract IDBAdapter createDBAdapter();

  protected abstract DataSource createDataSource(String repoName);
}

Lines 27-33 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DISABLE_XATransactionTest.java (-2 / +2 lines)
27	public void testCommitFromTransactionDisabled() throws Exception	27	public void testCommitFromTransactionDisabled() throws Exception
28	{	28	{
29	// XXX disabled because of Bug 290097	29	// XXX disabled because of Bug 290097
30	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	30	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
31	super.testCommitFromTransactionDisabled();	31	super.testCommitFromTransactionDisabled();
32	}	32	}
33		33
Lines 36-42 Link Here
36	public void test_ExceptionInReadingStream() throws Exception	36	public void test_ExceptionInReadingStream() throws Exception
37	{	37	{
38	// XXX disabled because of Bug 290097	38	// XXX disabled because of Bug 290097
39	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	39	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
40	super.test_ExceptionInReadingStream();	40	super.test_ExceptionInReadingStream();
41	}	41	}
42	}	42	}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.IRepository.Props;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.mysql.MYSQLAdapter;

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

import javax.sql.DataSource;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author Simon McDuff
 */
public class MysqlConfig extends DBConfig
{
  private static final long serialVersionUID = 1L;

  private transient DataSource setupDataSource;

  private transient List<String> databases = new ArrayList<String>();

  /**
   * Instructions to test with MySQL: - create a mysql instance - set HOST to the host where the DB is running
   * (listening on TCP) - set USER to a user who can create and drop databases (root, essentially) - set PASS to the
   * password of the said user
   */
  public static final String HOST = "localhost";

  public static final String USER = "root";

  public static final String PASS = "root";

  public MysqlConfig(boolean supportingAudits, boolean supportingBranches, IDGenerationLocation idGenerationLocation)
  {
    super("Mysql", supportingAudits, supportingBranches, false, false, idGenerationLocation);
  }

  @Override
  protected IDBAdapter createDBAdapter()
  {
    return new MYSQLAdapter();
  }

  @Override
  protected DataSource createDataSource(String repoName)
  {
    MysqlDataSource ds = new MysqlDataSource();

    initDatabase("test_" + repoName);

    ds.setUrl("jdbc:mysql://" + MysqlConfig.HOST + "/test_" + repoName);
    ds.setUser(MysqlConfig.USER);
    if (MysqlConfig.PASS != null)
    {
      ds.setPassword(MysqlConfig.PASS);
    }

    return ds;
  }

  private void initDatabase(String dbName)
  {
    dropDatabase(dbName);
    Connection connection = null;
    Statement stmt = null;

    try
    {
      connection = getSetupDataSource().getConnection();
      stmt = connection.createStatement();
      stmt.execute("create database " + dbName);
    }
    catch (SQLException ignore)
    {
    }
    finally
    {
      DBUtil.close(stmt);
      DBUtil.close(connection);
    }
  }

  @Override
  protected void deactivateRepositories()
  {
    super.deactivateRepositories();
    for (String dbName : databases)
    {
      dropDatabase(dbName);
    }
  }

  private void dropDatabase(String dbName)
  {
    Connection connection = null;
    Statement stmt = null;

    try
    {
      connection = getSetupDataSource().getConnection();
      stmt = connection.createStatement();
      stmt.execute("DROP database " + dbName);
    }
    catch (SQLException ignore)
    {
    }
    finally
    {
      DBUtil.close(stmt);
      DBUtil.close(connection);
    }
  }

  private DataSource getSetupDataSource()
  {
    if (setupDataSource == null)
    {
      MysqlDataSource ds = new MysqlDataSource();
      ds.setUrl("jdbc:mysql://" + MysqlConfig.HOST);
      ds.setUser(MysqlConfig.USER);
      if (MysqlConfig.PASS != null)
      {
        ds.setPassword(MysqlConfig.PASS);
      }

      setupDataSource = ds;
    }

    return setupDataSource;
  }

  @Override
  protected void initRepositoryProperties(Map<String, String> props)
  {
    super.initRepositoryProperties(props);
    props.put(Props.SUPPORTING_AUDITS, "true");
    props.put(Props.SUPPORTING_BRANCHES, "true");
  }
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;

import org.eclipse.net4j.db.DBUtil;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.db.derby.EmbeddedDerbyAdapter;
import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.io.TMPUtil;

import org.apache.derby.jdbc.EmbeddedDataSource;

import javax.sql.DataSource;

import java.io.File;
import java.sql.Connection;
import java.util.Collection;
import java.util.HashMap;

/**
 * @author Eike Stepper
 */
public class DerbyConfig extends DBConfig
{
  private static final long serialVersionUID = 1L;

  private static HashMap<String, File> dbFolders = new HashMap<String, File>();

  private static HashMap<File, EmbeddedDataSource> dataSources = new HashMap<File, EmbeddedDataSource>();

  public DerbyConfig(boolean supportingAudits, boolean supportingBranches, IDGenerationLocation idGenerationLocation)
  {
    super("Derby", supportingAudits, supportingBranches, false, false, idGenerationLocation);
  }

  public Collection<File> getDBFolders()
  {
    return dbFolders.values();
  }

  @Override
  protected IDBAdapter createDBAdapter()
  {
    return new EmbeddedDerbyAdapter();
  }

  @Override
  protected DataSource createDataSource(String repoName)
  {
    File reusableFolder = dbFolders.get(repoName);

    boolean needsNewFolder = reusableFolder == null;
    if (needsNewFolder)
    {
      reusableFolder = createDBFolder(repoName);
      IOUtil.delete(reusableFolder);
      dbFolders.put(repoName, reusableFolder);
    }

    EmbeddedDataSource dataSource = new EmbeddedDataSource();
    dataSource.setDatabaseName(reusableFolder.getAbsolutePath());
    dataSource.setCreateDatabase("create");
    dataSources.put(reusableFolder, dataSource);

    if (!needsNewFolder)
    {
      tearDownClean(reusableFolder);
    }

    return dataSource;
  }

  @Override
  protected void deactivateRepositories()
  {
    for (File folder : getDBFolders())
    {
      tearDownClean(folder);
    }

    super.deactivateRepositories();
  }

  protected void tearDownClean(File folder)
  {
    folder.deleteOnExit();
    Connection connection = null;

    EmbeddedDataSource dataSource = dataSources.get(folder);

    try
    {
      connection = dataSource.getConnection();
      DBUtil.dropAllTables(connection, dataSource.getDatabaseName());
    }
    catch (RuntimeException ex)
    {
      throw ex;
    }
    catch (Exception ex)
    {
      throw WrappedException.wrap(ex);
    }
    finally
    {
      DBUtil.close(connection);
    }
  }

  protected File createDBFolder(String repo)
  {
    return TMPUtil.createTempFolder("derby_" + repo + "_", "_test");
  }
}




<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<launchConfiguration type="org.eclipse.jdt.junit.launchconfig">
<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
<listEntry value="/org.eclipse.emf.cdo.tests.db/src/org/eclipse/emf/cdo/tests/db/AllTestsDBH2All.java"/>
</listAttribute>
<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
<listEntry value="1"/>
</listAttribute>
<stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value=""/>
<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit3"/>
<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.cdo.tests.db.AllTestsDBH2All"/>
<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.emf.cdo.tests.db"/>
<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xms40m&#13;&#10;-Xmx1024m&#13;&#10;-Dorg.eclipse.net4j.util.om.trace.disable=true"/>
</launchConfiguration>




 */
package org.eclipse.emf.cdo.tests.db;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;

import junit.framework.Test;
import junit.framework.TestSuite;


  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenarios(parent, IDGenerationLocation.STORE);
    addScenarios(parent, IDGenerationLocation.CLIENT);
    addScenario(parent, COMBINED, AllTestsDBH2Branching.H2Branching.ReusableFolder.INSTANCE, JVM, NATIVE);
  }

  private void addScenarios(TestSuite parent, IDGenerationLocation idGenerationLocation)
  protected boolean hasAuditSupport()
  {
    // Non-audit
    addScenario(parent, COMBINED, new H2Config(false, false, false, false, idGenerationLocation), JVM, NATIVE);

    // Audit
    addScenario(parent, COMBINED, new H2Config(true, false, false, false, idGenerationLocation), JVM, NATIVE);
    addScenario(parent, COMBINED, new H2Config(true, false, true, false, idGenerationLocation), JVM, NATIVE);

    // Branching
    addScenario(parent, COMBINED, new H2Config(true, true, false, false, idGenerationLocation), JVM, NATIVE);
    addScenario(parent, COMBINED, new H2Config(true, true, true, false, idGenerationLocation), JVM, NATIVE);
    addScenario(parent, COMBINED, new H2Config(true, true, true, true, idGenerationLocation), JVM, NATIVE);
  }
}




import org.eclipse.emf.cdo.tests.XRefTest;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_252214_Test;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_303807_Test;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;

public abstract class DBConfigs extends AllConfigs
{
  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    testClasses.add(Net4jDBTest.class);
    testClasses.add(DBAnnotationsTest.class);

    testClasses.add(CustomTypeMappingTest.class);
    testClasses.add(SQLQueryTest.class);

    super.initTestClasses(testClasses, scenario);
    testClasses.remove(MEMStoreQueryTest.class);

    if (!scenario.getRepositoryConfig().isSupportingBranches())
    {
      testClasses.remove(BranchingTest.class);
      testClasses.remove(BranchingSameSessionTest.class);

      testClasses.remove(Bugzilla_303807_Test.class);
    }

    if (!scenario.getRepositoryConfig().isSupportingAudits())
    {
      // non-audit mode - remove audit tests
      testClasses.remove(AuditTest.class);

    testClasses.remove(ExternalReferenceTest.class);
    testClasses.add(DISABLE_ExternalReferenceTest.class);
  }

  protected abstract boolean hasBranchingSupport();

  protected abstract boolean hasAuditSupport();
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.mongodb;

import org.eclipse.emf.cdo.server.CDOServerBrowser;
import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.internal.mongodb.MongoDBStore;
import org.eclipse.emf.cdo.server.mongodb.CDOMongoDBUtil;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;

import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.container.IPluginContainer;

import com.mongodb.DB;
import com.mongodb.Mongo;
import com.mongodb.MongoURI;

import java.util.Map;

/**
 * @author Eike Stepper
 */
public class MongoDBStoreRepositoryConfig extends RepositoryConfig
{
  public static final MongoDBStoreRepositoryConfig INSTANCE = new MongoDBStoreRepositoryConfig(false, false);

  public static final MongoDBStoreRepositoryConfig AUDITING = new MongoDBStoreRepositoryConfig(true, false);

  public static final MongoDBStoreRepositoryConfig BRANCHING = new MongoDBStoreRepositoryConfig(true, true);

  private static final long serialVersionUID = 1L;

  private boolean auditing;

  private boolean branching;

  private transient CDOServerBrowser mongoBrowser;

  public MongoDBStoreRepositoryConfig(boolean auditing, boolean branching)
  {
    super("MongoDBStore" + (branching ? " (branching)" : auditing ? " (auditing)" : ""));
    this.auditing = auditing;
    this.branching = branching;
  }

  @Override
  public void setUp() throws Exception
  {
    CDOMongoDBUtil.prepareContainer(IPluginContainer.INSTANCE);

    mongoBrowser = new CDOServerBrowser(MongoDBStore.REPOS);
    mongoBrowser.setPort(7778);
    mongoBrowser.activate();

    super.setUp();
  }

  @Override
  public void tearDown() throws Exception
  {
    mongoBrowser.deactivate();
    super.tearDown();
  }

  public IStore createStore(String repoName)
  {
    MongoURI mongoURI = new MongoURI("mongodb://localhost");
    if (!isRestarting())
    {
      dropDatabase(mongoURI, repoName);
    }

    return CDOMongoDBUtil.createStore(mongoURI.toString(), repoName);
  }

  protected void dropDatabase(MongoURI mongoURI, String repoName)
  {
    Mongo mongo = null;

    try
    {
      mongo = new Mongo(mongoURI);
      DB db = mongo.getDB(repoName);
      if (!db.getCollectionNames().isEmpty())
      {
        db.dropDatabase();
      }
    }
    catch (Exception ex)
    {
      throw WrappedException.wrap(ex);
    }
    finally
    {
      if (mongo != null)
      {
        mongo.close();
      }
    }
  }

  @Override
  protected void initRepositoryProperties(Map<String, String> props)
  {
    super.initRepositoryProperties(props);
    props.put(IRepository.Props.SUPPORTING_AUDITS, Boolean.toString(auditing));
    props.put(IRepository.Props.SUPPORTING_BRANCHES, Boolean.toString(branching));
  }
}




 */
package org.eclipse.emf.cdo.tests.mongodb;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.tests.AllConfigs;
import org.eclipse.emf.cdo.tests.MEMStoreQueryTest;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new MongoDBConfig(false, false, IDGenerationLocation.STORE), JVM, NATIVE);
    addScenario(parent, COMBINED, new MongoDBConfig(true, false, IDGenerationLocation.STORE), JVM, NATIVE);
    // addScenario(parent, COMBINED, MongoDBStoreRepositoryConfig.BRANCHING, JVM, NATIVE);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    testClasses.add(MongoDBInitialTest.class);
    super.initTestClasses(testClasses, scenario);
    testClasses.remove(MEMStoreQueryTest.class);
  }
}




 */
package org.eclipse.emf.cdo.tests.mongodb;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.internal.mongodb.MongoDBStore;
import org.eclipse.emf.cdo.server.mongodb.CDOMongoDBUtil;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;


import com.mongodb.Mongo;
import com.mongodb.MongoURI;

import java.util.Map;

/**
 * @author Eike Stepper
 */
public class MongoDBConfig extends RepositoryConfig
{
  public static final MongoDBStoreRepositoryConfig INSTANCE = new MongoDBStoreRepositoryConfig(false, false);

  public static final MongoDBStoreRepositoryConfig AUDITING = new MongoDBStoreRepositoryConfig(true, false);

  public static final MongoDBStoreRepositoryConfig BRANCHING = new MongoDBStoreRepositoryConfig(true, true);

  private static final long serialVersionUID = 1L;

  public MongoDBConfig(boolean supportingAudits, boolean supportingBranches, IDGenerationLocation idGenerationLocation)

  private boolean branching;

  private transient CDOServerBrowser mongoBrowser;

  public MongoDBStoreRepositoryConfig(boolean auditing, boolean branching)
  {
    super("MongoDB", supportingAudits, supportingBranches, idGenerationLocation);
    this.auditing = auditing;
    this.branching = branching;
  }

  @Override
  public void setUp() throws Exception
  {
    CDOMongoDBUtil.prepareContainer(IPluginContainer.INSTANCE);

    mongoBrowser = new CDOServerBrowser(MongoDBStore.REPOS);
    mongoBrowser.setPort(7778);
    mongoBrowser.activate();

    super.setUp();
  }

  @Override
  public void tearDown() throws Exception
  {
    mongoBrowser.deactivate();
    super.tearDown();
  }

  public IStore createStore(String repoName)
  {
    MongoURI mongoURI = new MongoURI("mongodb://localhost");

      }
    }
  }

  @Override
  protected void initRepositoryProperties(Map<String, String> props)
  {
    super.initRepositoryProperties(props);
    props.put(IRepository.Props.SUPPORTING_AUDITS, Boolean.toString(auditing));
    props.put(IRepository.Props.SUPPORTING_BRANCHES, Boolean.toString(branching));
  }
}
  + text/plain

Lines 10-15 Link Here

(-)src/org/eclipse/emf/cdo/tests/config/IRepositoryConfig.java (+7 lines)
10	*/	10	*/
11	package org.eclipse.emf.cdo.tests.config;	11	package org.eclipse.emf.cdo.tests.config;
12		12
		13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
13	import org.eclipse.emf.cdo.server.IStore;	14	import org.eclipse.emf.cdo.server.IStore;
14	import org.eclipse.emf.cdo.spi.server.InternalRepository;	15	import org.eclipse.emf.cdo.spi.server.InternalRepository;
15		16
Lines 22-27 Link Here
22	{	23	{
23	public static final String REPOSITORY_NAME = "repo1";	24	public static final String REPOSITORY_NAME = "repo1";
24		25
		26	public boolean isSupportingAudits();
		27
		28	public boolean isSupportingBranches();
		29
		30	public IDGenerationLocation getIDGenerationLocation();
		31
25	public Map<String, String> getRepositoryProperties();	32	public Map<String, String> getRepositoryProperties();
26		33
27	public InternalRepository getRepository(String name, boolean activate);	34	public InternalRepository getRepository(String name, boolean activate);

Lines 67-73 Link Here

(-)src/org/eclipse/emf/cdo/tests/config/impl/ConfigTestSuite.java (-2 / +2 lines)
67	TestSuite suite = new TestSuite(scenario.toString());	67	TestSuite suite = new TestSuite(scenario.toString());
68		68
69	List<Class<? extends ConfigTest>> testClasses = new ArrayList<Class<? extends ConfigTest>>();	69	List<Class<? extends ConfigTest>> testClasses = new ArrayList<Class<? extends ConfigTest>>();
70	initTestClasses(testClasses);	70	initTestClasses(testClasses, scenario);
71		71
72	for (Class<? extends ConfigTest> testClass : testClasses)	72	for (Class<? extends ConfigTest> testClass : testClasses)
73	{	73	{
Lines 98-104 Link Here
98	// }	98	// }
99	// }	99	// }
100		100
101	protected abstract void initTestClasses(List<Class<? extends ConfigTest>> testClasses);	101	protected abstract void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario);
102		102
103	/**	103	/**
104	* @author Eike Stepper	104	* @author Eike Stepper

Lines 11-16 Link Here

(-)src/org/eclipse/emf/cdo/tests/defs/AllTestsCDODefs.java (-1 / +2 lines)
11	*/	11	*/
12	package org.eclipse.emf.cdo.tests.defs;	12	package org.eclipse.emf.cdo.tests.defs;
13		13
		14	import org.eclipse.emf.cdo.tests.config.IScenario;
14	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	15	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
15	import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;	16	import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;
16		17
Lines 36-42 Link Here
36	}	37	}
37		38
38	@Override	39	@Override
39	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	40	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
40	{	41	{
41	testClasses.add(EGlobalPackageDefImplTest.class);	42	testClasses.add(EGlobalPackageDefImplTest.class);
42	testClasses.add(CDOPackageRegistryDefImplTest.class);	43	testClasses.add(CDOPackageRegistryDefImplTest.class);

Lines 11-16 Link Here

(-)src/org/eclipse/emf/cdo/tests/config/impl/RepositoryConfig.java (-87 / +50 lines)
11	*/	11	*/
12	package org.eclipse.emf.cdo.tests.config.impl;	12	package org.eclipse.emf.cdo.tests.config.impl;
13		13
		14	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
14	import org.eclipse.emf.cdo.common.CDOCommonView;	15	import org.eclipse.emf.cdo.common.CDOCommonView;
15	import org.eclipse.emf.cdo.common.commit.CDOCommitInfo;	16	import org.eclipse.emf.cdo.common.commit.CDOCommitInfo;
16	import org.eclipse.emf.cdo.common.revision.CDORevisionUtil;	17	import org.eclipse.emf.cdo.common.revision.CDORevisionUtil;
Lines 93-98 Link Here
93		94
94	private static final long serialVersionUID = 1L;	95	private static final long serialVersionUID = 1L;
95		96
		97	private boolean supportingAudits;
		98
		99	private boolean supportingBranches;
		100
		101	private IDGenerationLocation idGenerationLocation;
		102
96	protected transient Map<String, InternalRepository> repositories;	103	protected transient Map<String, InternalRepository> repositories;
97		104
98	/**	105	/**
Lines 107-115 Link Here
107		114
108	private transient IRepository.WriteAccessHandler resourcePathChecker;	115	private transient IRepository.WriteAccessHandler resourcePathChecker;
109		116
110	public RepositoryConfig(String name)	117	public RepositoryConfig(String name, boolean supportingAudits, boolean supportingBranches,
		118	IDGenerationLocation idGenerationLocation)
111	{	119	{
112	super(name);	120	super(name);
		121
		122	this.supportingAudits = supportingAudits;
		123	this.supportingBranches = supportingBranches;
		124	this.idGenerationLocation = idGenerationLocation;
		125	}
		126
		127	public boolean isSupportingAudits()
		128	{
		129	return supportingAudits;
		130	}
		131
		132	public boolean isSupportingBranches()
		133	{
		134	return supportingBranches;
		135	}
		136
		137	public IDGenerationLocation getIDGenerationLocation()
		138	{
		139	return idGenerationLocation;
		140	}
		141
		142	@Override
		143	public String getName()
		144	{
		145	return super.getName() + (supportingBranches ? "-branching" : supportingAudits ? "-auditing" : "")
		146	+ getMappingStrategySpecialization() + (idGenerationLocation == IDGenerationLocation.CLIENT ? "-uuids" : "");
		147	}
		148
		149	protected String getMappingStrategySpecialization()
		150	{
		151	return "";
113	}	152	}
114		153
115	public void setRestarting(boolean restarting)	154	public void setRestarting(boolean restarting)
Lines 139-146 Link Here
139	}	178	}
140	}	179	}
141		180
142	// int xxx;
143	// repositoryProperties.put(IRepository.Props.ID_GENERATION_LOCATION, IDGenerationLocation.CLIENT.toString());
144	return repositoryProperties;	181	return repositoryProperties;
145	}	182	}
146		183
Lines 195-202 Link Here
195	protected void initRepositoryProperties(Map<String, String> props)	232	protected void initRepositoryProperties(Map<String, String> props)
196	{	233	{
197	props.put(Props.OVERRIDE_UUID, ""); // UUID := name !!!	234	props.put(Props.OVERRIDE_UUID, ""); // UUID := name !!!
198	props.put(Props.SUPPORTING_AUDITS, "false");	235	props.put(Props.SUPPORTING_AUDITS, Boolean.toString(supportingAudits));
199	props.put(Props.SUPPORTING_BRANCHES, "false");	236	props.put(Props.SUPPORTING_BRANCHES, Boolean.toString(supportingBranches));
		237	props.put(Props.ID_GENERATION_LOCATION, idGenerationLocation.toString());
		238
200	}	239	}
201		240
202	public void registerRepository(final InternalRepository repository)	241	public void registerRepository(final InternalRepository repository)
Lines 542-548 Link Here
542		581
543	public OfflineConfig(String name)	582	public OfflineConfig(String name)
544	{	583	{
545	super(name);	584	super(name, true, true, IDGenerationLocation.CLIENT);
546	}	585	}
547		586
548	@Override	587	@Override
Lines 560-573 Link Here
560	}	599	}
561		600
562	@Override	601	@Override
563	protected void initRepositoryProperties(Map<String, String> props)
564	{
565	super.initRepositoryProperties(props);
566	props.put(Props.SUPPORTING_AUDITS, "true");
567	props.put(Props.SUPPORTING_BRANCHES, "true");
568	}
569
570	@Override
571	protected InternalRepository createRepository(String name)	602	protected InternalRepository createRepository(String name)
572	{	603	{
573	boolean failover = getTestFailover();	604	boolean failover = getTestFailover();
Lines 755-851 Link Here
755	/**	786	/**
756	* @author Eike Stepper	787	* @author Eike Stepper
757	*/	788	*/
758	public static class MEM extends RepositoryConfig	789	public static class MEMConfig extends RepositoryConfig
759	{	790	{
760	public static final MEM INSTANCE = new MEM();
761
762	private static final long serialVersionUID = 1L;	791	private static final long serialVersionUID = 1L;
763		792
764	public MEM()	793	public MEMConfig(boolean supportingAudits, boolean supportingBranches, IDGenerationLocation idGenerationLocation)
765	{	794	{
766	super("MEM");	795	super("MEM", supportingAudits, supportingBranches, idGenerationLocation);
767	}	796	}
768		797
769	public IStore createStore(String repoName)	798	public IStore createStore(String repoName)
770	{	799	{
771	return MEMStoreUtil.createMEMStore();	800	return MEMStoreUtil.createMEMStore();
772	}	801	}
773
774	@Override
775	protected void initRepositoryProperties(Map<String, String> props)
776	{
777	super.initRepositoryProperties(props);
778	props.put(Props.SUPPORTING_AUDITS, "false");
779	props.put(Props.SUPPORTING_BRANCHES, "false");
780	}
781	}	802	}
782		803
783	/**	804	/**
784	* @author Eike Stepper	805	* @author Eike Stepper
785	*/	806	*/
786	public static class MEMAudits extends RepositoryConfig	807	public static class MEMOfflineConfig extends OfflineConfig
787	{	808	{
788	public static final MEMAudits INSTANCE = new MEMAudits();
789
790	private static final long serialVersionUID = 1L;	809	private static final long serialVersionUID = 1L;
791		810
792	public MEMAudits()	811	public MEMOfflineConfig()
793	{
794	super("MEMAudits");
795	}
796
797	public IStore createStore(String repoName)
798	{
799	return MEMStoreUtil.createMEMStore();
800	}
801
802	@Override
803	protected void initRepositoryProperties(Map<String, String> props)
804	{
805	super.initRepositoryProperties(props);
806	props.put(Props.SUPPORTING_AUDITS, "true");
807	props.put(Props.SUPPORTING_BRANCHES, "false");
808	}
809	}
810
811	/**
812	* @author Eike Stepper
813	*/
814	public static class MEMBranches extends RepositoryConfig
815	{
816	public static final MEMBranches INSTANCE = new MEMBranches();
817
818	private static final long serialVersionUID = 1L;
819
820	public MEMBranches()
821	{
822	super("MEMBranches");
823	}
824
825	public IStore createStore(String repoName)
826	{
827	return MEMStoreUtil.createMEMStore();
828	}
829
830	@Override
831	protected void initRepositoryProperties(Map<String, String> props)
832	{
833	super.initRepositoryProperties(props);
834	props.put(Props.SUPPORTING_AUDITS, "true");
835	props.put(Props.SUPPORTING_BRANCHES, "true");
836	}
837	}
838
839	/**
840	* @author Eike Stepper
841	*/
842	public static class MEMOffline extends OfflineConfig
843	{
844	public static final MEMOffline INSTANCE = new MEMOffline();
845
846	private static final long serialVersionUID = 1L;
847
848	public MEMOffline()
849	{	812	{
850	super("MEMOffline");	813	super("MEMOffline");
851	}	814	}




package org.eclipse.emf.cdo.tests.config.impl;

import org.eclipse.emf.cdo.tests.config.IConfig;
import org.eclipse.emf.cdo.tests.config.IConstants;
import org.eclipse.emf.cdo.tests.config.IContainerConfig;
import org.eclipse.emf.cdo.tests.config.IModelConfig;
import org.eclipse.emf.cdo.tests.config.IRepositoryConfig;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.ISessionConfig;
import org.eclipse.emf.cdo.tests.config.impl.SessionConfig.Net4j;

import org.eclipse.net4j.util.WrappedException;
import org.eclipse.net4j.util.io.IOUtil;


    private Default()
    {
      setContainerConfig(IConstants.COMBINED);
      setRepositoryConfig(IConstants.MEM_BRANCHES);
      setSessionConfig(IConstants.JVM);
      setModelConfig(IConstants.NATIVE);
    }
  }
}




 */
package org.eclipse.emf.cdo.tests.config;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.tests.config.impl.ContainerConfig;
import org.eclipse.emf.cdo.tests.config.impl.ModelConfig;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig.MEMConfig;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig.MEMOfflineConfig;
import org.eclipse.emf.cdo.tests.config.impl.SessionConfig;
import org.eclipse.emf.cdo.tests.config.impl.SessionConfig.Net4j;



  public static final ContainerConfig SEPARATED = ContainerConfig.Separated.INSTANCE;

  public static final RepositoryConfig MEM = new MEMConfig(false, false, IDGenerationLocation.STORE);

  public static final RepositoryConfig MEM_AUDITS = new MEMConfig(true, false, IDGenerationLocation.STORE);

  public static final RepositoryConfig MEM_BRANCHES = new MEMConfig(true, true, IDGenerationLocation.STORE);

  public static final RepositoryConfig MEM_OFFLINE = new MEMOfflineConfig();

  public static final SessionConfig EMBEDDED = SessionConfig.Embedded.INSTANCE;


Lines 11-16 Link Here

(-)src/org/eclipse/emf/cdo/tests/AllConfigs.java (-1 / +2 lines)
11	package org.eclipse.emf.cdo.tests;	11	package org.eclipse.emf.cdo.tests;
12		12
13	import org.eclipse.emf.cdo.tests.bugzilla.*;	13	import org.eclipse.emf.cdo.tests.bugzilla.*;
		14	import org.eclipse.emf.cdo.tests.config.IScenario;
14	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	15	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
15	import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;	16	import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;
16		17
Lines 22-28 Link Here
22	public abstract class AllConfigs extends ConfigTestSuite	23	public abstract class AllConfigs extends ConfigTestSuite
23	{	24	{
24	@Override	25	@Override
25	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	26	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
26	{	27	{
27	// General	28	// General
28	testClasses.add(InitialTest.class);	29	testClasses.add(InitialTest.class);

Lines 10-15 Link Here

(-)src/org/eclipse/emf/cdo/tests/AllTestsMEMOffline.java (-8 / +7 lines)
10	*/	10	*/
11	package org.eclipse.emf.cdo.tests;	11	package org.eclipse.emf.cdo.tests;
12		12
		13	import org.eclipse.emf.cdo.tests.config.IScenario;
13	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	14	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
14	import org.eclipse.emf.cdo.tests.offline.FailoverTest;	15	import org.eclipse.emf.cdo.tests.offline.FailoverTest;
15	import org.eclipse.emf.cdo.tests.offline.OfflineDelayed2Test;	16	import org.eclipse.emf.cdo.tests.offline.OfflineDelayed2Test;
Lines 31-40 Link Here
31	}	32	}
32		33
33	@Override	34	@Override
34	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	35	protected void initConfigSuites(TestSuite parent)
35	{	36	{
36	// super.initTestClasses(testClasses);	37	addScenario(parent, COMBINED, MEM_OFFLINE, JVM, NATIVE);
		38	}
37		39
		40	@Override
		41	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
		42	{
38	// MEM does not support raw replication	43	// MEM does not support raw replication
39	// testClasses.add(OfflineRawTest.class);	44	// testClasses.add(OfflineRawTest.class);
40		45
Lines 42-51 Link Here
42	testClasses.add(OfflineDelayed2Test.class);	47	testClasses.add(OfflineDelayed2Test.class);
43	testClasses.add(FailoverTest.class);	48	testClasses.add(FailoverTest.class);
44	}	49	}
45
46	@Override
47	protected void initConfigSuites(TestSuite parent)
48	{
49	addScenario(parent, COMBINED, MEM_OFFLINE, JVM, NATIVE);
50	}
51	}	50	}




 */
package org.eclipse.emf.cdo.tests.objectivity;

import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.tests.BranchingWithCacheClearTest;
import org.eclipse.emf.cdo.tests.InitialTest;
import org.eclipse.emf.cdo.tests.MergingTest;

import org.eclipse.emf.cdo.tests.RevisionDeltaInBranchTest;
import org.eclipse.emf.cdo.tests.UnsetTest;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new ObjyConfig(false, false), JVM, NATIVE);
    addScenario(parent, COMBINED, repConfig, JVM, NATIVE);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    // super.initTestClasses(testClasses);
    // testClasses.remove(XATransactionTest.class);

    testClasses.clear();

    // testClasses.add(ComplexTest.class);

    // testClasses.add(Bugzilla_259949_Test.class);
    testClasses.add(Bugzilla_261218_Test.class);
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return true;
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  public static class ObjySampleConfig extends ObjyStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final SampleTestsObjy.ObjySampleConfig INSTANCE = new ObjySampleConfig("ObjectivityStore: (sample)"); //$NON-NLS-1$

    public ObjySampleConfig(String name)
    {
      super(name);

      org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.DEBUG.setEnabled(true);
      org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.INFO.setEnabled(true);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "true");
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "true");
    }
  }

}




 */
package org.eclipse.emf.cdo.tests.objectivity;

import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.tests.ExternalReferenceTest;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new ObjyConfig(false, false), JVM, NATIVE);
    ObjyStoreRepositoryConfig repoConfig = new ObjyNonAuditConfig("ObjectivityStore: (non-audit)"); //$NON-NLS-1$
    addScenario(parent, COMBINED, repoConfig, JVM, NATIVE);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return false;
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    return false;
  }

  public static class ObjyNonAuditConfig extends ObjyStoreRepositoryConfig
  {
    super.initTestClasses(testClasses, scenario);

    public static final AllTestsObjyNonAudit.ObjyNonAuditConfig INSTANCE = new ObjyNonAuditConfig(
        "ObjectivityStore: (non-audit)"); //$NON-NLS-1$

    public ObjyNonAuditConfig(String name)
    {
      super(name);

      org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.DEBUG.setEnabled(true);
      org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.INFO.setEnabled(true);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "false"); //$NON-NLS-1$
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "false"); //$NON-NLS-1$
    }
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)
  {
    super.initTestClasses(testClasses);
    // There is a problem with the root resource sharing, so for now we're commenting
    // out ExternalReferenceTest and Bugzilla_259869_Test
    testClasses.remove(ExternalReferenceTest.class);




 */
package org.eclipse.emf.cdo.tests.objectivity;

import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;


  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new ObjyConfig(true, false), JVM, NATIVE);
    addScenario(parent, COMBINED, repoConfig, JVM, NATIVE);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)
  {
    super.initTestClasses(testClasses);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return false;
  }

  public static class ObjyAuditConfig extends ObjyStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsObjyAudit.ObjyAuditConfig INSTANCE = new ObjyAuditConfig("ObjectivityStore: (audit)"); //$NON-NLS-1$

    public ObjyAuditConfig(String name)
    {
      super(name);

      org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.DEBUG.setEnabled(true);
      org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.INFO.setEnabled(true);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "true"); //$NON-NLS-1$
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "false"); //$NON-NLS-1$
    }
  }
}




package org.eclipse.emf.cdo.tests.objectivity;

import org.eclipse.emf.cdo.tests.AllConfigs;
import org.eclipse.emf.cdo.tests.AuditTest;
import org.eclipse.emf.cdo.tests.AuditSameSessionTest;
import org.eclipse.emf.cdo.tests.AuditTest;
import org.eclipse.emf.cdo.tests.BranchingSameSessionTest;
import org.eclipse.emf.cdo.tests.BranchingTest;
import org.eclipse.emf.cdo.tests.MergingTest;
import org.eclipse.emf.cdo.tests.XATransactionTest;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_252214_Test;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_303807_Test;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;

public abstract class ObjyDBConfigs extends AllConfigs
{
  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    super.initTestClasses(testClasses, scenario);

    // remove BranchingTests because most mappings do not support it
    // Subclasses should add Banching tests if supported
    if (!scenario.getRepositoryConfig().isSupportingBranches())
    {
      testClasses.remove(BranchingTest.class);
      testClasses.remove(BranchingSameSessionTest.class);

      testClasses.remove(Bugzilla_303807_Test.class);
    }

    if (!scenario.getRepositoryConfig().isSupportingAudits())
    {
      // non-audit mode - remove audit tests
      testClasses.remove(AuditTest.class);

    // sometime cause a crash (Investigate!!)
    testClasses.remove(XATransactionTest.class);
  }

  protected abstract boolean hasBranchingSupport();

  protected abstract boolean hasAuditSupport();
}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.objectivity;

import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.internal.objectivity.ObjectivityStoreConfig;
import org.eclipse.emf.cdo.server.objectivity.ObjyStoreUtil;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;

/**
 * @author Eike Stepper
 */
public abstract class ObjyStoreRepositoryConfig extends RepositoryConfig
{
  private static final long serialVersionUID = 1L;

  private static ObjectivityStoreConfig storeConfig = new ObjectivityStoreConfig();

  public ObjyStoreRepositoryConfig(String name)
  {
    super(name);
  }

  @Override
  public void setUp() throws Exception
  {
    // System.out.println("ObjyStoreRepositry.setup() - STARTED");
    // long sTime = System.currentTimeMillis();
    super.setUp();
    // long eTime = System.currentTimeMillis();
    // System.out.println("ObjyStoreRepositry.setup() time: " + (eTime - sTime));
  }

  @Override
  protected void deactivateRepositories()
  {
    super.deactivateRepositories();
    // System.out.println(">>>>IS:<<<< We need to remove all data created here....");
    storeConfig.resetFD();
  }

  public IStore createStore(String repoName)
  {
    // We might need to use the repoName to our advantage!!!
    System.out.println("************* ObjyStore creation ****************\n");
    return ObjyStoreUtil.createStore(storeConfig);
  }

}




 */
package org.eclipse.emf.cdo.tests.objectivity;

import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;

import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;


  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new ObjyConfig(true, true), JVM, NATIVE);
    addScenario(parent, COMBINED, repoConfig, JVM, NATIVE);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)
  {
    super.initTestClasses(testClasses);

    // // add branching tests for this testsuite
    // testClasses.add(BranchingTest.class);
    // testClasses.add(BranchingSameSessionTest.class);
    // testClasses.add(MergingTest.class);
  }

  @Override
  protected boolean hasAuditSupport()
  {
    return true;
  }

  @Override
  protected boolean hasBranchingSupport()
  {
    return true;
  }

  public static class ObjyBranchingConfig extends ObjyStoreRepositoryConfig
  {
    private static final long serialVersionUID = 1L;

    public static final AllTestsObjyBranching.ObjyBranchingConfig INSTANCE = new ObjyBranchingConfig(
        "ObjectivityStore: (branching)"); //$NON-NLS-1$

    public ObjyBranchingConfig(String name)
    {
      super(name);

      org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.DEBUG.setEnabled(true);
      org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.INFO.setEnabled(true);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "true"); //$NON-NLS-1$
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "true"); //$NON-NLS-1$
    }
  }
}




 */
package org.eclipse.emf.cdo.tests.objectivity;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.internal.objectivity.ObjectivityStoreConfig;
import org.eclipse.emf.cdo.server.objectivity.ObjyStoreUtil;

/**
 * @author Eike Stepper
 */
public class ObjyConfig extends RepositoryConfig
{
  private static final long serialVersionUID = 1L;

  private static ObjectivityStoreConfig storeConfig = new ObjectivityStoreConfig();

  public ObjyConfig(boolean supportingAudits, boolean supportingBranches)
  {
    super("Objy", supportingAudits, supportingBranches, IDGenerationLocation.STORE);
  }

    org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.DEBUG.setEnabled(true);
    org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.INFO.setEnabled(true);
  {
    // System.out.println("ObjyStoreRepositry.setup() - STARTED");
    // long sTime = System.currentTimeMillis();
    super.setUp();
    // long eTime = System.currentTimeMillis();
    // System.out.println("ObjyStoreRepositry.setup() time: " + (eTime - sTime));
  }

  @Override

    System.out.println("************* ObjyStore creation ****************\n");
    return ObjyStoreUtil.createStore(storeConfig);
  }

}




 */
package org.eclipse.emf.cdo.tests.db4o;

import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.internal.db4o.DB4OStore;
import org.eclipse.emf.cdo.tests.AllConfigs;
import org.eclipse.emf.cdo.tests.BranchingSameSessionTest;
import org.eclipse.emf.cdo.tests.BranchingTest;
import org.eclipse.emf.cdo.tests.BranchingWithCacheClearTest;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_324585_Test;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;

import org.eclipse.net4j.util.io.TMPUtil;

import java.io.File;
import java.io.IOException;
import java.net.ServerSocket;
import java.util.List;
import java.util.Map;
import java.util.Random;

import junit.framework.Test;
import junit.framework.TestSuite;

  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new DB4OConfig(false), JVM, NATIVE);
  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    super.initTestClasses(testClasses, scenario);

    // Added here testcases to skip
    // takes too much

    testClasses.remove(BranchingSameSessionTest.class);
    testClasses.remove(BranchingWithCacheClearTest.class);
  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, DB4ORepositoryConfig.INSTANCE, JVM, NATIVE);
  }

  /**
   * @author Victor Roldan Betancort
   */
  public static class DB4ORepositoryConfig extends RepositoryConfig
  {
    private static final Random RANDOM = new Random(System.currentTimeMillis());

    public static final DB4ORepositoryConfig INSTANCE = new DB4ORepositoryConfig("DB4O");

    private static final long serialVersionUID = 1L;

    private transient boolean optimizing = true;

    public DB4ORepositoryConfig(String name)
    {
      super(name);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "false");
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "false");
    }

    public IStore createStore(String repoName)
    {
      File tempFolder = TMPUtil.getTempFolder();
      File file = new File(tempFolder, "cdodb_" + repoName + ".db4o");
      if (file.exists() && !isRestarting())
      {
        file.delete();
      }

      int port = 0;
      boolean ok = false;
      do
      {
        ServerSocket sock = null;
        try
        {
          port = 1024 + RANDOM.nextInt(65536 - 1024);
          sock = new ServerSocket(port);
          ok = true;
        }
        catch (IOException e)
        {
        }
        finally
        {
          try
          {
            if (sock != null)
            {
              sock.close();
            }
          }
          catch (IOException e)
          {
          }
        }
      } while (!ok);

      IStore store = new DB4OStore(file.getPath(), port);
      return store;
    }

    @Override
    protected boolean isOptimizing()
    {
      // Do NOT replace this with a hardcoded value!
      return optimizing;
    }
  }
}




package org.eclipse.emf.cdo.tests.db4o;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.internal.db4o.DB4OStore;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;

import org.eclipse.net4j.util.io.TMPUtil;

import java.io.File;
import java.io.IOException;
import java.net.ServerSocket;
import java.util.Random;

/**
 * @author Victor Roldan Betancort
 */
public class DB4OConfig extends RepositoryConfig
{
  private static final Random RANDOM = new Random(System.currentTimeMillis());

  private static final long serialVersionUID = 1L;

  private boolean mem;

  private transient boolean optimizing = true;

  public DB4OConfig(boolean mem)
  {
    super("DB4O", false, false, IDGenerationLocation.STORE);
    this.mem = mem;
  }

  public boolean isMem()
  {
    return mem;
  }

  public IStore createStore(String repoName)
  {
    if (mem)
    {
      if (!isRestarting())
      {
        MEMDB4OStore.clearContainer();
      }

      return new MEMDB4OStore();
    }

    File tempFolder = TMPUtil.getTempFolder();
    File file = new File(tempFolder, "cdodb_" + repoName + ".db4o");
    if (file.exists() && !isRestarting())
    {
      file.delete();
    }

    int port = 0;
    boolean ok = false;
    do
    {
      ServerSocket sock = null;

      try
      {
        port = 1024 + RANDOM.nextInt(65536 - 1024);
        sock = new ServerSocket(port);
        ok = true;
      }
      catch (IOException e)
      {
      }
      finally
      {
        try
        {
          if (sock != null)
          {
            sock.close();
          }
        }
        catch (IOException e)
        {
        }
      }
    } while (!ok);

    return new DB4OStore(file.getPath(), port);
  }

  @Override
  protected boolean isOptimizing()
  {
    // Do NOT replace this with a hardcoded value!
    return optimizing;
  }
}




package org.eclipse.emf.cdo.tests.db4o;

import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;

import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

public class AllTestsMEMDB4O extends AllTestsDB4O
{

  public static Test suite()
  {
    return new AllTestsMEMDB4O().getTestSuite("CDO Tests (MEMDB4O)");
  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, MemDB4ORepositoryConfig.INSTANCE, JVM, NATIVE);
  }

  public static class MemDB4ORepositoryConfig extends RepositoryConfig
  {
    public static final MemDB4ORepositoryConfig INSTANCE = new MemDB4ORepositoryConfig("DB4O");

    private static final long serialVersionUID = 1L;

    private transient boolean optimizing = false;

    public MemDB4ORepositoryConfig(String name)
    {
      super(name);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "false");
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "false");
    }

    public IStore createStore(String repoName)
    {
      if (!isRestarting())
      {
        MEMDB4OStore.clearContainer();
      }

      return new MEMDB4OStore();
    }

    @Override
    protected boolean isOptimizing()
    {
      // Do NOT replace this with a hardcoded value!
      return optimizing;
    }
  }

}




/**
 * Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Victor Roldan Betancort - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.db4o;

import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;

import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * @author Victor Roldan Betancort
 */
public class AllTestsDB4OMem extends AllTestsDB4O
{

  public static Test suite()
  {
    return new AllTestsDB4OMem().getTestSuite("CDO Tests (DB4OMem)");
  }

  @Override
  protected void initConfigSuites(TestSuite parent)
  {
    addScenario(parent, COMBINED, new DB4OConfig(true), JVM, NATIVE);
  }

  public static class MemDB4ORepositoryConfig extends RepositoryConfig
  {
    public static final MemDB4ORepositoryConfig INSTANCE = new MemDB4ORepositoryConfig("DB4O");

    private static final long serialVersionUID = 1L;

    private transient boolean optimizing = false;

    public MemDB4ORepositoryConfig(String name)
    {
      super(name);
    }

    @Override
    protected void initRepositoryProperties(Map<String, String> props)
    {
      super.initRepositoryProperties(props);
      props.put(IRepository.Props.SUPPORTING_AUDITS, "false");
      props.put(IRepository.Props.SUPPORTING_BRANCHES, "false");
    }

    public IStore createStore(String repoName)
    {
      if (!isRestarting())
      {
        MEMDB4OStore.clearContainer();
      }

      return new MEMDB4OStore();
    }

    @Override
    protected boolean isOptimizing()
    {
      // Do NOT replace this with a hardcoded value!
      return optimizing;
    }
  }

}
  + text/plain

Lines 28-34 Link Here

(-)src/org/eclipse/emf/cdo/internal/common/revision/CDOIDAndVersionImpl.java (-1 / +1 lines)
28		28
29	public CDOIDAndVersionImpl(CDOID id, int version)	29	public CDOIDAndVersionImpl(CDOID id, int version)
30	{	30	{
31	CheckUtil.checkNull(id, "id");	31	CheckUtil.checkArg(id, "id");
32		32
33	this.id = id;	33	this.id = id;
34	this.version = version;	34	this.version = version;

Lines 30-37 Link Here

(-)src/org/eclipse/emf/cdo/internal/common/revision/CDOIDAndBranchImpl.java (-2 / +2 lines)
30		30
31	public CDOIDAndBranchImpl(CDOID id, CDOBranch branch)	31	public CDOIDAndBranchImpl(CDOID id, CDOBranch branch)
32	{	32	{
33	CheckUtil.checkNull(id, "id");	33	CheckUtil.checkArg(id, "id");
34	CheckUtil.checkNull(branch, "branch");	34	CheckUtil.checkArg(branch, "branch");
35		35
36	this.id = id;	36	this.id = id;
37	this.branch = branch;	37	this.branch = branch;

Lines 11-17 Link Here

(-)src/org/eclipse/emf/cdo/spi/common/revision/CDOReferenceAdjustable.java (-1 lines)
11	*/	11	*/
12	package org.eclipse.emf.cdo.spi.common.revision;	12	package org.eclipse.emf.cdo.spi.common.revision;
13		13
14
15	/**	14	/**
16	* @author Simon McDuff	15	* @author Simon McDuff
17	* @since 4.0	16	* @since 4.0




import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_316444_Test;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_319836_Test;
import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_322804_Test;
import org.eclipse.emf.cdo.tests.config.IScenario;
import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;
import org.eclipse.emf.cdo.util.CommitException;

  }

  @Override
  protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
  {
    // testClasses.clear();
    // testClasses.add(XRefTest.class);

    testClasses.add(Hibernate_PartialCommitTest.class);
    testClasses.add(Hibernate_Bugzilla_316444_Test.class);

    super.initTestClasses(testClasses, scenario);

    // Teneo does not yet support lists of int arrays:
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330212




 */
package org.eclipse.emf.cdo.tests.hibernate;

import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
import org.eclipse.emf.cdo.server.IStore;
import org.eclipse.emf.cdo.server.hibernate.CDOHibernateUtil;
import org.eclipse.emf.cdo.server.hibernate.IHibernateMappingProvider;


  public HibernateConfig()
  {
    super("Hibernate", false, false, IDGenerationLocation.STORE);
  }

  @Override
  protected void initRepositoryProperties(Map<String, String> props)
  {
    super.initRepositoryProperties(props);
    props.put(Props.SUPPORTING_AUDITS, "false");
    props.put(Props.SUPPORTING_BRANCHES, "false");

    try
    {

Lines 1-7 Link Here

(-)META-INF/MANIFEST.MF (-3 / +3 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-SymbolicName: org.eclipse.emf.cdo.tests.ui;singleton:=true	3	Bundle-SymbolicName: org.eclipse.emf.cdo.tests.ui;singleton:=true
4	Bundle-Version: 4.0.0.qualifier	4	Bundle-Version: 4.0.100.qualifier
5	Bundle-Name: %pluginName	5	Bundle-Name: %pluginName
6	Bundle-Vendor: %providerName	6	Bundle-Vendor: %providerName
7	Bundle-Localization: plugin	7	Bundle-Localization: plugin
Lines 19-23 Link Here
19	org.eclipse.emf.cdo.ui;bundle-version="[4.0.0,5.0.0)",	19	org.eclipse.emf.cdo.ui;bundle-version="[4.0.0,5.0.0)",
20	org.eclipse.emf.cdo.tests;bundle-version="[4.0.0,5.0.0)"	20	org.eclipse.emf.cdo.tests;bundle-version="[4.0.0,5.0.0)"
21	Eclipse-BuddyPolicy:	21	Eclipse-BuddyPolicy:
22	Export-Package: org.eclipse.emf.cdo.tests.ui;version="4.0.0";x-friends:="org.eclipse.emf.cdo.dawn.tests",	22	Export-Package: org.eclipse.emf.cdo.tests.ui;version="4.0.100";x-friends:="org.eclipse.emf.cdo.dawn.tests",
23	org.eclipse.emf.cdo.tests.ui.bundle;version="4.0.0";x-internal:=true	23	org.eclipse.emf.cdo.tests.ui.bundle;version="4.0.100";x-internal:=true

Lines 11-16 Link Here

(-)src/org/eclipse/emf/cdo/tests/ui/AllTestsCDOUISWTBot.java (-1 / +2 lines)
11	package org.eclipse.emf.cdo.tests.ui;	11	package org.eclipse.emf.cdo.tests.ui;
12		12
13	import org.eclipse.emf.cdo.tests.AllTests;	13	import org.eclipse.emf.cdo.tests.AllTests;
		14	import org.eclipse.emf.cdo.tests.config.IScenario;
14	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	15	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
15	import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;	16	import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;
16		17
Lines 42-48 Link Here
42	}	43	}
43		44
44	@Override	45	@Override
45	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	46	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
46	{	47	{
47	testClasses.add(CDOSessionsViewTest.class);	48	testClasses.add(CDOSessionsViewTest.class);
48	}	49	}




 */
package org.eclipse.emf.cdo.server.internal.db.mapping.horizontal;

import org.eclipse.emf.cdo.server.db.CDODBUtil;
import org.eclipse.emf.cdo.server.db.mapping.IClassMapping;
import org.eclipse.emf.cdo.server.db.mapping.IListMapping;
import org.eclipse.emf.cdo.server.internal.db.CDODBSchema;

 */
public class HorizontalBranchingMappingStrategyWithRanges extends AbstractHorizontalMappingStrategy
{
  private static final String PROP_COPY_ON_BRANCH = "copyOnBranch";

  private boolean copyOnBranch;

  public HorizontalBranchingMappingStrategyWithRanges()

  {
    super.doAfterActivate();

    String value = getProperties().get(CDODBUtil.PROP_COPY_ON_BRANCH);
    copyOnBranch = value == null ? false : Boolean.valueOf(value);
  }
}

Lines 18-24 Link Here

(-)src/org/eclipse/emf/cdo/server/db/CDODBUtil.java (-7 / +49 lines)
18	import org.eclipse.emf.cdo.server.internal.db.SmartPreparedStatementCache;	18	import org.eclipse.emf.cdo.server.internal.db.SmartPreparedStatementCache;
19	import org.eclipse.emf.cdo.server.internal.db.bundle.OM;	19	import org.eclipse.emf.cdo.server.internal.db.bundle.OM;
20	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategy;	20	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategy;
		21	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalAuditMappingStrategyWithRanges;
21	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalBranchingMappingStrategy;	22	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalBranchingMappingStrategy;
		23	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalBranchingMappingStrategyWithRanges;
		24	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalMappingStrategy;
22	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalNonAuditMappingStrategy;	25	import org.eclipse.emf.cdo.server.internal.db.mapping.horizontal.HorizontalNonAuditMappingStrategy;
23		26
24	import org.eclipse.net4j.db.IDBAdapter;	27	import org.eclipse.net4j.db.IDBAdapter;
Lines 47-52 Link Here
47	*/	50	*/
48	public static final String EXT_POINT_MAPPING_STRATEGIES = "mappingStrategies"; //$NON-NLS-1$	51	public static final String EXT_POINT_MAPPING_STRATEGIES = "mappingStrategies"; //$NON-NLS-1$
49		52
		53	/**
		54	* @since 4.1
		55	*/
		56	public static final String PROP_WITH_RANGES = "withRanges";
		57
		58	/**
		59	* @since 4.1
		60	*/
		61	public static final String PROP_COPY_ON_BRANCH = "copyOnBranch";
		62
50	private CDODBUtil()	63	private CDODBUtil()
51	{	64	{
52	}	65	}
Lines 77-88 Link Here
77	*/	90	*/
78	public static IMappingStrategy createHorizontalMappingStrategy(boolean auditing)	91	public static IMappingStrategy createHorizontalMappingStrategy(boolean auditing)
79	{	92	{
80	if (auditing)	93	return createHorizontalMappingStrategy(auditing, false, false);
81	{
82	return new HorizontalAuditMappingStrategy();
83	}
84
85	return new HorizontalNonAuditMappingStrategy();
86	}	94	}
87		95
88	/**	96	/**
Lines 90-106 Link Here
90	*/	98	*/
91	public static IMappingStrategy createHorizontalMappingStrategy(boolean auditing, boolean branching)	99	public static IMappingStrategy createHorizontalMappingStrategy(boolean auditing, boolean branching)
92	{	100	{
		101	return createHorizontalMappingStrategy(auditing, branching, false);
		102	}
		103
		104	/**
		105	* @since 4.1
		106	*/
		107	public static IMappingStrategy createHorizontalMappingStrategy(boolean auditing, boolean branching, boolean withRanges)
		108	{
93	if (branching)	109	if (branching)
94	{	110	{
95	if (auditing)	111	if (auditing)
96	{	112	{
		113	if (withRanges)
		114	{
		115	return new HorizontalBranchingMappingStrategyWithRanges();
		116	}
		117
97	return new HorizontalBranchingMappingStrategy();	118	return new HorizontalBranchingMappingStrategy();
98	}	119	}
99		120
100	throw new IllegalArgumentException("Misconfiguration: Branching requires Auditing!");	121	throw new IllegalArgumentException("Misconfiguration: Branching requires Auditing!");
101	}	122	}
102		123
103	return createHorizontalMappingStrategy(auditing);	124	if (auditing)
		125	{
		126	if (withRanges)
		127	{
		128	return new HorizontalAuditMappingStrategyWithRanges();
		129	}
		130
		131	return new HorizontalAuditMappingStrategy();
		132	}
		133
		134	return new HorizontalNonAuditMappingStrategy();
		135	}
		136
		137	/**
		138	* Creates a horizontal {@link IMappingStrategy mapping strategy} that supports all valid combinations of auditing and
		139	* branching.
		140	*
		141	* @since 4.1
		142	*/
		143	public static IMappingStrategy createHorizontalMappingStrategy()
		144	{
		145	return new HorizontalMappingStrategy();
104	}	146	}
105		147
106	/**	148	/**

Lines 1321-1328 Link Here

(-)src/org/eclipse/emf/cdo/server/internal/db/mapping/horizontal/BranchingListTableMappingWithRanges.java (-2 / +8 lines)
1321	{	1321	{
1322	IRepository repository = accessor.getStore().getRepository();	1322	IRepository repository = accessor.getStore().getRepository();
1323	CDOBranchPoint base = repository.getBranchManager().getBranch(branchID).getBase();	1323	CDOBranchPoint base = repository.getBranchManager().getBranch(branchID).getBase();
1324	InternalCDORevision baseRevision = (InternalCDORevision)repository.getRevisionManager()	1324	InternalCDORevision baseRevision = (InternalCDORevision)repository.getRevisionManager().getRevision(id, base, /*
1325	.getRevision(id, base, /* referenceChunk = /0, / prefetchDepth = */CDORevision.DEPTH_NONE, true);	1325	* referenceChunk
		1326	* =
		1327	/0, /
		1328	* prefetchDepth
		1329	* =
		1330	*/
		1331	CDORevision.DEPTH_NONE, true);
1326	IStoreChunkReader chunkReader = accessor.createChunkReader(baseRevision, getFeature());	1332	IStoreChunkReader chunkReader = accessor.createChunkReader(baseRevision, getFeature());
1327	return chunkReader;	1333	return chunkReader;
1328	}	1334	}

Lines 240-246 Link Here

(-)src/org/eclipse/emf/cdo/server/internal/db/mapping/horizontal/HorizontalMappingStrategy.java (-1 / +7 lines)
240	boolean auditing = getBooleanProperty(Props.SUPPORTING_AUDITS);	240	boolean auditing = getBooleanProperty(Props.SUPPORTING_AUDITS);
241	boolean branching = getBooleanProperty(Props.SUPPORTING_BRANCHES);	241	boolean branching = getBooleanProperty(Props.SUPPORTING_BRANCHES);
242		242
243	delegate = CDODBUtil.createHorizontalMappingStrategy(auditing, branching);	243	boolean withRanges = false;
		244	if (auditing \|\| branching)
		245	{
		246	withRanges = getBooleanProperty(CDODBUtil.PROP_WITH_RANGES);
		247	}
		248
		249	delegate = CDODBUtil.createHorizontalMappingStrategy(auditing, branching, withRanges);
244	delegate.setStore(store);	250	delegate.setStore(store);
245	delegate.setProperties(properties);	251	delegate.setProperties(properties);
246	LifecycleUtil.activate(delegate);	252	LifecycleUtil.activate(delegate);

Return to bug 352696

Lines 14-19 Link Here

(-)src/org/eclipse/emf/cdo/dawn/tests/AllTestsDawnUI.java (-6 / +7 lines)
14	import org.eclipse.emf.cdo.dawn.tests.ui.gmf.DawnBasicGMFUITest;	14	import org.eclipse.emf.cdo.dawn.tests.ui.gmf.DawnBasicGMFUITest;
15	import org.eclipse.emf.cdo.dawn.tests.ui.gmf.DawnCreationWizardTest;	15	import org.eclipse.emf.cdo.dawn.tests.ui.gmf.DawnCreationWizardTest;
16	import org.eclipse.emf.cdo.tests.AllTests;	16	import org.eclipse.emf.cdo.tests.AllTests;
		17	import org.eclipse.emf.cdo.tests.config.IScenario;
17	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	18	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
18		19
19	import java.util.List;	20	import java.util.List;
Lines 34-49 Link Here
34	}	35	}
35		36
36	@Override	37	@Override
37	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	38	protected void initConfigSuites(TestSuite parent)
38	{	39	{
39	testClasses.add(DawnCreationWizardTest.class);	40	addScenario(parent, COMBINED, MEM, TCP, NATIVE);
40	testClasses.add(DawnBasicGMFUITest.class);
41	testClasses.add(DawnBasicEMFUITest.class);
42	}	41	}
43		42
44	@Override	43	@Override
45	protected void initConfigSuites(TestSuite parent)	44	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
46	{	45	{
47	addScenario(parent, COMBINED, MEM, TCP, NATIVE);	46	testClasses.add(DawnCreationWizardTest.class);
		47	testClasses.add(DawnBasicGMFUITest.class);
		48	testClasses.add(DawnBasicEMFUITest.class);
48	}	49	}
49	}	50	}

Lines 12-17 Link Here

(-)src/org/eclipse/emf/cdo/dawn/tests/TCPConfigStarter.java (-4 / +5 lines)
12		12
13	import org.eclipse.emf.cdo.tests.AllConfigs;	13	import org.eclipse.emf.cdo.tests.AllConfigs;
14	import org.eclipse.emf.cdo.tests.InitialTest;	14	import org.eclipse.emf.cdo.tests.InitialTest;
		15	import org.eclipse.emf.cdo.tests.config.IScenario;
15	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	16	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
16		17
17	import java.util.List;	18	import java.util.List;
Lines 30-43 Link Here
30	}	31	}
31		32
32	@Override	33	@Override
33	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	34	protected void initConfigSuites(TestSuite parent)
34	{	35	{
35	testClasses.add(InitialTest.class);	36	addScenario(parent, COMBINED, MEM_BRANCHES, TCP, NATIVE);
36	}	37	}
37		38
38	@Override	39	@Override
39	protected void initConfigSuites(TestSuite parent)	40	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
40	{	41	{
41	addScenario(parent, COMBINED, MEM_BRANCHES, TCP, NATIVE);	42	testClasses.add(InitialTest.class);
42	}	43	}
43	}	44	}

Lines 15-20 Link Here

(-)src/org/eclipse/emf/cdo/dawn/tests/AllTestsDawn.java (-7 / +8 lines)
15	import org.eclipse.emf.cdo.dawn.tests.common.GMFTest;	15	import org.eclipse.emf.cdo.dawn.tests.common.GMFTest;
16	import org.eclipse.emf.cdo.dawn.tests.common.TestFrameworkTest;	16	import org.eclipse.emf.cdo.dawn.tests.common.TestFrameworkTest;
17	import org.eclipse.emf.cdo.tests.AllTests;	17	import org.eclipse.emf.cdo.tests.AllTests;
		18	import org.eclipse.emf.cdo.tests.config.IScenario;
18	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	19	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
19		20
20	import java.util.List;	21	import java.util.List;
Lines 35-51 Link Here
35	}	36	}
36		37
37	@Override	38	@Override
38	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	39	protected void initConfigSuites(TestSuite parent)
39	{	40	{
40	testClasses.add(TestFrameworkTest.class);	41	addScenario(parent, COMBINED, MEM, JVM, NATIVE);
41	testClasses.add(GMFTest.class);
42	testClasses.add(DawnWrapperResourceTest.class);
43	testClasses.add(DawnCodeGenGMFFragmentTest.class);
44	}	42	}
45		43
46	@Override	44	@Override
47	protected void initConfigSuites(TestSuite parent)	45	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
48	{	46	{
49	addScenario(parent, COMBINED, MEM, JVM, NATIVE);	47	testClasses.add(TestFrameworkTest.class);
		48	testClasses.add(GMFTest.class);
		49	testClasses.add(DawnWrapperResourceTest.class);
		50	testClasses.add(DawnCodeGenGMFFragmentTest.class);
50	}	51	}
51	}	52	}

Lines 10-25 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/AllTestsDBHsqldbNonAudit.java (-53 / +5 lines)
10	*/	10	*/
11	package org.eclipse.emf.cdo.tests.db;	11	package org.eclipse.emf.cdo.tests.db;
12		12
13	import org.eclipse.emf.cdo.server.IRepository;	13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
14	import org.eclipse.emf.cdo.server.db.CDODBUtil;
15	import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
16	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;	14	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;
		15	import org.eclipse.emf.cdo.tests.config.IScenario;
17	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	16	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
18	import org.eclipse.emf.cdo.tests.db.verifier.DBStoreVerifier;
19	import org.eclipse.emf.cdo.tests.db.verifier.DBStoreVerifier.NonAudit;
20		17
21	import java.util.List;	18	import java.util.List;
22	import java.util.Map;
23		19
24	import junit.framework.Test;	20	import junit.framework.Test;
25	import junit.framework.TestSuite;	21	import junit.framework.TestSuite;
Lines 37-95 Link Here
37	@Override	33	@Override
38	protected void initConfigSuites(TestSuite parent)	34	protected void initConfigSuites(TestSuite parent)
39	{	35	{
40	addScenario(parent, COMBINED, AllTestsDBHsqldbNonAudit.HsqldbNonAudit.INSTANCE, TCP, NATIVE);	36	addScenario(parent, COMBINED, new HsqldbConfig(false, false, IDGenerationLocation.STORE), TCP, NATIVE);
41	}	37	}
42		38
43	@Override	39	@Override
44	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	40	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
45	{	41	{
46	super.initTestClasses(testClasses);	42	super.initTestClasses(testClasses, scenario);
47		43
48	// this takes ages - so for now, we disable it	44	// this takes ages - so for now, we disable it
49	testClasses.remove(Bugzilla_261218_Test.class);	45	testClasses.remove(Bugzilla_261218_Test.class);
50	}	46	}
51
52	@Override
53	protected boolean hasAuditSupport()
54	{
55	return false;
56	}
57
58	@Override
59	protected boolean hasBranchingSupport()
60	{
61	return false;
62	}
63
64	public static class HsqldbNonAudit extends AllTestsDBHsqldb.Hsqldb
65	{
66	private static final long serialVersionUID = 1L;
67
68	public static final AllTestsDBHsqldbNonAudit.HsqldbNonAudit INSTANCE = new HsqldbNonAudit(
69	"DBStore: Hsqldb (non audit)");
70
71	public HsqldbNonAudit(String name)
72	{
73	super(name);
74	}
75
76	@Override
77	protected void initRepositoryProperties(Map<String, String> props)
78	{
79	super.initRepositoryProperties(props);
80	props.put(IRepository.Props.SUPPORTING_AUDITS, "false");
81	}
82
83	@Override
84	protected IMappingStrategy createMappingStrategy()
85	{
86	return CDODBUtil.createHorizontalMappingStrategy(false);
87	}
88
89	@Override
90	protected DBStoreVerifier getVerifier(IRepository repository)
91	{
92	return new NonAudit(repository);
93	}
94	}
95	}	47	}

Lines 10-15 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DBConfig.java (-4 / +32 lines)
10	*/	10	*/
11	package org.eclipse.emf.cdo.tests.db;	11	package org.eclipse.emf.cdo.tests.db;
12		12
		13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
13	import org.eclipse.emf.cdo.server.IStore;	14	import org.eclipse.emf.cdo.server.IStore;
14	import org.eclipse.emf.cdo.server.db.CDODBUtil;	15	import org.eclipse.emf.cdo.server.db.CDODBUtil;
15	import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;	16	import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
Lines 29-41 Link Here
29	/**	30	/**
30	* @author Eike Stepper	31	* @author Eike Stepper
31	*/	32	*/
32	public abstract class DBStoreRepositoryConfig extends RepositoryConfig	33	public abstract class DBConfig extends RepositoryConfig
33	{	34	{
34	private static final long serialVersionUID = 1L;	35	private static final long serialVersionUID = 1L;
35		36
36	public DBStoreRepositoryConfig(String name)	37	private boolean withRanges;
		38
		39	private boolean copyOnBranch;
		40
		41	public DBConfig(String name, boolean supportingAudits, boolean supportingBranches, boolean withRanges,
		42	boolean copyOnBranch, IDGenerationLocation idGenerationLocation)
		43	{
		44	super(name, supportingAudits, supportingBranches, idGenerationLocation);
		45	this.withRanges = withRanges;
		46	this.copyOnBranch = copyOnBranch;
		47	}
		48
		49	public boolean isWithRanges()
		50	{
		51	return withRanges;
		52	}
		53
		54	public boolean isCopyOnBranch()
37	{	55	{
38	super(name);	56	return copyOnBranch;
39	}	57	}
40		58
41	@Override	59	@Override
Lines 65-74 Link Here
65	{	83	{
66	Map<String, String> props = new HashMap<String, String>();	84	Map<String, String> props = new HashMap<String, String>();
67	props.put(IMappingStrategy.PROP_QUALIFIED_NAMES, "true");	85	props.put(IMappingStrategy.PROP_QUALIFIED_NAMES, "true");
		86	props.put(CDODBUtil.PROP_COPY_ON_BRANCH, Boolean.toString(copyOnBranch));
68	return props;	87	return props;
69	}	88	}
70		89
71	protected abstract IMappingStrategy createMappingStrategy();	90	protected IMappingStrategy createMappingStrategy()
		91	{
		92	return CDODBUtil.createHorizontalMappingStrategy(isSupportingAudits(), isSupportingBranches(), withRanges);
		93	}
		94
		95	@Override
		96	protected String getMappingStrategySpecialization()
		97	{
		98	return (withRanges ? "-ranges" : "") + (copyOnBranch ? "-copy" : "");
		99	}
72		100
73	protected abstract IDBAdapter createDBAdapter();	101	protected abstract IDBAdapter createDBAdapter();
74		102

Lines 21-27 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DISABLE_AttributeTest.java (-3 / +3 lines)
21	public void testByteArray() throws Exception	21	public void testByteArray() throws Exception
22	{	22	{
23	// XXX disabled because of Bug 289445	23	// XXX disabled because of Bug 289445
24	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	24	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
25	super.testByteArray();	25	super.testByteArray();
26	}	26	}
27		27
Lines 29-35 Link Here
29	public void testByteArrayEmpty() throws Exception	29	public void testByteArrayEmpty() throws Exception
30	{	30	{
31	// XXX disabled because of Bug 289445	31	// XXX disabled because of Bug 289445
32	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	32	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
33	super.testByteArrayEmpty();	33	super.testByteArrayEmpty();
34	}	34	}
35		35
Lines 37-43 Link Here
37	public void testByteArrayNull() throws Exception	37	public void testByteArrayNull() throws Exception
38	{	38	{
39	// XXX disabled because of Bug 289445	39	// XXX disabled because of Bug 289445
40	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	40	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
41	super.testByteArrayNull();	41	super.testByteArrayNull();
42	}	42	}
43	}	43	}

Line 0 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/HsqldbConfig.java (+153 lines)
		1	/**
		2	* Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Eike Stepper - initial API and implementation
		10	*/
		11	package org.eclipse.emf.cdo.tests.db;
		12
		13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
		14	import org.eclipse.emf.cdo.server.IRepository;
		15	import org.eclipse.emf.cdo.server.IRepository.Props;
		16	import org.eclipse.emf.cdo.tests.db.bundle.OM;
		17	import org.eclipse.emf.cdo.tests.db.verifier.DBStoreVerifier;
		18
		19	import org.eclipse.net4j.db.DBUtil;
		20	import org.eclipse.net4j.db.IDBAdapter;
		21	import org.eclipse.net4j.db.hsqldb.HSQLDBAdapter;
		22	import org.eclipse.net4j.db.hsqldb.HSQLDBDataSource;
		23
		24	import org.eclipse.emf.common.util.WrappedException;
		25
		26	import javax.sql.DataSource;
		27
		28	import java.io.PrintWriter;
		29	import java.sql.Connection;
		30	import java.sql.SQLException;
		31	import java.sql.Statement;
		32	import java.util.ArrayList;
		33	import java.util.Map;
		34
		35	/**
		36	* @author Eike Stepper
		37	*/
		38	public class HsqldbConfig extends DBConfig
		39	{
		40	private static final long serialVersionUID = 1L;
		41
		42	public static boolean USE_VERIFIER = false;
		43
		44	private transient ArrayList<HSQLDBDataSource> dataSources;
		45
		46	public HsqldbConfig(boolean supportingAudits, boolean supportingBranches, IDGenerationLocation idGenerationLocation)
		47	{
		48	super("Hsqldb", supportingAudits, supportingBranches, false, false, idGenerationLocation);
		49	}
		50
		51	@Override
		52	protected IDBAdapter createDBAdapter()
		53	{
		54	return new HSQLDBAdapter();
		55	}
		56
		57	@Override
		58	protected DataSource createDataSource(String repoName)
		59	{
		60	HSQLDBDataSource dataSource = new HSQLDBDataSource();
		61	dataSource.setDatabase("jdbc:hsqldb:mem:" + repoName);
		62	dataSource.setUser("sa");
		63
		64	try
65	{
66	dataSource.setLogWriter(new PrintWriter(System.err));
67	}
68	catch (SQLException ex)
69	{
70	OM.LOG.warn(ex.getMessage());
71	}
72
73	if (dataSources == null)
74	{
75	dataSources = new ArrayList<HSQLDBDataSource>();
76	}
77
78	dataSources.add(dataSource);
79	return dataSource;
80	}
81
82	@Override
83	public void tearDown() throws Exception
84	{
85	try
86	{
87	if (USE_VERIFIER)
88	{
89	IRepository testRepository = getRepository(REPOSITORY_NAME);
90	if (testRepository != null)
91	{
92	getVerifier(testRepository).verify();
93	}
94	}
95	}
96	finally
97	{
98	super.tearDown();
99	}
100	}
101
102	@Override
103	protected void deactivateRepositories()
104	{
105	try
106	{
107	shutDownHsqldb();
108	}
109	catch (SQLException e)
110	{
111	throw new WrappedException(e);
112	}
113	finally
114	{
115	super.deactivateRepositories();
116	}
117	}
118
119	protected DBStoreVerifier getVerifier(IRepository repository)
120	{
121	return new DBStoreVerifier.Audit(repository);
122	}
123
124	private void shutDownHsqldb() throws SQLException
125	{
126	for (HSQLDBDataSource ds : dataSources)
127	{
128	Connection connection = null;
129	Statement statement = null;
130
131	try
132	{
133	connection = ds.getConnection();
134	statement = connection.createStatement();
135	statement.execute("SHUTDOWN");
136	}
137	finally
138	{
139	DBUtil.close(statement);
140	DBUtil.close(connection);
141	}
142	}
143
144	dataSources.clear();
145	}
146
147	@Override
148	protected void initRepositoryProperties(Map<String, String> props)
149	{
150	super.initRepositoryProperties(props);
151	props.put(Props.SUPPORTING_AUDITS, "true");
152	}
153	}

Line 0 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/H2OfflineConfig.java (+141 lines)
		1	/**
		2	* Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Eike Stepper - initial API and implementation
		10	*/
		11	package org.eclipse.emf.cdo.tests.db;
		12
		13	import org.eclipse.emf.cdo.server.IStore;
		14	import org.eclipse.emf.cdo.server.db.CDODBUtil;
		15	import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
		16	import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig.OfflineConfig;
		17
		18	import org.eclipse.net4j.db.DBUtil;
		19	import org.eclipse.net4j.db.IDBAdapter;
		20	import org.eclipse.net4j.db.h2.H2Adapter;
		21	import org.eclipse.net4j.util.WrappedException;
		22	import org.eclipse.net4j.util.container.IPluginContainer;
		23	import org.eclipse.net4j.util.io.IOUtil;
		24	import org.eclipse.net4j.util.io.TMPUtil;
		25
		26	import org.h2.jdbcx.JdbcDataSource;
		27
		28	import javax.sql.DataSource;
		29
		30	import java.io.File;
		31	import java.sql.Connection;
		32	import java.sql.Statement;
		33
		34	/**
		35	* @author Eike Stepper
		36	*/
		37	public class H2OfflineConfig extends OfflineConfig
		38	{
		39	private static final long serialVersionUID = 1L;
		40
		41	private static File reusableFolder;
		42
		43	private static JdbcDataSource defaultDataSource;
		44
		45	public H2OfflineConfig()
		46	{
		47	super("H2Offline");
		48	}
		49
		50	public IStore createStore(String repoName)
		51	{
		52	IMappingStrategy mappingStrategy = createMappingStrategy();
		53	IDBAdapter dbAdapter = createDBAdapter();
		54	DataSource dataSource = createDataSource(repoName);
		55	return CDODBUtil.createStore(mappingStrategy, dbAdapter, DBUtil.createConnectionProvider(dataSource));
		56	}
		57
		58	protected IMappingStrategy createMappingStrategy()
		59	{
		60	return CDODBUtil.createHorizontalMappingStrategy();
		61	}
		62
		63	protected IDBAdapter createDBAdapter()
		64	{
65	return new H2Adapter();
66	}
67
68	protected DataSource createDataSource(String repoName)
69	{
70	if (reusableFolder == null)
71	{
72	reusableFolder = createDBFolder();
73	IOUtil.delete(reusableFolder);
74	}
75
76	if (defaultDataSource == null)
77	{
78	defaultDataSource = new JdbcDataSource();
79	defaultDataSource.setURL("jdbc:h2:" + reusableFolder.getAbsolutePath() + "/h2test");
80	}
81
82	Connection conn = null;
83	Statement stmt = null;
84
85	try
86	{
87	conn = defaultDataSource.getConnection();
88	stmt = conn.createStatement();
89	stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
90	stmt.execute("CREATE SCHEMA " + repoName);
91	}
92	catch (Exception ex)
93	{
94	ex.printStackTrace();
95	}
96	finally
97	{
98	DBUtil.close(conn);
99	DBUtil.close(stmt);
100	}
101
102	JdbcDataSource dataSource = new JdbcDataSource();
103	dataSource.setURL("jdbc:h2:" + reusableFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
104	return dataSource;
105	}
106
107	@Override
108	public void setUp() throws Exception
109	{
110	CDODBUtil.prepareContainer(IPluginContainer.INSTANCE);
111	super.setUp();
112	}
113
114	protected File createDBFolder()
115	{
116	return TMPUtil.createTempFolder("h2_", "_test");
117	}
118
119	protected void tearDownClean(String repoName)
120	{
121	reusableFolder.deleteOnExit();
122	Connection connection = null;
123	Statement stmt = null;
124
125	try
126	{
127	connection = defaultDataSource.getConnection();
128	stmt = connection.createStatement();
129	stmt.execute("DROP SCHEMA " + repoName);
130	}
131	catch (Exception ex)
132	{
133	throw WrappedException.wrap(ex);
134	}
135	finally
136	{
137	DBUtil.close(stmt);
138	DBUtil.close(connection);
139	}
140	}
141	}

Line 0 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/H2Config.java (+104 lines)
		1	/**
		2	* Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Eike Stepper - initial API and implementation
		10	*/
		11	package org.eclipse.emf.cdo.tests.db;
		12
		13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
		14
		15	import org.eclipse.net4j.db.DBUtil;
		16	import org.eclipse.net4j.db.IDBAdapter;
		17	import org.eclipse.net4j.db.h2.H2Adapter;
		18	import org.eclipse.net4j.util.io.IOUtil;
		19	import org.eclipse.net4j.util.io.TMPUtil;
		20
		21	import org.h2.jdbcx.JdbcDataSource;
		22
		23	import javax.sql.DataSource;
		24
		25	import java.io.File;
		26	import java.sql.Connection;
		27	import java.sql.Statement;
		28
		29	/**
		30	* @author Eike Stepper
		31	*/
		32	public class H2Config extends DBConfig
		33	{
		34	private static final long serialVersionUID = 1L;
		35
		36	private static File reusableFolder;
		37
		38	private static JdbcDataSource defaultDataSource;
		39
		40	protected transient File dbFolder;
		41
		42	public H2Config(boolean supportingAudits, boolean supportingBranches, boolean withRanges, boolean copyOnBranch,
		43	IDGenerationLocation idGenerationLocation)
		44	{
		45	super("H2", supportingAudits, supportingBranches, withRanges, copyOnBranch, idGenerationLocation);
		46	}
		47
		48	@Override
		49	protected IDBAdapter createDBAdapter()
		50	{
		51	return new H2Adapter();
		52	}
		53
		54	@Override
		55	protected DataSource createDataSource(String repoName)
		56	{
		57	if (reusableFolder == null)
		58	{
		59	reusableFolder = createDBFolder();
		60	IOUtil.delete(reusableFolder);
		61	}
		62
		63	dbFolder = reusableFolder;
		64	if (defaultDataSource == null)
65	{
66	defaultDataSource = new JdbcDataSource();
67	defaultDataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test");
68	}
69
70	Connection conn = null;
71	Statement stmt = null;
72
73	try
74	{
75	conn = defaultDataSource.getConnection();
76	stmt = conn.createStatement();
77
78	if (!isRestarting())
79	{
80	stmt.execute("DROP SCHEMA IF EXISTS " + repoName);
81	}
82
83	stmt.execute("CREATE SCHEMA IF NOT EXISTS " + repoName);
84	}
85	catch (Exception e)
86	{
87	e.printStackTrace();
88	}
89	finally
90	{
91	DBUtil.close(conn);
92	DBUtil.close(stmt);
93	}
94
95	JdbcDataSource dataSource = new JdbcDataSource();
96	dataSource.setURL("jdbc:h2:" + dbFolder.getAbsolutePath() + "/h2test;SCHEMA=" + repoName);
97	return dataSource;
98	}
99
100	protected File createDBFolder()
101	{
102	return TMPUtil.createTempFolder("h2_", "_test");
103	}
104	}

Line 0 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/PostgresqlConfig.java (+120 lines)
		1	/**
		2	* Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Eike Stepper - initial API and implementation
		10	*/
		11	package org.eclipse.emf.cdo.tests.db;
		12
		13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
		14	import org.eclipse.emf.cdo.tests.db.bundle.OM;
		15
		16	import org.eclipse.net4j.db.DBUtil;
		17	import org.eclipse.net4j.db.IDBAdapter;
		18	import org.eclipse.net4j.db.postgresql.PostgreSQLAdapter;
		19	import org.eclipse.net4j.util.io.IOUtil;
		20
		21	import org.postgresql.jdbc3.Jdbc3SimpleDataSource;
		22
		23	import javax.sql.DataSource;
		24
		25	import java.io.PrintWriter;
		26	import java.sql.Connection;
		27	import java.sql.SQLException;
		28
		29	/**
		30	* @author Victor Roldan Betancort
		31	*/
		32	public class PostgresqlConfig extends DBConfig
		33	{
		34	private static final long serialVersionUID = 1L;
		35
		36	private transient Jdbc3SimpleDataSource dataSource;
		37
		38	private transient Jdbc3SimpleDataSource setupDataSource;
		39
		40	private String currentRepositoryName = "cdodb1";
		41
		42	public PostgresqlConfig(boolean supportingAudits, boolean supportingBranches,
		43	IDGenerationLocation idGenerationLocation)
		44	{
		45	super("Postgresql", supportingAudits, supportingBranches, false, false, idGenerationLocation);
		46	}
		47
		48	@Override
		49	protected IDBAdapter createDBAdapter()
		50	{
		51	return new PostgreSQLAdapter();
		52	}
		53
		54	@Override
		55	protected DataSource createDataSource(String repoName)
		56	{
		57	currentRepositoryName = repoName;
		58
		59	dataSource = new Jdbc3SimpleDataSource();
		60	dataSource.setServerName("localhost");
		61	dataSource.setDatabaseName(currentRepositoryName);
		62	dataSource.setUser("sa");
		63	dataSource.setPassword("sa");
		64
65	try
66	{
67	dataSource.setLogWriter(new PrintWriter(System.err));
68	}
69	catch (SQLException ex)
70	{
71	OM.LOG.warn(ex.getMessage());
72	}
73
74	dropDatabase();
75
76	return dataSource;
77	}
78
79	@Override
80	protected void deactivateRepositories()
81	{
82	super.deactivateRepositories();
83	dataSource = null;
84	setupDataSource = null;
85	dropDatabase();
86	}
87
88	private void dropDatabase()
89	{
90	Connection connection = null;
91
92	try
93	{
94	connection = getSetupDataSource().getConnection();
95	DBUtil.dropAllTables(connection, currentRepositoryName);
96	}
97	catch (SQLException ignore)
98	{
99	IOUtil.ERR().println(ignore);
100	}
101	finally
102	{
103	DBUtil.close(connection);
104	}
105	}
106
107	private DataSource getSetupDataSource()
108	{
109	if (setupDataSource == null)
110	{
111	setupDataSource = new Jdbc3SimpleDataSource();
112	setupDataSource.setServerName("localhost");
113	setupDataSource.setDatabaseName(currentRepositoryName);
114	setupDataSource.setUser("sa");
115	setupDataSource.setPassword("sa");
116	}
117
118	return setupDataSource;
119	}
120	}

Lines 1-7 Link Here

(-)CDO AllTests (H2 audit).launch (-2 / +2 lines)
1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>	1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2	<launchConfiguration type="org.eclipse.jdt.junit.launchconfig">	2	<launchConfiguration type="org.eclipse.jdt.junit.launchconfig">
3	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">	3	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
4	<listEntry value="/org.eclipse.emf.cdo.tests.db/src/org/eclipse/emf/cdo/tests/db/AllTestsDBH2.java"/>	4	<listEntry value="/org.eclipse.emf.cdo.tests.db/src/org/eclipse/emf/cdo/tests/db/AllTestsDBH2Audit.java"/>
5	</listAttribute>	5	</listAttribute>
6	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">	6	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
7	<listEntry value="1"/>	7	<listEntry value="1"/>
Lines 10-16 Link Here
10	<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>	10	<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
11	<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>	11	<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
12	<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit3"/>	12	<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit3"/>
13	<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.cdo.tests.db.AllTestsDBH2"/>	13	<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.cdo.tests.db.AllTestsDBH2Audit"/>
14	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.emf.cdo.tests.db"/>	14	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.emf.cdo.tests.db"/>
15	<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xms40m -Xmx1024m -Dorg.eclipse.net4j.util.om.trace.disable=true"/>	15	<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xms40m -Xmx1024m -Dorg.eclipse.net4j.util.om.trace.disable=true"/>
16	</launchConfiguration>	16	</launchConfiguration>

Lines 68-77 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DBAnnotationsTest.java (-12 / +10 lines)
68	public void testLengthAnnotationNegative() throws Exception	68	public void testLengthAnnotationNegative() throws Exception
69	{	69	{
70	// HSQL does not support length annotations	70	// HSQL does not support length annotations
71	skipConfig(AllTestsDBHsqldb.Hsqldb.INSTANCE);	71	skipTest(getRepositoryConfig() instanceof HsqldbConfig);
72	skipConfig(AllTestsDBHsqldbNonAudit.HsqldbNonAudit.INSTANCE);	72
73	// XXX PSQL fails, too - need to investigate	73	// XXX PSQL fails, too - need to investigate
74	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	74	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
75		75
76	msg("Opening session");	76	msg("Opening session");
77	EPackage model1 = createModel();	77	EPackage model1 = createModel();
Lines 111-117 Link Here
111	public void testLengthAnnotationByMetaData() throws CommitException	111	public void testLengthAnnotationByMetaData() throws CommitException
112	{	112	{
113	// XXX [PSQL] disabled because of Bug 290095	113	// XXX [PSQL] disabled because of Bug 290095
114	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	114	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
115		115
116	msg("Opening session");	116	msg("Opening session");
117	final EPackage model1 = createModel();	117	final EPackage model1 = createModel();
Lines 152-162 Link Here
152	public void testTypeAnnotationByMetaData() throws CommitException	152	public void testTypeAnnotationByMetaData() throws CommitException
153	{	153	{
154	// XXX [PSQL] disabled because of Bug 290095	154	// XXX [PSQL] disabled because of Bug 290095
155	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	155	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
156		156
157	// HSQL does not support type annotations	157	// HSQL does not support type annotations
158	skipConfig(AllTestsDBHsqldb.Hsqldb.INSTANCE);	158	skipTest(getRepositoryConfig() instanceof HsqldbConfig);
159	skipConfig(AllTestsDBHsqldbNonAudit.HsqldbNonAudit.INSTANCE);
160		159
161	msg("Opening session");	160	msg("Opening session");
162	final EPackage model1 = createModel();	161	final EPackage model1 = createModel();
Lines 197-203 Link Here
197	public void testTableNameAnnotationByMetaData() throws CommitException	196	public void testTableNameAnnotationByMetaData() throws CommitException
198	{	197	{
199	// XXX [PSQL] disabled because of Bug 290095	198	// XXX [PSQL] disabled because of Bug 290095
200	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	199	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
201		200
202	msg("Opening session");	201	msg("Opening session");
203	EPackage model1 = createModel();	202	EPackage model1 = createModel();
Lines 237-243 Link Here
237	public void testColumnNameAnnotationByMetaData() throws CommitException	236	public void testColumnNameAnnotationByMetaData() throws CommitException
238	{	237	{
239	// XXX [PSQL] disabled because of Bug 290095	238	// XXX [PSQL] disabled because of Bug 290095
240	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	239	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
241		240
242	msg("Opening session");	241	msg("Opening session");
243	final EPackage model1 = createModel();	242	final EPackage model1 = createModel();
Lines 278-288 Link Here
278	public void testColumnNameTypeAnnotationByMetaData() throws CommitException	277	public void testColumnNameTypeAnnotationByMetaData() throws CommitException
279	{	278	{
280	// HSQL does not support type annotations	279	// HSQL does not support type annotations
281	skipConfig(AllTestsDBHsqldb.Hsqldb.INSTANCE);	280	skipTest(getRepositoryConfig() instanceof HsqldbConfig);
282	skipConfig(AllTestsDBHsqldbNonAudit.HsqldbNonAudit.INSTANCE);
283		281
284	// XXX [PSQL] disabled because of Bug 290095	282	// XXX [PSQL] disabled because of Bug 290095
285	skipConfig(AllTestsDBPsql.Psql.INSTANCE);	283	skipTest(getRepositoryConfig() instanceof PostgresqlConfig);
286		284
287	msg("Opening session");	285	msg("Opening session");
288	final EPackage model1 = createModel();	286	final EPackage model1 = createModel();

Lines 1-76 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DBStoreRepositoryConfig.java (-76 lines)
1	/**
2	* Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Eike Stepper - initial API and implementation
10	*/
11	package org.eclipse.emf.cdo.tests.db;
12
13	import org.eclipse.emf.cdo.server.IStore;
14	import org.eclipse.emf.cdo.server.db.CDODBUtil;
15	import org.eclipse.emf.cdo.server.db.mapping.IMappingStrategy;
16	import org.eclipse.emf.cdo.server.db.mapping.ITypeMapping;
17	import org.eclipse.emf.cdo.server.internal.db.mapping.TypeMappingRegistry;
18	import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;
19
20	import org.eclipse.net4j.db.DBUtil;
21	import org.eclipse.net4j.db.IDBAdapter;
22	import org.eclipse.net4j.util.container.IPluginContainer;
23
24	import javax.sql.DataSource;
25
26	import java.util.HashMap;
27	import java.util.Map;
28
29	/**
30	* @author Eike Stepper
31	*/
32	public abstract class DBStoreRepositoryConfig extends RepositoryConfig
33	{
34	private static final long serialVersionUID = 1L;
35
36	public DBStoreRepositoryConfig(String name)
37	{
38	super(name);
39	}
40
41	@Override
42	public void setUp() throws Exception
43	{
44	CDODBUtil.prepareContainer(IPluginContainer.INSTANCE);
45	super.setUp();
46	((TypeMappingRegistry)ITypeMapping.Registry.INSTANCE).init();
47	}
48
49	@Override
50	protected boolean isOptimizing()
51	{
52	return true;
53	}
54
55	public IStore createStore(String repoName)
56	{
57	IMappingStrategy mappingStrategy = createMappingStrategy();
58	mappingStrategy.setProperties(createMappingStrategyProperties());
59	IDBAdapter dbAdapter = createDBAdapter();
60	DataSource dataSource = createDataSource(repoName);
61	return CDODBUtil.createStore(mappingStrategy, dbAdapter, DBUtil.createConnectionProvider(dataSource));
62	}
63
64	protected Map<String, String> createMappingStrategyProperties()
65	{
66	Map<String, String> props = new HashMap<String, String>();
67	props.put(IMappingStrategy.PROP_QUALIFIED_NAMES, "true");
68	return props;
69	}
70
71	protected abstract IMappingStrategy createMappingStrategy();
72
73	protected abstract IDBAdapter createDBAdapter();
74
75	protected abstract DataSource createDataSource(String repoName);
76	}

Line 0 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/MysqlConfig.java (+159 lines)
		1	/**
		2	* Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Eike Stepper - initial API and implementation
		10	*/
		11	package org.eclipse.emf.cdo.tests.db;
		12
		13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
		14	import org.eclipse.emf.cdo.server.IRepository.Props;
		15
		16	import org.eclipse.net4j.db.DBUtil;
		17	import org.eclipse.net4j.db.IDBAdapter;
		18	import org.eclipse.net4j.db.mysql.MYSQLAdapter;
		19
		20	import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
		21
		22	import javax.sql.DataSource;
		23
		24	import java.sql.Connection;
		25	import java.sql.SQLException;
		26	import java.sql.Statement;
		27	import java.util.ArrayList;
		28	import java.util.List;
		29	import java.util.Map;
		30
		31	/**
		32	* @author Simon McDuff
		33	*/
		34	public class MysqlConfig extends DBConfig
		35	{
		36	private static final long serialVersionUID = 1L;
		37
		38	private transient DataSource setupDataSource;
		39
		40	private transient List<String> databases = new ArrayList<String>();
		41
		42	/**
		43	* Instructions to test with MySQL: - create a mysql instance - set HOST to the host where the DB is running
		44	* (listening on TCP) - set USER to a user who can create and drop databases (root, essentially) - set PASS to the
		45	* password of the said user
		46	*/
		47	public static final String HOST = "localhost";
		48
		49	public static final String USER = "root";
		50
		51	public static final String PASS = "root";
		52
		53	public MysqlConfig(boolean supportingAudits, boolean supportingBranches, IDGenerationLocation idGenerationLocation)
		54	{
		55	super("Mysql", supportingAudits, supportingBranches, false, false, idGenerationLocation);
		56	}
		57
		58	@Override
		59	protected IDBAdapter createDBAdapter()
		60	{
		61	return new MYSQLAdapter();
		62	}
		63
		64	@Override
65	protected DataSource createDataSource(String repoName)
66	{
67	MysqlDataSource ds = new MysqlDataSource();
68
69	initDatabase("test_" + repoName);
70
71	ds.setUrl("jdbc:mysql://" + MysqlConfig.HOST + "/test_" + repoName);
72	ds.setUser(MysqlConfig.USER);
73	if (MysqlConfig.PASS != null)
74	{
75	ds.setPassword(MysqlConfig.PASS);
76	}
77
78	return ds;
79	}
80
81	private void initDatabase(String dbName)
82	{
83	dropDatabase(dbName);
84	Connection connection = null;
85	Statement stmt = null;
86
87	try
88	{
89	connection = getSetupDataSource().getConnection();
90	stmt = connection.createStatement();
91	stmt.execute("create database " + dbName);
92	}
93	catch (SQLException ignore)
94	{
95	}
96	finally
97	{
98	DBUtil.close(stmt);
99	DBUtil.close(connection);
100	}
101	}
102
103	@Override
104	protected void deactivateRepositories()
105	{
106	super.deactivateRepositories();
107	for (String dbName : databases)
108	{
109	dropDatabase(dbName);
110	}
111	}
112
113	private void dropDatabase(String dbName)
114	{
115	Connection connection = null;
116	Statement stmt = null;
117
118	try
119	{
120	connection = getSetupDataSource().getConnection();
121	stmt = connection.createStatement();
122	stmt.execute("DROP database " + dbName);
123	}
124	catch (SQLException ignore)
125	{
126	}
127	finally
128	{
129	DBUtil.close(stmt);
130	DBUtil.close(connection);
131	}
132	}
133
134	private DataSource getSetupDataSource()
135	{
136	if (setupDataSource == null)
137	{
138	MysqlDataSource ds = new MysqlDataSource();
139	ds.setUrl("jdbc:mysql://" + MysqlConfig.HOST);
140	ds.setUser(MysqlConfig.USER);
141	if (MysqlConfig.PASS != null)
142	{
143	ds.setPassword(MysqlConfig.PASS);
144	}
145
146	setupDataSource = ds;
147	}
148
149	return setupDataSource;
150	}
151
152	@Override
153	protected void initRepositoryProperties(Map<String, String> props)
154	{
155	super.initRepositoryProperties(props);
156	props.put(Props.SUPPORTING_AUDITS, "true");
157	props.put(Props.SUPPORTING_BRANCHES, "true");
158	}
159	}

Line 0 Link Here

(-)src/org/eclipse/emf/cdo/tests/db/DerbyConfig.java (+125 lines)
		1	/**
		2	* Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Eike Stepper - initial API and implementation
		10	*/
		11	package org.eclipse.emf.cdo.tests.db;
		12
		13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
		14
		15	import org.eclipse.net4j.db.DBUtil;
		16	import org.eclipse.net4j.db.IDBAdapter;
		17	import org.eclipse.net4j.db.derby.EmbeddedDerbyAdapter;
		18	import org.eclipse.net4j.util.WrappedException;
		19	import org.eclipse.net4j.util.io.IOUtil;
		20	import org.eclipse.net4j.util.io.TMPUtil;
		21
		22	import org.apache.derby.jdbc.EmbeddedDataSource;
		23
		24	import javax.sql.DataSource;
		25
		26	import java.io.File;
		27	import java.sql.Connection;
		28	import java.util.Collection;
		29	import java.util.HashMap;
		30
		31	/**
		32	* @author Eike Stepper
		33	*/
		34	public class DerbyConfig extends DBConfig
		35	{
		36	private static final long serialVersionUID = 1L;
		37
		38	private static HashMap<String, File> dbFolders = new HashMap<String, File>();
		39
		40	private static HashMap<File, EmbeddedDataSource> dataSources = new HashMap<File, EmbeddedDataSource>();
		41
		42	public DerbyConfig(boolean supportingAudits, boolean supportingBranches, IDGenerationLocation idGenerationLocation)
		43	{
		44	super("Derby", supportingAudits, supportingBranches, false, false, idGenerationLocation);
		45	}
		46
		47	public Collection<File> getDBFolders()
		48	{
		49	return dbFolders.values();
		50	}
		51
		52	@Override
		53	protected IDBAdapter createDBAdapter()
		54	{
		55	return new EmbeddedDerbyAdapter();
		56	}
		57
		58	@Override
		59	protected DataSource createDataSource(String repoName)
		60	{
		61	File reusableFolder = dbFolders.get(repoName);
		62
		63	boolean needsNewFolder = reusableFolder == null;
		64	if (needsNewFolder)
65	{
66	reusableFolder = createDBFolder(repoName);
67	IOUtil.delete(reusableFolder);
68	dbFolders.put(repoName, reusableFolder);
69	}
70
71	EmbeddedDataSource dataSource = new EmbeddedDataSource();
72	dataSource.setDatabaseName(reusableFolder.getAbsolutePath());
73	dataSource.setCreateDatabase("create");
74	dataSources.put(reusableFolder, dataSource);
75
76	if (!needsNewFolder)
77	{
78	tearDownClean(reusableFolder);
79	}
80
81	return dataSource;
82	}
83
84	@Override
85	protected void deactivateRepositories()
86	{
87	for (File folder : getDBFolders())
88	{
89	tearDownClean(folder);
90	}
91
92	super.deactivateRepositories();
93	}
94
95	protected void tearDownClean(File folder)
96	{
97	folder.deleteOnExit();
98	Connection connection = null;
99
100	EmbeddedDataSource dataSource = dataSources.get(folder);
101
102	try
103	{
104	connection = dataSource.getConnection();
105	DBUtil.dropAllTables(connection, dataSource.getDatabaseName());
106	}
107	catch (RuntimeException ex)
108	{
109	throw ex;
110	}
111	catch (Exception ex)
112	{
113	throw WrappedException.wrap(ex);
114	}
115	finally
116	{
117	DBUtil.close(connection);
118	}
119	}
120
121	protected File createDBFolder(String repo)
122	{
123	return TMPUtil.createTempFolder("derby_" + repo + "_", "_test");
124	}
125	}

Line 0 Link Here

(-)CDO AllTests (H2 ALL).launch (+16 lines)
	1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
	2	<launchConfiguration type="org.eclipse.jdt.junit.launchconfig">
	3	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
	4	<listEntry value="/org.eclipse.emf.cdo.tests.db/src/org/eclipse/emf/cdo/tests/db/AllTestsDBH2All.java"/>
	5	</listAttribute>
	6	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
	7	<listEntry value="1"/>
	8	</listAttribute>
	9	<stringAttribute key="org.eclipse.jdt.junit.CONTAINER" value=""/>
	10	<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
	11	<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
	12	<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit3"/>
	13	<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.cdo.tests.db.AllTestsDBH2All"/>
	14	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.emf.cdo.tests.db"/>
	15	<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xms40m -Xmx1024m -Dorg.eclipse.net4j.util.om.trace.disable=true"/>
	16	</launchConfiguration>

Lines 1-118 Link Here

(-)src/org/eclipse/emf/cdo/tests/mongodb/MongoDBStoreRepositoryConfig.java (-118 lines)
1	/**
2	* Copyright (c) 2004 - 2011 Eike Stepper (Berlin, Germany) and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Eike Stepper - initial API and implementation
10	*/
11	package org.eclipse.emf.cdo.tests.mongodb;
12
13	import org.eclipse.emf.cdo.server.CDOServerBrowser;
14	import org.eclipse.emf.cdo.server.IRepository;
15	import org.eclipse.emf.cdo.server.IStore;
16	import org.eclipse.emf.cdo.server.internal.mongodb.MongoDBStore;
17	import org.eclipse.emf.cdo.server.mongodb.CDOMongoDBUtil;
18	import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;
19
20	import org.eclipse.net4j.util.WrappedException;
21	import org.eclipse.net4j.util.container.IPluginContainer;
22
23	import com.mongodb.DB;
24	import com.mongodb.Mongo;
25	import com.mongodb.MongoURI;
26
27	import java.util.Map;
28
29	/**
30	* @author Eike Stepper
31	*/
32	public class MongoDBStoreRepositoryConfig extends RepositoryConfig
33	{
34	public static final MongoDBStoreRepositoryConfig INSTANCE = new MongoDBStoreRepositoryConfig(false, false);
35
36	public static final MongoDBStoreRepositoryConfig AUDITING = new MongoDBStoreRepositoryConfig(true, false);
37
38	public static final MongoDBStoreRepositoryConfig BRANCHING = new MongoDBStoreRepositoryConfig(true, true);
39
40	private static final long serialVersionUID = 1L;
41
42	private boolean auditing;
43
44	private boolean branching;
45
46	private transient CDOServerBrowser mongoBrowser;
47
48	public MongoDBStoreRepositoryConfig(boolean auditing, boolean branching)
49	{
50	super("MongoDBStore" + (branching ? " (branching)" : auditing ? " (auditing)" : ""));
51	this.auditing = auditing;
52	this.branching = branching;
53	}
54
55	@Override
56	public void setUp() throws Exception
57	{
58	CDOMongoDBUtil.prepareContainer(IPluginContainer.INSTANCE);
59
60	mongoBrowser = new CDOServerBrowser(MongoDBStore.REPOS);
61	mongoBrowser.setPort(7778);
62	mongoBrowser.activate();
63
64	super.setUp();
65	}
66
67	@Override
68	public void tearDown() throws Exception
69	{
70	mongoBrowser.deactivate();
71	super.tearDown();
72	}
73
74	public IStore createStore(String repoName)
75	{
76	MongoURI mongoURI = new MongoURI("mongodb://localhost");
77	if (!isRestarting())
78	{
79	dropDatabase(mongoURI, repoName);
80	}
81
82	return CDOMongoDBUtil.createStore(mongoURI.toString(), repoName);
83	}
84
85	protected void dropDatabase(MongoURI mongoURI, String repoName)
86	{
87	Mongo mongo = null;
88
89	try
90	{
91	mongo = new Mongo(mongoURI);
92	DB db = mongo.getDB(repoName);
93	if (!db.getCollectionNames().isEmpty())
94	{
95	db.dropDatabase();
96	}
97	}
98	catch (Exception ex)
99	{
100	throw WrappedException.wrap(ex);
101	}
102	finally
103	{
104	if (mongo != null)
105	{
106	mongo.close();
107	}
108	}
109	}
110
111	@Override
112	protected void initRepositoryProperties(Map<String, String> props)
113	{
114	super.initRepositoryProperties(props);
115	props.put(IRepository.Props.SUPPORTING_AUDITS, Boolean.toString(auditing));
116	props.put(IRepository.Props.SUPPORTING_BRANCHES, Boolean.toString(branching));
117	}
118	}

Lines 10-16 Link Here

(-)src/org/eclipse/emf/cdo/tests/objectivity/SampleTestsObjy.java (-44 / +3 lines)
10	*/	10	*/
11	package org.eclipse.emf.cdo.tests.objectivity;	11	package org.eclipse.emf.cdo.tests.objectivity;
12		12
13	import org.eclipse.emf.cdo.server.IRepository;
14	import org.eclipse.emf.cdo.tests.BranchingWithCacheClearTest;	13	import org.eclipse.emf.cdo.tests.BranchingWithCacheClearTest;
15	import org.eclipse.emf.cdo.tests.InitialTest;	14	import org.eclipse.emf.cdo.tests.InitialTest;
16	import org.eclipse.emf.cdo.tests.MergingTest;	15	import org.eclipse.emf.cdo.tests.MergingTest;
Lines 19-28 Link Here
19	import org.eclipse.emf.cdo.tests.RevisionDeltaInBranchTest;	18	import org.eclipse.emf.cdo.tests.RevisionDeltaInBranchTest;
20	import org.eclipse.emf.cdo.tests.UnsetTest;	19	import org.eclipse.emf.cdo.tests.UnsetTest;
21	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;	20	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;
		21	import org.eclipse.emf.cdo.tests.config.IScenario;
22	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	22	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
23		23
24	import java.util.List;	24	import java.util.List;
25	import java.util.Map;
26		25
27	import junit.framework.Test;	26	import junit.framework.Test;
28	import junit.framework.TestSuite;	27	import junit.framework.TestSuite;
Lines 40-55 Link Here
40	@Override	39	@Override
41	protected void initConfigSuites(TestSuite parent)	40	protected void initConfigSuites(TestSuite parent)
42	{	41	{
43	ObjyStoreRepositoryConfig repConfig = ObjySampleConfig.INSTANCE;	42	addScenario(parent, COMBINED, new ObjyConfig(false, false), JVM, NATIVE);
44	addScenario(parent, COMBINED, repConfig, JVM, NATIVE);
45	}	43	}
46		44
47	@Override	45	@Override
48	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	46	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
49	{	47	{
50	// super.initTestClasses(testClasses);
51	// testClasses.remove(XATransactionTest.class);
52
53	testClasses.clear();	48	testClasses.clear();
54		49
55	// testClasses.add(ComplexTest.class);	50	// testClasses.add(ComplexTest.class);
Lines 110-149 Link Here
110	// testClasses.add(Bugzilla_259949_Test.class);	105	// testClasses.add(Bugzilla_259949_Test.class);
111	testClasses.add(Bugzilla_261218_Test.class);	106	testClasses.add(Bugzilla_261218_Test.class);
112	}	107	}
113
114	@Override
115	protected boolean hasBranchingSupport()
116	{
117	return true;
118	}
119
120	@Override
121	protected boolean hasAuditSupport()
122	{
123	return true;
124	}
125
126	public static class ObjySampleConfig extends ObjyStoreRepositoryConfig
127	{
128	private static final long serialVersionUID = 1L;
129
130	public static final SampleTestsObjy.ObjySampleConfig INSTANCE = new ObjySampleConfig("ObjectivityStore: (sample)"); //$NON-NLS-1$
131
132	public ObjySampleConfig(String name)
133	{
134	super(name);
135
136	org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.DEBUG.setEnabled(true);
137	org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM.INFO.setEnabled(true);
138	}
139
140	@Override
141	protected void initRepositoryProperties(Map<String, String> props)
142	{
143	super.initRepositoryProperties(props);
144	props.put(IRepository.Props.SUPPORTING_AUDITS, "true");
145	props.put(IRepository.Props.SUPPORTING_BRANCHES, "true");
146	}
147	}
148
149	}	108	}

Lines 10-35 Link Here

(-)src/org/eclipse/emf/cdo/tests/db4o/AllTestsDB4O.java (-95 / +9 lines)
10	*/	10	*/
11	package org.eclipse.emf.cdo.tests.db4o;	11	package org.eclipse.emf.cdo.tests.db4o;
12		12
13	import org.eclipse.emf.cdo.server.IRepository;
14	import org.eclipse.emf.cdo.server.IStore;
15	import org.eclipse.emf.cdo.server.internal.db4o.DB4OStore;
16	import org.eclipse.emf.cdo.tests.AllConfigs;	13	import org.eclipse.emf.cdo.tests.AllConfigs;
17	import org.eclipse.emf.cdo.tests.BranchingSameSessionTest;	14	import org.eclipse.emf.cdo.tests.BranchingSameSessionTest;
18	import org.eclipse.emf.cdo.tests.BranchingTest;	15	import org.eclipse.emf.cdo.tests.BranchingTest;
19	import org.eclipse.emf.cdo.tests.BranchingWithCacheClearTest;	16	import org.eclipse.emf.cdo.tests.BranchingWithCacheClearTest;
20	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;	17	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;
21	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_324585_Test;	18	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_324585_Test;
		19	import org.eclipse.emf.cdo.tests.config.IScenario;
22	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	20	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
23	import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;
24
25	import org.eclipse.net4j.util.io.TMPUtil;
26		21
27	import java.io.File;
28	import java.io.IOException;
29	import java.net.ServerSocket;
30	import java.util.List;	22	import java.util.List;
31	import java.util.Map;
32	import java.util.Random;
33		23
34	import junit.framework.Test;	24	import junit.framework.Test;
35	import junit.framework.TestSuite;	25	import junit.framework.TestSuite;
Lines 45-53 Link Here
45	}	35	}
46		36
47	@Override	37	@Override
48	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	38	protected void initConfigSuites(TestSuite parent)
		39	{
		40	addScenario(parent, COMBINED, new DB4OConfig(false), JVM, NATIVE);
		41	}
		42
		43	@Override
		44	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
49	{	45	{
50	super.initTestClasses(testClasses);	46	super.initTestClasses(testClasses, scenario);
51		47
52	// Added here testcases to skip	48	// Added here testcases to skip
53	// takes too much	49	// takes too much
Lines 59-144 Link Here
59	testClasses.remove(BranchingSameSessionTest.class);	55	testClasses.remove(BranchingSameSessionTest.class);
60	testClasses.remove(BranchingWithCacheClearTest.class);	56	testClasses.remove(BranchingWithCacheClearTest.class);
61	}	57	}
62
63	@Override
64	protected void initConfigSuites(TestSuite parent)
65	{
66	addScenario(parent, COMBINED, DB4ORepositoryConfig.INSTANCE, JVM, NATIVE);
67	}
68
69	/**
70	* @author Victor Roldan Betancort
71	*/
72	public static class DB4ORepositoryConfig extends RepositoryConfig
73	{
74	private static final Random RANDOM = new Random(System.currentTimeMillis());
75
76	public static final DB4ORepositoryConfig INSTANCE = new DB4ORepositoryConfig("DB4O");
77
78	private static final long serialVersionUID = 1L;
79
80	private transient boolean optimizing = true;
81
82	public DB4ORepositoryConfig(String name)
83	{
84	super(name);
85	}
86
87	@Override
88	protected void initRepositoryProperties(Map<String, String> props)
89	{
90	super.initRepositoryProperties(props);
91	props.put(IRepository.Props.SUPPORTING_AUDITS, "false");
92	props.put(IRepository.Props.SUPPORTING_BRANCHES, "false");
93	}
94
95	public IStore createStore(String repoName)
96	{
97	File tempFolder = TMPUtil.getTempFolder();
98	File file = new File(tempFolder, "cdodb_" + repoName + ".db4o");
99	if (file.exists() && !isRestarting())
100	{
101	file.delete();
102	}
103
104	int port = 0;
105	boolean ok = false;
106	do
107	{
108	ServerSocket sock = null;
109	try
110	{
111	port = 1024 + RANDOM.nextInt(65536 - 1024);
112	sock = new ServerSocket(port);
113	ok = true;
114	}
115	catch (IOException e)
116	{
117	}
118	finally
119	{
120	try
121	{
122	if (sock != null)
123	{
124	sock.close();
125	}
126	}
127	catch (IOException e)
128	{
129	}
130	}
131	} while (!ok);
132
133	IStore store = new DB4OStore(file.getPath(), port);
134	return store;
135	}
136
137	@Override
138	protected boolean isOptimizing()
139	{
140	// Do NOT replace this with a hardcoded value!
141	return optimizing;
142	}
143	}
144	}	58	}

Line 0 Link Here

(-)src/org/eclipse/emf/cdo/tests/db4o/DB4OConfig.java (+97 lines)
		1	package org.eclipse.emf.cdo.tests.db4o;
		2
		3	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
		4	import org.eclipse.emf.cdo.server.IStore;
		5	import org.eclipse.emf.cdo.server.internal.db4o.DB4OStore;
		6	import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;
		7
		8	import org.eclipse.net4j.util.io.TMPUtil;
		9
		10	import java.io.File;
		11	import java.io.IOException;
		12	import java.net.ServerSocket;
		13	import java.util.Random;
		14
		15	/**
		16	* @author Victor Roldan Betancort
		17	*/
		18	public class DB4OConfig extends RepositoryConfig
		19	{
		20	private static final Random RANDOM = new Random(System.currentTimeMillis());
		21
		22	private static final long serialVersionUID = 1L;
		23
		24	private boolean mem;
		25
		26	private transient boolean optimizing = true;
		27
		28	public DB4OConfig(boolean mem)
		29	{
		30	super("DB4O", false, false, IDGenerationLocation.STORE);
		31	this.mem = mem;
		32	}
		33
		34	public boolean isMem()
		35	{
		36	return mem;
		37	}
		38
		39	public IStore createStore(String repoName)
		40	{
		41	if (mem)
		42	{
		43	if (!isRestarting())
		44	{
		45	MEMDB4OStore.clearContainer();
		46	}
		47
		48	return new MEMDB4OStore();
		49	}
		50
		51	File tempFolder = TMPUtil.getTempFolder();
		52	File file = new File(tempFolder, "cdodb_" + repoName + ".db4o");
		53	if (file.exists() && !isRestarting())
		54	{
		55	file.delete();
		56	}
		57
		58	int port = 0;
		59	boolean ok = false;
		60	do
		61	{
		62	ServerSocket sock = null;
		63
		64	try
65	{
66	port = 1024 + RANDOM.nextInt(65536 - 1024);
67	sock = new ServerSocket(port);
68	ok = true;
69	}
70	catch (IOException e)
71	{
72	}
73	finally
74	{
75	try
76	{
77	if (sock != null)
78	{
79	sock.close();
80	}
81	}
82	catch (IOException e)
83	{
84	}
85	}
86	} while (!ok);
87
88	return new DB4OStore(file.getPath(), port);
89	}
90
91	@Override
92	protected boolean isOptimizing()
93	{
94	// Do NOT replace this with a hardcoded value!
95	return optimizing;
96	}
97	}

Lines 1-7 Link Here

(-)CDO AllTests (MEMDB4O).launch (-2 / +2 lines)
1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>	1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
2	<launchConfiguration type="org.eclipse.jdt.junit.launchconfig">	2	<launchConfiguration type="org.eclipse.jdt.junit.launchconfig">
3	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">	3	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
4	<listEntry value="/org.eclipse.emf.cdo.tests.db4o/src/org/eclipse/emf/cdo/tests/db4o/AllTestsMEMDB4O.java"/>	4	<listEntry value="/org.eclipse.emf.cdo.tests.db4o/src/org/eclipse/emf/cdo/tests/db4o/AllTestsDB4OMem.java"/>
5	</listAttribute>	5	</listAttribute>
6	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">	6	<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
7	<listEntry value="1"/>	7	<listEntry value="1"/>
Lines 10-16 Link Here
10	<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>	10	<booleanAttribute key="org.eclipse.jdt.junit.KEEPRUNNING_ATTR" value="false"/>
11	<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>	11	<stringAttribute key="org.eclipse.jdt.junit.TESTNAME" value=""/>
12	<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>	12	<stringAttribute key="org.eclipse.jdt.junit.TEST_KIND" value="org.eclipse.jdt.junit.loader.junit4"/>
13	<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.cdo.tests.db4o.AllTestsMEMDB4O"/>	13	<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.cdo.tests.db4o.AllTestsDB4OMem"/>
14	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.emf.cdo.tests.db4o"/>	14	<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.emf.cdo.tests.db4o"/>
15	<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-XX:MaxPermSize=128m -Xmx1024m"/>	15	<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-XX:MaxPermSize=128m -Xmx1024m"/>
16	</launchConfiguration>	16	</launchConfiguration>

Lines 44-49 Link Here

(-)src/org/eclipse/emf/cdo/tests/hibernate/AllTestsHibernate.java (-2 / +3 lines)
44	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_316444_Test;	44	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_316444_Test;
45	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_319836_Test;	45	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_319836_Test;
46	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_322804_Test;	46	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_322804_Test;
		47	import org.eclipse.emf.cdo.tests.config.IScenario;
47	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	48	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
48	import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;	49	import org.eclipse.emf.cdo.tests.config.impl.RepositoryConfig;
49	import org.eclipse.emf.cdo.util.CommitException;	50	import org.eclipse.emf.cdo.util.CommitException;
Lines 72-78 Link Here
72	}	73	}
73		74
74	@Override	75	@Override
75	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses)	76	protected void initTestClasses(List<Class<? extends ConfigTest>> testClasses, IScenario scenario)
76	{	77	{
77	// testClasses.clear();	78	// testClasses.clear();
78	// testClasses.add(XRefTest.class);	79	// testClasses.add(XRefTest.class);
Lines 100-106 Link Here
100	testClasses.add(Hibernate_PartialCommitTest.class);	101	testClasses.add(Hibernate_PartialCommitTest.class);
101	testClasses.add(Hibernate_Bugzilla_316444_Test.class);	102	testClasses.add(Hibernate_Bugzilla_316444_Test.class);
102		103
103	super.initTestClasses(testClasses);	104	super.initTestClasses(testClasses, scenario);
104		105
105	// Teneo does not yet support lists of int arrays:	106	// Teneo does not yet support lists of int arrays:
106	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=330212	107	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=330212

Lines 10-16 Link Here

(-)src/org/eclipse/emf/cdo/tests/hibernate/HibernateConfig.java (-4 / +2 lines)
10	*/	10	*/
11	package org.eclipse.emf.cdo.tests.hibernate;	11	package org.eclipse.emf.cdo.tests.hibernate;
12		12
13	import org.eclipse.emf.cdo.server.IRepository.Props;	13	import org.eclipse.emf.cdo.common.CDOCommonRepository.IDGenerationLocation;
14	import org.eclipse.emf.cdo.server.IStore;	14	import org.eclipse.emf.cdo.server.IStore;
15	import org.eclipse.emf.cdo.server.hibernate.CDOHibernateUtil;	15	import org.eclipse.emf.cdo.server.hibernate.CDOHibernateUtil;
16	import org.eclipse.emf.cdo.server.hibernate.IHibernateMappingProvider;	16	import org.eclipse.emf.cdo.server.hibernate.IHibernateMappingProvider;
Lines 38-52 Link Here
38		38
39	public HibernateConfig()	39	public HibernateConfig()
40	{	40	{
41	super("Hibernate");	41	super("Hibernate", false, false, IDGenerationLocation.STORE);
42	}	42	}
43		43
44	@Override	44	@Override
45	protected void initRepositoryProperties(Map<String, String> props)	45	protected void initRepositoryProperties(Map<String, String> props)
46	{	46	{
47	super.initRepositoryProperties(props);	47	super.initRepositoryProperties(props);
48	props.put(Props.SUPPORTING_AUDITS, "false");
49	props.put(Props.SUPPORTING_BRANCHES, "false");
50		48
51	try	49	try
52	{	50	{

Lines 12-17 Link Here

(-)src/org/eclipse/emf/cdo/server/internal/db/mapping/horizontal/HorizontalBranchingMappingStrategyWithRanges.java (-3 / +2 lines)
12	*/	12	*/
13	package org.eclipse.emf.cdo.server.internal.db.mapping.horizontal;	13	package org.eclipse.emf.cdo.server.internal.db.mapping.horizontal;
14		14
		15	import org.eclipse.emf.cdo.server.db.CDODBUtil;
15	import org.eclipse.emf.cdo.server.db.mapping.IClassMapping;	16	import org.eclipse.emf.cdo.server.db.mapping.IClassMapping;
16	import org.eclipse.emf.cdo.server.db.mapping.IListMapping;	17	import org.eclipse.emf.cdo.server.db.mapping.IListMapping;
17	import org.eclipse.emf.cdo.server.internal.db.CDODBSchema;	18	import org.eclipse.emf.cdo.server.internal.db.CDODBSchema;
Lines 25-32 Link Here
25	*/	26	*/
26	public class HorizontalBranchingMappingStrategyWithRanges extends AbstractHorizontalMappingStrategy	27	public class HorizontalBranchingMappingStrategyWithRanges extends AbstractHorizontalMappingStrategy
27	{	28	{
28	private static final String PROP_COPY_ON_BRANCH = "copyOnBranch";
29
30	private boolean copyOnBranch;	29	private boolean copyOnBranch;
31		30
32	public HorizontalBranchingMappingStrategyWithRanges()	31	public HorizontalBranchingMappingStrategyWithRanges()
Lines 90-96 Link Here
90	{	89	{
91	super.doAfterActivate();	90	super.doAfterActivate();
92		91
93	String value = getProperties().get(PROP_COPY_ON_BRANCH);	92	String value = getProperties().get(CDODBUtil.PROP_COPY_ON_BRANCH);
94	copyOnBranch = value == null ? false : Boolean.valueOf(value);	93	copyOnBranch = value == null ? false : Boolean.valueOf(value);
95	}	94	}
96	}	95	}