teiid SVN: r1325 - in trunk/test-integration/db/src/main/java/org/teiid/test: framework/connection and 4 other directories.
by teiid-commits＠lists.jboss.org
Author: vhalbert(a)redhat.com
Date: 2009-09-11 15:18:01 -0400 (Fri, 11 Sep 2009)
New Revision: 1325
Added:
trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/DataSourceSetup.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategyFactory.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionUtil.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DataSourceConnection.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DriverConnection.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/JEEConnection.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DatasourceMgr.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/QueryTestFailedException.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/TransactionRuntimeException.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/JNDITransaction.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/TransactionFactory.java
trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/XATransaction.java
trunk/test-integration/db/src/main/java/org/teiid/test/util/ArgCheck.java
trunk/test-integration/db/src/main/java/org/teiid/test/util/ChecksumUtil.java
trunk/test-integration/db/src/main/java/org/teiid/test/util/FileUtils.java
trunk/test-integration/db/src/main/java/org/teiid/test/util/PropUtils.java
trunk/test-integration/db/src/main/java/org/teiid/test/util/StringUtil.java
Log:
Teiid 773 - organize integration test
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,61 @@
+package org.teiid.test.framework;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+import org.teiid.test.framework.connection.ConnectionStrategyFactory;
+
+public class ConfigPropertyLoader {
+ /**
+ * Specify this property to set a specific configuration to use
+ */
+ public static final String CONFIG_FILE="config";
+
+ /**
+ * The default config file to use when #CONFIG_FILE system property isn't set
+ */
+ private static final String DEFAULT_CONFIG_FILE_NAME="default-config.properties";
+
+ public static Properties loadConfigurationProperties() {
+ return loadConfiguration();
+ }
+
+ private static Properties loadConfiguration() {
+ String filename = System.getProperty(CONFIG_FILE);
+ if (filename == null) {
+ filename = DEFAULT_CONFIG_FILE_NAME;
+ }
+
+ return loadProperties(filename);
+
+ }
+
+ private static Properties loadProperties(String filename) {
+ Properties props = null;
+ try {
+ InputStream in = ConnectionStrategyFactory.class.getResourceAsStream("/"+ filename);
+ if (in != null) {
+ props = new Properties();
+ props.load(in);
+ return props;
+ }
+ else {
+ throw new RuntimeException("Failed to load properties from file '"+filename+ "' configuration file");
+ }
+ } catch (IOException e) {
+ throw new RuntimeException("Error loading properties from file '"+filename+ "'" + e.getMessage());
+ }
+ }
+
+ public static void main(String[] args) {
+ Properties props = ConfigPropertyLoader.loadConfigurationProperties();
+ if (props == null || props.isEmpty()) {
+ throw new RuntimeException("Failed to load config properties file");
+
+ }
+ System.out.println("Loaded Config Properties " + props.toString());
+
+ }
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/ConfigPropertyLoader.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/DataSourceSetup.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/DataSourceSetup.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/DataSourceSetup.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,11 @@
+package org.teiid.test.framework;
+
+public interface DataSourceSetup {
+
+
+ void setup() throws Exception;
+
+
+ int getDataSourceCnt();
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/DataSourceSetup.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework;
+
+import java.sql.Connection;
+import java.util.Properties;
+
+import javax.sql.XAConnection;
+
+import org.teiid.test.framework.datasource.DatasourceMgr;
+import org.teiid.test.framework.exception.QueryTestFailedException;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+import org.teiid.test.framework.connection.ConnectionStrategy;
+
+
+
+
+public abstract class TransactionContainer {
+
+ private boolean debug = false;
+
+ protected Properties props;
+ protected ConnectionStrategy connStrategy;
+
+ protected TransactionContainer(ConnectionStrategy strategy){
+ this.connStrategy = strategy;
+ this.props = new Properties();
+ this.props.putAll(this.connStrategy.getEnvironment());
+
+ }
+
+
+ /**
+ * Returns <code>true</code> if the test <b>CANNOT</b> be run due to not have the right
+ * number of datasources available.
+ *
+ */
+ protected boolean turnOffTest (int numberofDataSources) {
+ boolean rtn = (numberofDataSources > DatasourceMgr.getInstance().numberOfAvailDataSources());
+ if (rtn) {
+ System.out.println("Required Number of DataSources is " + numberofDataSources + " but availables sources is " + DatasourceMgr.getInstance().numberOfAvailDataSources());
+ }
+ return rtn;
+ }
+
+ protected void before(TransactionQueryTest test){}
+
+ protected void after(TransactionQueryTest test) {}
+
+ public void runTransaction(TransactionQueryTest test) {
+
+ if (turnOffTest(test.getNumberRequiredDataSources())) {
+ detail("Transaction test: " + test.getTestName() + " will not be run");
+ return;
+
+ }
+
+ detail("Start transaction test: " + test.getTestName());
+
+ try {
+ test.setupDataSource();
+
+ debug(" setConnection");
+ test.setConnection(getConnection());
+ test.setExecutionProperties(this.props);
+ debug(" before(test)");
+
+ before(test);
+ debug(" test.before");
+
+ test.before();
+
+ debug(" test.testcase");
+
+ // run the test
+ test.testCase();
+
+ }catch(Throwable e) {
+ if (!test.exceptionExpected()) {
+ e.printStackTrace();
+ }
+ throw new TransactionRuntimeException(e.getMessage());
+ }finally {
+ debug(" test.after");
+
+ test.after();
+ debug(" after(test)");
+
+ after(test);
+ debug(" test.cleanup");
+
+ test.cleanup();
+
+ detail("End transaction test: " + test.getTestName());
+
+ }
+
+ try {
+ detail("Start validation: " + test.getTestName());
+
+ test.validateTestCase();
+
+ detail("End validation: " + test.getTestName());
+
+ }catch(Exception e) {
+ throw new TransactionRuntimeException(e);
+ }
+ }
+
+
+ protected Connection getConnection() throws QueryTestFailedException {
+ return this.connStrategy.getConnection();
+ }
+
+ protected XAConnection getXAConnection() throws QueryTestFailedException {
+ return this.connStrategy.getXAConnection();
+ }
+
+
+ public Properties getEnvironmentProperties() {
+ return props;
+ }
+
+ protected void debug(String message) {
+ if (debug) {
+ System.out.println(message);
+ }
+
+ }
+
+ protected void detail(String message) {
+ System.out.println(message);
+ }
+
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionContainer.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,131 @@
+package org.teiid.test.framework;
+
+import java.sql.Connection;
+import java.util.Properties;
+
+import javax.sql.XAConnection;
+
+/**
+ * The TransactionQueryTest interface represents the transaction test framework from which
+ * the @link TransactionContainer operates.
+ * @author vanhalbert
+ *
+ */
+
+public interface TransactionQueryTest {
+
+ /**
+ * Returns the name of the test so that better tracing of what tests are running/completing.
+ * @return String is test name
+ */
+ String getTestName();
+
+ /**
+ * Called by the @link TransactionContainer to set the Teiid connection to be used in the test.
+ * @param conn
+ *
+ * @since
+ */
+ void setConnection(Connection conn);
+
+
+ /**
+ * Returns the connection being used in the test.
+ * @return
+ *
+ * @since
+ */
+ Connection getConnection();
+
+ XAConnection getXAConnection();
+
+
+ /**
+ * Called to set the properties used to initialize prior
+ * to execution.
+ * @param props
+ *
+ * @since
+ */
+ void setExecutionProperties(Properties props) ;
+
+ /**
+ * The test case has to specify how many sources its using so that the correct
+ * data setup is performed.
+ * @return int is the number of datasources in use
+ *
+ * @since
+ */
+
+ int getNumberRequiredDataSources();
+
+ /**
+ * Called by the {@link TransactionContainer} prior to testcase processing so that
+ * the datasource data can be setup for the specific testcase.
+ *
+ *
+ * @since
+ */
+ void setupDataSource();
+
+
+ /**
+ * Override <code>before</code> if there is behavior that needs to be performed
+ * prior to {@link #testCase()} being called.
+ *
+ *
+ * @since
+ */
+ void before();
+
+ /**
+ * Implement testCase(), it is the entry point to the execution of the test.
+ * @throws Exception
+ *
+ * @since
+ */
+ void testCase() throws Exception;
+
+
+ /**
+ * Override <code>after</code> if there is behavior that needs to be performed
+ * after {@link #testCase()} being called.
+ *
+ *
+ * @since
+ */
+ void after() ;
+
+ /**
+ * Indicates what should be done when a failure occurs in {@link #testCase()}
+ * @return
+ *
+ * @since
+ */
+ boolean rollbackAllways() ;
+
+ boolean exceptionExpected();
+
+ boolean exceptionOccurred();
+
+
+ /**
+ * Called at the end of the test so that the testcase can clean itself up by
+ * releasing any resources, closing any open connections, etc.
+ *
+ *
+ * @since
+ */
+ void cleanup();
+
+ /**
+ * validateTestCase is called after the testcase has been completed. This enables
+ * the validation to be performed as part of the overall testcase.
+ * @throws Exception
+ *
+ * @since
+ */
+ void validateTestCase() throws Exception;
+
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/TransactionQueryTest.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.connection;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Properties;
+
+import javax.sql.XAConnection;
+
+import org.teiid.test.framework.datasource.DataSource;
+import org.teiid.test.framework.datasource.DatasourceMgr;
+import org.teiid.adminapi.Admin;
+import org.teiid.adminapi.AdminOptions;
+import org.teiid.adminapi.ConnectorBinding;
+import org.teiid.adminapi.Model;
+import org.teiid.adminapi.VDB;
+import org.teiid.connector.jdbc.JDBCPropertyNames;
+import org.teiid.test.framework.exception.QueryTestFailedException;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+
+
+
+public abstract class ConnectionStrategy {
+ /**
+ * Connection Type indicates the type of connection (strategy) to use
+ */
+ public static final String CONNECTION_TYPE = "connection-type"; //$NON-NLS-1$
+
+ /**
+ * The connection types that map to connection strategies
+ * ****************************************************************
+ */
+ // used to create the jdb driver
+ public static final String DRIVER_CONNECTION = "driver"; //$NON-NLS-1$
+ // used to create a datasource
+ public static final String DATASOURCE_CONNECTION = "datasource"; //$NON-NLS-1$
+ // used for when embedded is running in an appserver
+ public static final String JNDI_CONNECTION = "jndi"; //$NON-NLS-1$
+ /*
+ * ******************************************************************
+ */
+
+ public static final String DS_USER = "user"; //$NON-NLS-1$
+
+ // need both user variables because Teiid uses 'user' and connectors use 'username'
+ public static final String DS_USERNAME = JDBCPropertyNames.USERNAME; //$NON-NLS-1$
+ public static final String DS_PASSWORD = JDBCPropertyNames.PASSWORD; //$NON-NLS-1$
+
+ // the driver is only used for making direct connections to the source, the
+ // connector type will provide the JDBCPropertyNames.CONNECTION_SOURCE driver class
+ public static final String DS_DRIVER = "driver"; //$NON-NLS-1$
+
+ public static final String DS_URL = JDBCPropertyNames.URL; //$NON-NLS-1$
+ public static final String DS_SERVERNAME = "servername"; //$NON-NLS-1$
+ public static final String DS_SERVERPORT = "portnumber"; //$NON-NLS-1$
+ public static final String DS_JNDINAME = "ds-jndiname"; //$NON-NLS-1$
+ public static final String DS_DATABASENAME = "databasename"; //$NON-NLS-1$
+ public static final String DS_APPLICATION_NAME = "application-name"; //$NON-NLS-1$
+
+ public static final String PROCESS_BATCH = "process-batch"; //$NON-NLS-1$
+ public static final String CONNECTOR_BATCH = "connector-batch"; //$NON-NLS-1$
+ public static final String JNDINAME_USERTXN = "usertxn-jndiname"; //$NON-NLS-1$
+
+
+ public static final String AUTOCOMMIT = "autocommit"; //$NON-NLS-1$
+
+ public static final String EXEC_IN_BATCH = "execute.in.batch"; //$NON-NLS-1$
+
+
+ public ConnectionStrategy(Properties props) throws QueryTestFailedException {
+ this.env = props;
+
+
+ }
+
+ /*
+ * Lifecycle methods for managing the connection
+ */
+
+ /**
+ * Returns a connection
+ * @return Connection
+ */
+ public abstract Connection getConnection() throws QueryTestFailedException;
+
+ public Connection getAdminConnection() throws QueryTestFailedException{
+ return null;
+ }
+
+ private boolean autoCommit;
+ public boolean getAutocommit() {
+ return autoCommit;
+ }
+
+ public abstract void shutdown();
+
+ public XAConnection getXAConnection() throws QueryTestFailedException {
+ return null;
+ }
+
+
+ private Properties env = null;
+
+
+ public Properties getEnvironment() {
+ return env;
+ }
+
+ class CloseInterceptor implements InvocationHandler {
+
+ Connection conn;
+
+ CloseInterceptor(Connection conn) {
+ this.conn = conn;
+ }
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ if (method.getName().equals("close")) { //$NON-NLS-1$
+ return null;
+ }
+ try {
+ return method.invoke(this.conn, args);
+ } catch (InvocationTargetException e) {
+ throw e.getTargetException();
+ }
+ }
+ }
+
+
+ void configure() throws QueryTestFailedException {
+
+ String ac = this.env.getProperty(AUTOCOMMIT, "true");
+ this.autoCommit = Boolean.getBoolean(ac);
+
+ com.metamatrix.jdbc.api.Connection c =null;
+ try {
+
+ // the the driver strategy is going to be used to connection directly to the connector binding
+ // source, then no administration can be done
+ java.sql.Connection conn = getConnection();
+ if ( conn instanceof com.metamatrix.jdbc.api.Connection) {
+ c = (com.metamatrix.jdbc.api.Connection) conn;
+ } else {
+ return;
+ }
+
+ Admin admin = (Admin)c.getAdminAPI();
+
+ boolean update = false;
+ Properties p = new Properties();
+ if (this.env.getProperty(PROCESS_BATCH) != null) {
+ p.setProperty("metamatrix.buffer.processorBatchSize", this.env.getProperty(PROCESS_BATCH)); //$NON-NLS-1$
+ update = true;
+ }
+
+ if (this.env.getProperty(CONNECTOR_BATCH) != null) {
+ p.setProperty("metamatrix.buffer.connectorBatchSize", this.env.getProperty(CONNECTOR_BATCH)); //$NON-NLS-1$
+ update = true;
+ }
+
+ // update the system.
+// if (update) {
+// admin.s
+// admin.updateSystemProperties(p);
+// }
+ setupVDBConnectorBindings(admin);
+
+ admin.restart();
+
+ System.out.println("Bouncing the system..(wait 15 seconds)"); //$NON-NLS-1$
+ Thread.sleep(1000*15);
+ // Thread.sleep(1000*60);
+ System.out.println("done."); //$NON-NLS-1$
+
+ } catch (Exception e) {
+ e.printStackTrace();
+
+ throw new TransactionRuntimeException(e);
+ } finally {
+ // need to close and flush the connection after restarting
+ this.shutdown();
+
+ }
+ }
+
+ protected void setupVDBConnectorBindings(Admin api) throws QueryTestFailedException {
+
+ try {
+
+ Collection<VDB> vdbs = api.getVDBs("*");
+ if (vdbs == null) {
+ throw new QueryTestFailedException("GetVDBS returned no vdbs available");
+
+ } else if (vdbs.size() != 1) {
+ throw new QueryTestFailedException("GetVDBS returned more than 1 vdb available");
+ }
+ VDB vdb = (VDB) vdbs.iterator().next();
+ Iterator<Model> modelIt = vdb.getModels().iterator();
+ while (modelIt.hasNext() ) {
+ Model m = modelIt.next();
+
+ if (!m.isPhysical()) continue;
+
+ // get the mapping, if defined
+ String mappedName = this.env.getProperty(m.getName());
+
+ String useName = m.getName();
+ if(mappedName != null) {
+ useName = mappedName;
+ }
+
+ org.teiid.test.framework.datasource.DataSource ds = DatasourceMgr.getInstance().getDatasource(useName);
+// Properties sourceProps = DatasourceMgr.getInstance().getDatasourceProperties(useName);
+
+ if (ds != null) {
+
+ AdminOptions ao = new AdminOptions(AdminOptions.OnConflict.OVERWRITE);
+ ao.addOption(AdminOptions.BINDINGS_IGNORE_DECRYPT_ERROR);
+
+ api.addConnectorBinding(ds.getName(), ds.getType(), ds.getProperties(), ao);
+
+ api.assignBindingToModel(ds.getName(), vdb.getName(), vdb.getVDBVersion(), m.getName());
+
+ } else {
+ throw new QueryTestFailedException("Error: Unable to create binding to map to model : " + m.getName() + ", the mapped name " + useName + " had no datasource properties defined");
+ }
+
+ }
+
+// Collection<ConnectorBinding> bindings = api.getConnectorBindingsInVDB("*");
+//
+// for (Iterator<ConnectorBinding> it=bindings.iterator(); it.hasNext();) {
+// ConnectorBinding cb = it.next();
+//
+// cb.
+//
+// String mappedName = this.env.getProperty(cb.getName());
+//
+// String useName = cb.getName();
+// if(mappedName != null) {
+// useName = mappedName;
+// }
+//
+// Properties sourceProps = DatasourceMgr.getInstance().getDatasourceProperties(useName);
+//
+// if (sourceProps != null) {
+// Properties newprops = new Properties(cb.getProperties());
+// newprops.putAll(sourceProps);
+// api.updateProperties(cb.getName(), "org.teiid.adminapi.ConnectorBinding", newprops);
+//
+// } else {
+// System.err.println("WARNING: ConnectorBinding : " + cb.getName() + " was not updated, the mapped name " + useName + " had no datasource properties defined");
+// }
+//
+//
+//
+// }
+ } catch (QueryTestFailedException qt) {
+ throw qt;
+ } catch (Exception t) {
+ throw new QueryTestFailedException(t);
+ }
+
+
+ }
+
+
+ /**
+ * The datasource_identifier must match one of the mappings in the file
+ * at {@see} src/main/resources/datasources/datasource_mapping.txt
+ * @param datasource_identifier
+ * @return
+ *
+ * @since
+ */
+// public XAConnection getXASource(String datasource_identifier) {
+// return null;
+// }
+//
+// public Connection getSource(String datasource_identifier) {
+// return null;
+// }
+
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategy.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategyFactory.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategyFactory.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategyFactory.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.connection;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+
+import org.teiid.test.framework.exception.QueryTestFailedException;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+
+public class ConnectionStrategyFactory {
+
+ /**
+ * Specify this property to set a specific configuration to use
+ */
+ public static final String CONFIG_FILE="config";
+
+ /**
+ * The default config file to use when #CONFIG_FILE system property isn't set
+ */
+ private static final String DEFAULT_CONFIG_FILE_NAME="default-config.properties";
+
+ private static ConnectionStrategyFactory _instance = null;
+ private ConnectionStrategy strategy = null;
+ private Properties config = null;
+ private static Map<String, ConnectionStrategy> sources = null;
+
+
+
+ private ConnectionStrategyFactory(){
+ }
+
+ public static synchronized ConnectionStrategyFactory getInstance() {
+ if (_instance == null) {
+ _instance = new ConnectionStrategyFactory();
+ Properties p = _instance.loadConfiguration();
+ try {
+ _instance.initialize(p);
+ } catch (QueryTestFailedException e) {
+ // TODO Auto-generated catch block
+ throw new TransactionRuntimeException(e);
+ }
+ }
+ return _instance;
+ }
+
+ private static void init() {
+ if (sources == null) {
+ sources = new HashMap<String, ConnectionStrategy>();
+ }
+ }
+
+
+ public static synchronized void destroyInstance() {
+ if (_instance != null) {
+ _instance.shutdown();
+
+ _instance = null;
+
+
+ }
+ }
+
+ private void shutdown() {
+ Properties p = System.getProperties();
+ p.remove(CONFIG_FILE);
+
+
+ for (Iterator it=sources.keySet().iterator(); it.hasNext(); ){
+
+ ConnectionStrategy cs = sources.get(it.next());
+ try {
+ cs.shutdown();
+ } catch (Exception e) {
+
+ }
+
+ }
+ sources.clear();
+ sources = null;
+
+ strategy.shutdown();
+ strategy = null;
+ config = null;
+
+ }
+
+ public Properties getConfiguration() {
+ return this.config;
+ }
+
+ public ConnectionStrategy getConnectionStrategy() {
+ return this.strategy;
+ }
+
+ private Properties loadConfiguration() {
+ init();
+
+ String filename = System.getProperty(CONFIG_FILE);
+ if (filename == null) {
+ filename = DEFAULT_CONFIG_FILE_NAME;
+ }
+
+ return loadProperties(filename);
+
+ }
+
+ private void initialize(Properties props) throws QueryTestFailedException {
+ this.config = props;
+
+ this.strategy = create(props);
+
+ }
+
+ private ConnectionStrategy create(Properties props) throws QueryTestFailedException {
+
+ ConnectionStrategy strategy = null;
+
+ String type = props.getProperty(ConnectionStrategy.CONNECTION_TYPE, ConnectionStrategy.DRIVER_CONNECTION);
+ if (type == null) {
+ throw new RuntimeException("Property " + ConnectionStrategy.CONNECTION_TYPE + " was specified");
+ }
+
+ if (type.equalsIgnoreCase(ConnectionStrategy.DRIVER_CONNECTION)) {
+ strategy = createDriverStrategy(null, props);
+ System.out.println("Created Driver Strategy");
+ }
+ else if (type.equalsIgnoreCase(ConnectionStrategy.DATASOURCE_CONNECTION)) {
+ strategy = createDataSourceStrategy(null, props);
+ System.out.println("Created DataSource Strategy");
+ }
+ else if (type.equalsIgnoreCase(ConnectionStrategy.JNDI_CONNECTION)) {
+ strategy = createJEEStrategy(null, props);
+ System.out.println("Created JEE Strategy");
+ }
+
+ if (strategy == null) {
+ new TransactionRuntimeException("Invalid property value for " + ConnectionStrategy.CONNECTION_TYPE + " is " + type );
+ }
+ // call configure here because this is creating the connection to Teiid
+ // direct connections to the datasource use the static call directly to create strategy and don't need to configure
+ strategy.configure();
+ return strategy;
+ }
+
+ public synchronized static ConnectionStrategy createDriverStrategy(String identifier, Properties props) throws QueryTestFailedException {
+ if (identifier == null) {
+ return new DriverConnection(props);
+ }
+ init();
+
+ ConnectionStrategy strategy = null;
+ if (sources.containsKey(identifier)) {
+ strategy = sources.get(identifier);
+ } else {
+ strategy = new DriverConnection(props);
+ sources.put(identifier, strategy);
+ }
+
+ return strategy;
+
+ }
+
+ public synchronized static ConnectionStrategy createDataSourceStrategy(String identifier, Properties props) throws QueryTestFailedException {
+ if (identifier == null) {
+ return new DataSourceConnection(props);
+ }
+ init();
+
+ ConnectionStrategy strategy = null;
+ if (sources.containsKey(identifier)) {
+ strategy = sources.get(identifier);
+ } else {
+ strategy = new DataSourceConnection(props);
+ sources.put(identifier, strategy);
+ }
+
+ return strategy;
+
+ }
+
+ public synchronized static ConnectionStrategy createJEEStrategy(String identifier, Properties props) throws QueryTestFailedException {
+ if (identifier == null) {
+ return new JEEConnection(props);
+ }
+
+ init();
+ ConnectionStrategy strategy = null;
+ if (sources.containsKey(identifier)) {
+ strategy = sources.get(identifier);
+ } else {
+ strategy = new JEEConnection(props);
+ sources.put(identifier, strategy);
+ }
+
+ return strategy;
+
+ }
+
+ private final Properties loadProperties(String filename) {
+ Properties props = null;
+ try {
+ InputStream in = ConnectionStrategyFactory.class.getResourceAsStream("/"+filename);
+ if (in != null) {
+ props = new Properties();
+ props.load(in);
+ return props;
+ }
+ else {
+ throw new RuntimeException("Failed to load properties from file '"+filename+ "' configuration file");
+ }
+ } catch (IOException e) {
+ throw new RuntimeException("Error loading properties from file '"+filename+ "'" + e.getMessage());
+ }
+ }
+
+ public static void main(String[] args) {
+ ConnectionStrategyFactory cf = ConnectionStrategyFactory.getInstance();
+
+ }
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionStrategyFactory.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionUtil.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionUtil.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionUtil.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,81 @@
+package org.teiid.test.framework.connection;
+
+import java.sql.Connection;
+import java.util.Properties;
+
+import javax.sql.XAConnection;
+
+import org.teiid.test.framework.ConfigPropertyLoader;
+import org.teiid.test.framework.datasource.DatasourceMgr;
+import org.teiid.test.framework.exception.QueryTestFailedException;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+
+public class ConnectionUtil {
+ public static final Connection getSource(String identifier)
+ throws QueryTestFailedException {
+ if (identifier != null) {
+ Properties props = ConfigPropertyLoader
+ .loadConfigurationProperties();
+ String mappedName = props.getProperty(identifier);
+
+ if (mappedName == null) {
+ throw new TransactionRuntimeException("Identifier mapping "
+ + identifier
+ + " is not defined in the config properties file");
+ }
+
+ Properties sourceProps;
+ try {
+ sourceProps = DatasourceMgr.getInstance()
+ .getDatasourceProperties(mappedName);
+ } catch (QueryTestFailedException e) {
+ throw new TransactionRuntimeException(e);
+ }
+
+ if (sourceProps == null) {
+ throw new TransactionRuntimeException("Identifier "
+ + identifier + " mapped to " + mappedName
+ + " has no datasource properties");
+ }
+
+ return ConnectionStrategyFactory.createDriverStrategy(identifier,
+ sourceProps).getConnection();
+
+ }
+ throw new RuntimeException("No Connection by name :" + identifier); //$NON-NLS-1$
+ }
+
+ public static final XAConnection getXASource(String identifier)
+ throws QueryTestFailedException {
+ if (identifier != null) {
+ Properties props = ConfigPropertyLoader
+ .loadConfigurationProperties();
+ String mappedName = props.getProperty(identifier);
+
+ if (mappedName == null) {
+ throw new TransactionRuntimeException("Identifier mapping "
+ + identifier
+ + " is not defined in the config properties file");
+ }
+
+ Properties sourceProps;
+ try {
+ sourceProps = DatasourceMgr.getInstance()
+ .getDatasourceProperties(mappedName);
+ } catch (QueryTestFailedException e) {
+ throw new TransactionRuntimeException(e);
+ }
+
+ if (sourceProps == null) {
+ throw new TransactionRuntimeException("Identifier "
+ + identifier + " mapped to " + mappedName
+ + " has no datasource properties");
+ }
+
+ return ConnectionStrategyFactory.createDataSourceStrategy(
+ identifier, sourceProps).getXAConnection();
+ }
+ throw new RuntimeException("No Connection by name :" + identifier); //$NON-NLS-1$
+ }
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/ConnectionUtil.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DataSourceConnection.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DataSourceConnection.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DataSourceConnection.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.connection;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Properties;
+
+import javax.sql.XAConnection;
+import javax.sql.XADataSource;
+
+import org.teiid.test.framework.exception.QueryTestFailedException;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+
+import com.metamatrix.jdbc.BaseDataSource;
+import com.metamatrix.jdbc.EmbeddedDataSource;
+import com.metamatrix.jdbc.MMDataSource;
+
+/**
+*
+*/
+public class DataSourceConnection extends ConnectionStrategy {
+
+ private String driver = null;
+ private String username = null;
+ private String pwd = null;
+ private String applName = null;
+ private String databaseName = null;
+ private String serverName = null;
+ private String portNumber = null;
+
+
+ private XAConnection xaConnection;
+
+ public DataSourceConnection(Properties props) throws QueryTestFailedException {
+ super(props);
+ }
+
+
+
+ public void validate() {
+ databaseName = this.getEnvironment().getProperty(DS_DATABASENAME);
+ if (databaseName == null || databaseName.length() == 0) {
+ throw new TransactionRuntimeException("Property " + DS_DATABASENAME + " was not specified");
+ }
+
+ serverName = this.getEnvironment().getProperty(DS_SERVERNAME);
+ if (serverName == null || serverName.length() == 0) {
+ throw new TransactionRuntimeException("Property " + DS_SERVERNAME + " was not specified");
+ }
+
+
+ this.portNumber = this.getEnvironment().getProperty(DS_SERVERPORT);
+
+ this.applName = this.getEnvironment().getProperty(DS_APPLICATION_NAME);
+
+ driver = this.getEnvironment().getProperty(DS_DRIVER);
+ if (driver == null || driver.length() == 0) {
+ throw new TransactionRuntimeException("Property " + DS_DRIVER + " was not specified");
+ }
+
+ this.username = this.getEnvironment().getProperty(DS_USER);
+ this.pwd = this.getEnvironment().getProperty(DS_PASSWORD);
+
+ }
+
+//
+// public synchronized XAConnection getXAAdminConnection() throws QueryTestFailedException {
+// if (xaConnection == null) {
+// try {
+// xaConnection = createAdminConnection();
+// } catch (Exception e) {
+// throw new QueryTestFailedException(e);
+// }
+// }
+// return xaConnection;
+// }
+
+
+ public Connection getConnection() throws QueryTestFailedException {
+ try {
+ return getXAConnection().getConnection();
+ } catch (QueryTestFailedException qtf) {
+ throw qtf;
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new QueryTestFailedException(e);
+ }
+ }
+
+ public synchronized XAConnection getXAConnection() throws QueryTestFailedException {
+ if (xaConnection == null) {
+ validate();
+ try {
+ xaConnection = createConnection();
+ } catch (Exception e) {
+ throw new QueryTestFailedException(e);
+ }
+ }
+ return xaConnection;
+ }
+
+ private XAConnection createConnection() throws SQLException, InstantiationException, IllegalAccessException, ClassNotFoundException {
+ BaseDataSource dataSource = (BaseDataSource)Class.forName(this.driver).newInstance();
+
+ dataSource.setDatabaseName(this.databaseName);
+ if (this.applName != null) {
+ dataSource.setApplicationName(this.applName);
+ }
+
+ if (dataSource instanceof EmbeddedDataSource) {
+ ((EmbeddedDataSource)dataSource).setBootstrapFile(this.serverName);
+ } else {
+ ((MMDataSource)dataSource).setServerName(this.serverName);
+ ((MMDataSource)dataSource).setPortNumber(Integer.parseInt(this.portNumber));
+ }
+
+ if (this.username != null) {
+ dataSource.setUser(this.username);
+ dataSource.setPassword(this.pwd);
+ }
+
+
+ return ((XADataSource)dataSource).getXAConnection();
+ }
+
+// private XAConnection createAdminConnection() throws SQLException, InstantiationException, IllegalAccessException, ClassNotFoundException {
+// BaseDataSource dataSource = (BaseDataSource)Class.forName(this.driver).newInstance();
+//
+// dataSource.setDatabaseName("Admin");
+// if (this.applName != null) {
+// dataSource.setApplicationName(this.applName);
+// }
+//
+// if (dataSource instanceof EmbeddedDataSource) {
+// ((EmbeddedDataSource)dataSource).setBootstrapFile(this.serverName);
+// } else {
+// ((MMDataSource)dataSource).setServerName(this.serverName);
+// ((MMDataSource)dataSource).setPortNumber(Integer.parseInt(this.portNumber));
+// }
+//
+// if (this.username != null) {
+// dataSource.setUser(this.username);
+// dataSource.setPassword(this.pwd);
+// }
+//
+//
+// return ((XADataSource)dataSource).getXAConnection();
+// }
+
+// private static XAConnection getDataSource(String prefix, Properties props) throws SQLException, InstantiationException, IllegalAccessException, ClassNotFoundException {
+// // depending upon the DataDirect class hirarchy..
+// DataSource dataSource = (DataSource)Class.forName(props.getProperty(DS_DRIVER)).newInstance();
+// PropertiesUtils.setBeanProperties(dataSource, props, prefix);
+//
+// return ((XADataSource)dataSource).getXAConnection();
+// }
+
+
+
+ public void shutdown() {
+ try {
+
+
+ if (this.xaConnection != null) {
+ this.xaConnection.close();
+ }
+ } catch (SQLException e) {
+ // ignore..
+ }
+
+ this.xaConnection = null;
+ }
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DataSourceConnection.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DriverConnection.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DriverConnection.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DriverConnection.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.connection;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+import org.teiid.test.framework.exception.QueryTestFailedException;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+
+
+
+/**
+ * The DriverConnection strategy that can get connections in standalone mode
+ * or embedded mode.
+ */
+public class DriverConnection extends ConnectionStrategy{
+
+ private String url = null;
+ private String driver = null;
+ private String username = null;
+ private String pwd = null;
+
+ private Connection connection;
+
+
+ public DriverConnection(Properties props) throws QueryTestFailedException {
+ super(props);
+ }
+
+ public void validate() {
+
+ String urlProp = this.getEnvironment().getProperty(DS_URL);
+ if (urlProp == null || urlProp.length() == 0) {
+ throw new TransactionRuntimeException("Property " + DS_URL + " was not specified");
+ }
+ StringBuffer urlSB = new StringBuffer(urlProp);
+
+ String appl = this.getEnvironment().getProperty(DS_APPLICATION_NAME);
+ if (appl != null) {
+ urlSB.append(";");
+ urlSB.append("ApplicationName").append("=").append(appl);
+ }
+
+ url = urlSB.toString();
+
+ driver = this.getEnvironment().getProperty(DS_DRIVER);
+ if (driver == null || driver.length() == 0) {
+ throw new TransactionRuntimeException("Property " + DS_DRIVER + " was not specified");
+ }
+
+ // need both user variables because Teiid uses 'user' and connectors use 'username'
+
+ this.username = this.getEnvironment().getProperty(DS_USER);
+ if (username == null) {
+ this.username = this.getEnvironment().getProperty(DS_USERNAME);
+ }
+ this.pwd = this.getEnvironment().getProperty(DS_PASSWORD);
+
+ try {
+ // Load jdbc driver
+ Class.forName(driver);
+ } catch (ClassNotFoundException e) {
+ throw new TransactionRuntimeException(e);
+ }
+
+ }
+
+ public synchronized Connection getConnection() throws QueryTestFailedException {
+ if (this.connection != null) {
+ try {
+ if (!this.connection.isClosed()) {
+ return this.connection;
+ }
+ } catch (SQLException e) {
+
+ }
+
+ }
+
+ validate();
+
+ this.connection = getJDBCConnection(this.driver, this.url, this.username, this.pwd);
+ return this.connection;
+ }
+
+
+ private Connection getJDBCConnection(String driver, String url, String user, String passwd) throws QueryTestFailedException {
+
+ System.out.println("Creating Connection: \"" + url + "\""); //$NON-NLS-1$ //$NON-NLS-2$
+
+ Connection conn;
+ try {
+ // Create a connection
+ if (user != null && user.length() > 0) {
+ conn = DriverManager.getConnection(url, user, passwd);
+ } else {
+ conn = DriverManager.getConnection(url);
+ }
+
+
+ } catch (SQLException e) {
+ throw new QueryTestFailedException(e);
+ }
+ return conn;
+
+ }
+
+ public void shutdown() {
+ if (this.connection != null) {
+ try {
+ this.connection.close();
+ } catch (Exception e) {
+ //ignore
+ }
+ }
+
+ this.connection = null;
+
+ }
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/DriverConnection.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/JEEConnection.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/JEEConnection.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/JEEConnection.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.connection;
+
+import java.sql.Connection;
+import java.util.Properties;
+
+import javax.naming.InitialContext;
+import javax.sql.DataSource;
+
+import org.teiid.test.framework.exception.QueryTestFailedException;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+
+
+
+/**
+ * JEE (JNDI) Connection Strategy, when the test is run inside an application server. Make
+ * sure all the jndi names are set correctly in the properties file.
+ */
+public class JEEConnection extends ConnectionStrategy{
+
+ private String jndi_name = null;
+
+
+ public JEEConnection(Properties props) throws QueryTestFailedException {
+ super(props);
+ }
+
+ public Connection getConnection() throws QueryTestFailedException {
+ validate();
+ try {
+ InitialContext ctx = new InitialContext();
+ DataSource source = (DataSource)ctx.lookup(jndi_name);
+
+
+ if (source == null) {
+ String msg = "Unable to find jndi source " + jndi_name;//$NON-NLS-1$
+
+ QueryTestFailedException mme = new QueryTestFailedException(msg);//$NON-NLS-1$
+ throw mme;
+ }
+ Connection conn = source.getConnection();
+ return conn;
+ } catch (QueryTestFailedException qtfe) {
+ throw qtfe;
+ } catch (Exception e) {
+ throw new QueryTestFailedException(e);
+ }
+ }
+
+ public void shutdown() {
+ // no connection management here; app server takes care of these..
+ }
+
+ public void validate() {
+ // TODO Auto-generated method stub
+
+ jndi_name = getEnvironment().getProperty(ConnectionStrategy.DS_JNDINAME);
+ if (jndi_name == null || jndi_name.length() == 0) {
+ throw new TransactionRuntimeException("Property " + DS_JNDINAME + " was not specified");
+ }
+ }
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/JEEConnection.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,39 @@
+package org.teiid.test.framework.datasource;
+
+import java.util.Properties;
+
+public class DataSource {
+ public static final String DIRECTORY="dir";
+ public static final String CONNECTOR_TYPE="connectortype";
+
+ private Properties props;
+
+ private String name;
+ private String group;
+
+ public DataSource(String name, String group, Properties properties) {
+ this.name = name;
+ this.group = group;
+ this.props = properties;
+ }
+
+
+ public String getName() {
+ return name;
+ }
+
+ public String getType() {
+ return props.getProperty(CONNECTOR_TYPE);
+ }
+
+ public String getProperty(String propName) {
+ return props.getProperty(propName);
+ }
+
+ public Properties getProperties() {
+ return this.props;
+ }
+
+
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DataSource.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DatasourceMgr.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DatasourceMgr.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DatasourceMgr.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.datasource;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.sql.Connection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import javax.sql.XAConnection;
+
+import org.jdom.Document;
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.teiid.test.framework.ConfigPropertyLoader;
+import org.teiid.test.framework.connection.ConnectionStrategyFactory;
+import org.teiid.test.framework.exception.QueryTestFailedException;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+
+import com.metamatrix.common.xml.XMLReaderWriter;
+import com.metamatrix.common.xml.XMLReaderWriterImpl;
+
+/**
+ * The DatasourceMgr is responsible for loading and managing the datasource
+ * mapping properties file {@see #DATASOURCE_MAPPING_FILE} and the mapped
+ * datasource properties files. The {@link #getDatasourceProperties(String)}
+ * returns the properties defined for that datasourceid, which is mapped in the
+ * mnappings file. This mapping allows the test
+ *
+ * @author vanhalbert
+ *
+ */
+public class DatasourceMgr {
+
+ static final String DIRECTORY = "datasources/";
+ static final String DATASOURCE_MAPPING_FILE = "datasource_mapping.xml";
+
+ private static DatasourceMgr _instance = null;
+
+ private Map<String, Map<String, DataSource>>dstypeMap = new HashMap<String, Map<String, DataSource>>();
+
+ private Map<String, DataSource> allDatasourcesMap = new HashMap<String, DataSource>();
+
+ private DatasourceMgr() {
+ }
+
+ public static synchronized DatasourceMgr getInstance() {
+ if (_instance == null) {
+ _instance = new DatasourceMgr();
+ try {
+ _instance.loadDataSourceMappings();
+ } catch (QueryTestFailedException e) {
+ // TODO Auto-generated catch block
+ throw new TransactionRuntimeException(e);
+ } catch (TransactionRuntimeException e) {
+ // TODO Auto-generated catch block
+ throw e;
+ }
+
+ }
+ return _instance;
+ }
+
+ public int numberOfAvailDataSources() {
+ return allDatasourcesMap.size();
+ }
+
+ public org.teiid.test.framework.datasource.DataSource getDatasource(String datasourceid)
+ throws QueryTestFailedException {
+ DataSource ds = null;
+ if (dstypeMap.containsKey(datasourceid)) {
+
+ Map datasources = dstypeMap.get(datasourceid);
+ ds = (DataSource) datasources.values().iterator().next();
+
+ } else {
+ ds = allDatasourcesMap.get(datasourceid);
+ }
+ if (ds == null) {
+ throw new QueryTestFailedException("DatasourceID " + datasourceid
+ + " is not a defined datasource in the mappings file ");
+
+ }
+ return ds;
+
+ }
+
+ public Properties getDatasourceProperties(String datasourceid)
+ throws QueryTestFailedException {
+ DataSource ds = null;
+ if (dstypeMap.containsKey(datasourceid)) {
+
+ Map datasources = dstypeMap.get(datasourceid);
+ ds = (DataSource)datasources.values().iterator().next();
+
+ } else {
+ ds = allDatasourcesMap.get(datasourceid);
+ }
+ if (ds == null) {
+ throw new QueryTestFailedException("DatasourceID " + datasourceid
+ + " is not a defined datasource in the mappings file ");
+
+ }
+ return ds.getProperties();
+
+ }
+
+ private void loadDataSourceMappings()
+ throws QueryTestFailedException {
+
+ Document doc = null;
+ XMLReaderWriter readerWriter = new XMLReaderWriterImpl();
+
+ try {
+ doc = readerWriter.readDocument(getInputStream());
+ } catch (JDOMException e) {
+ e.printStackTrace();
+ throw new TransactionRuntimeException(e);
+ } catch (IOException e) {
+ e.printStackTrace();
+ throw new TransactionRuntimeException(e);
+ }
+
+ Element root = doc.getRootElement();
+ List<Element> rootElements = root.getChildren();
+ if (rootElements == null || rootElements.size() == 0) {
+ throw new TransactionRuntimeException("No children defined under root element " + DSCONFIG);
+ }
+
+ for (Iterator<Element> it = rootElements.iterator(); it.hasNext();) {
+ Element type = it.next();
+// System.out.println("Loading ds transactional type " + type.getName());
+ String typename = type.getAttributeValue(Property.Attributes.NAME);
+
+ List<Element> typeElements = type.getChildren();
+ if (typeElements != null) {
+ Map<String, DataSource> datasources = new HashMap<String, DataSource>(typeElements.size());
+
+ for (Iterator<Element> typeit = typeElements.iterator(); typeit.hasNext();) {
+ Element e = typeit.next();
+// System.out.println("Loading ds type " + e.getName());
+ addDataSource(e, typename, datasources);
+ }
+ dstypeMap.put(typename, datasources);
+ allDatasourcesMap.putAll(datasources);
+
+ }
+
+
+ }
+
+ if (dstypeMap == null || dstypeMap.isEmpty()) {
+ throw new TransactionRuntimeException(
+ "No Datasources were found in the mappings file");
+ }
+
+ System.out.println("Number of datasource types loaded " + dstypeMap.size());
+ System.out.println("Number of total datasource mappings loaded " + allDatasourcesMap.size());
+
+
+
+ }
+
+ private static void addDataSource(Element element, String type, Map<String, DataSource> datasources) {
+ String name = element.getAttributeValue(Property.Attributes.NAME);
+ Properties props = getProperties(element);
+
+ String dir = props.getProperty(DataSource.DIRECTORY);
+ String dsfile = DIRECTORY + dir + "/connection.properties";
+ Properties dsprops = loadProperties(dsfile);
+ if (dsprops != null) {
+ props.putAll(dsprops);
+ DataSource ds = new DataSource(name,
+ type,
+ props);
+ datasources.put(ds.getName(), ds);
+ System.out.println("Loaded datasource " + ds.getName());
+
+ }
+// else {
+// System.out.println("Did not load datasource " + name);
+// }
+
+ }
+
+
+ private static Properties loadProperties(String filename) {
+ Properties props = null;
+
+ try {
+ InputStream in = DatasourceMgr.class.getResourceAsStream("/"
+ + filename);
+ if (in != null) {
+ props = new Properties();
+ props.load(in);
+ return props;
+ }
+ return null;
+ } catch (IOException e) {
+ throw new TransactionRuntimeException("Error loading properties from file '"
+ + filename + "'" + e.getMessage());
+ }
+ }
+
+ private static Properties getProperties(Element propertiesElement) {
+ Properties props = new Properties();
+
+ List<Element> properties = propertiesElement
+ .getChildren(Property.ELEMENT);
+ Iterator<Element> iterator = properties.iterator();
+ while (iterator.hasNext()) {
+ Element propertyElement = (Element) iterator.next();
+ String propertyName = propertyElement
+ .getAttributeValue(Property.Attributes.NAME);
+ String propertyValue = propertyElement.getText();
+
+ props.setProperty(propertyName, propertyValue);
+
+ }
+ return props;
+ }
+
+ private static InputStream getInputStream() {
+
+ InputStream in = DatasourceMgr.class.getResourceAsStream("/"
+ + DIRECTORY + DATASOURCE_MAPPING_FILE);
+ if (in != null) {
+
+ return in;
+ } else {
+ throw new RuntimeException(
+ "Failed to load datasource mapping file '" + DIRECTORY
+ + DATASOURCE_MAPPING_FILE + "'");
+ }
+
+ }
+
+ static final String DSCONFIG = "datasourceconfig";
+ static final String DATASOURCETYPE = "datasourcetype";
+ static final String DATASOURCE = "datasource";
+
+// static class DS_TYPE {
+//
+// /**
+// * This is the name of the Property Element.
+// */
+// public static final String XA_ELEMENT = "xa"; //$NON-NLS-1$
+// public static final String NONXA_ELEMENT = "nonxa"; //$NON-NLS-1$
+//
+// }
+
+ static class Property {
+
+ /**
+ * This is the name of the Property Element.
+ */
+ public static final String ELEMENT = "property"; //$NON-NLS-1$
+
+ /**
+ * This class defines the Attributes of the Element class that contains
+ * it.
+ */
+ public static class Attributes {
+ public static final String NAME = "name"; //$NON-NLS-1$
+ }
+
+ }
+
+ public static void main(String[] args) {
+ DatasourceMgr mgr = DatasourceMgr.getInstance();
+
+ try {
+ System.out.println("Value for ds_mysql5: "
+ + mgr.getDatasourceProperties("ds_mysql5"));
+ } catch (QueryTestFailedException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/DatasourceMgr.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/QueryTestFailedException.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/QueryTestFailedException.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/QueryTestFailedException.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) 2000-2005 MetaMatrix, Inc. All rights reserved.
+ */
+package org.teiid.test.framework.exception;
+
+import java.io.Serializable;
+import java.util.List;
+
+import com.metamatrix.core.MetaMatrixRuntimeException;
+import com.metamatrix.core.util.MetaMatrixExceptionUtil;
+
+/**
+ */
+
+ /**
+ * The QueryTestFailedException is thrown during a test.
+ *
+ * This exception which contains a reference to another exception. This
+ * class can be used to maintain a linked list of exceptions. <p>
+ *
+ * Subclasses of this exception typically only need to implement whatever
+ * constructors they need. <p>
+ */
+public class QueryTestFailedException extends Exception
+ implements Serializable{
+ //############################################################################################################################
+ //# Static Methods #
+ //############################################################################################################################
+
+ /**
+ * @since
+ */
+ private static final long serialVersionUID = -4824998416118801290L;
+
+ /**
+ * Utility method to get the name of a class, without package information.
+ *
+ * @param cls The class to get the name of
+ * @return The name of the class, without package info
+ */
+ public static String getClassShortName( Class<?> cls ) {
+ if ( cls == null ) return ""; //$NON-NLS-1$
+ String className = cls.getName();
+ return className.substring( className.lastIndexOf('.')+1 );
+ }
+
+ //############################################################################################################################
+ //# Variables #
+ //############################################################################################################################
+
+ /** An error code. */
+ private String code;
+
+ /** Exception chained to this one. */
+ private Throwable child;
+
+ private String msg;
+
+ //############################################################################################################################
+ //# Constructors #
+ //############################################################################################################################
+
+ /**
+ * Construct a default instance of this class.
+ */
+ public QueryTestFailedException() {
+ }
+
+ /**
+ * Construct an instance with the specified error message. If the message is actually a key, the actual message will be
+ * retrieved from a resource bundle using the key, the specified parameters will be substituted for placeholders within the
+ * message, and the code will be set to the key.
+ * @param message The error message or a resource bundle key
+ */
+ public QueryTestFailedException(final String message) {
+ setMessage(message, null);
+ }
+
+ /**
+ * Construct an instance with the specified error code and message. If the message is actually a key, the actual message will
+ * be retrieved from a resource bundle using the key, and the specified parameters will be substituted for placeholders within
+ * the message.
+ * @param code The error code
+ * @param message The error message or a resource bundle key
+ */
+ public QueryTestFailedException(final String code, final String message) {
+ setMessage(message, null);
+ // The following setCode call should be executed after setting the message
+ setCode(code);
+ }
+
+ /**
+ * Construct an instance with a linked exception specified. If the exception is a MetaMatrixException or a
+ * {@link MetaMatrixRuntimeException}, then the code will be set to the exception's code.
+ * @param e An exception to chain to this exception
+ */
+ public QueryTestFailedException(final Throwable e) {
+ // This is nasty, but there's no setMessage() routine!
+ this.msg = ( e instanceof java.lang.reflect.InvocationTargetException )
+ ? ((java.lang.reflect.InvocationTargetException)e).getTargetException().getMessage()
+ : (e == null ? null : e.getMessage());
+ setChild( e );
+
+ }
+
+ /**
+ * Construct an instance with the linked exception and error message specified. If the message is actually a key, the error
+ * message will be retrieved from a resource bundle the key, and code will be set to that key. Otherwise, if the specified
+ * exception is a MetaMatrixException or a {@link MetaMatrixRuntimeException}, the code will be set to the exception's code.
+ * @param e The exception to chain to this exception
+ * @param message The error message or a resource bundle key
+ */
+ public QueryTestFailedException(final Throwable e, final String message) {
+ setChild( e );
+ // The following setMessage call should be executed after attempting to set the code from the passed-in exception
+ setMessage(message, null);
+
+ }
+
+
+ /**
+ * Construct an instance with the linked exception, error code, and error message specified. If the message is actually a
+ * key, the error message will be retrieved from a resource bundle using the key.
+ * @param e The exception to chain to this exception
+ * @param code The error code
+ * @param message The error message or a resource bundle key
+ */
+ public QueryTestFailedException(final Throwable e, final String code, final String message) {
+ setChild(e);
+ setMessage(message, null);
+ // The following setCode call should be executed after setting the message
+ setCode(code);
+ }
+
+ //############################################################################################################################
+ //# Methods #
+ //############################################################################################################################
+
+ /**
+ * Get the exception which is linked to this exception.
+ *
+ * @return The linked exception
+ */
+ public Throwable getChild() {
+ return this.child;
+ }
+
+ /**
+ * Get the error code.
+ *
+ * @return The error code
+ */
+ public String getCode() {
+ return this.code;
+ }
+
+ /**
+ * Returns the error message, formatted for output. <P>
+ *
+ * The default formatting provided by this method is to prepend the
+ * error message with the level and the name of the class, and to
+ * append the error code on the end if a non-zero code is defined. <P>
+ *
+ * This method provides a hook for subclasses to override the default
+ * formatting of any one exception.
+ *
+ * @param except The exception to print
+ * @param level The depth of the exception in the chain of exceptions
+ * @return A formatted string for the exception
+ */
+ public String getFormattedMessage(final Throwable throwable, final int level) {
+
+ return ((level != 0) ? ("\n" + level + " ") : "" ) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ + "[" + getClassShortName(throwable.getClass()) + "]" //$NON-NLS-1$ //$NON-NLS-2$
+ + ((code != null) ? (' ' + code + ": ") : "") //$NON-NLS-1$//$NON-NLS-2$
+ + (throwable.getMessage() == null ? "" : throwable.getMessage()); //$NON-NLS-1$
+ }
+
+ /**
+ * Get the full error message, including any message(s) from child
+ * exceptions. Messages of any exceptions chained to this exception are
+ * prepended with their "level" in the chain.
+ *
+ * @return The full error message
+ *
+ * @see #getFormattedMessage
+ */
+ public String getFullMessage() {
+ return MetaMatrixExceptionUtil.getLinkedMessages(this, 0 );
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Throwable#getMessage()
+ */
+ public String getMessage() {
+ return this.msg;
+ }
+
+ /**
+ * Set the exception which is linked to this exception. <P>
+ *
+ * For the special case of an InvocationTargetException, which is
+ * a wrapped exception provided in the <CODE>java.lang.reflect</CODE>
+ * package, the child is set to the wrapped exception, and the message,
+ * if not yet defined, is set to the message of the wrapped exception.
+ *
+ * @param child The linked exception
+ */
+ public void setChild( Throwable child ) {
+ // Special processing in case this is already a wrapped exception
+ if ( child instanceof java.lang.reflect.InvocationTargetException ) {
+ this.child = ((java.lang.reflect.InvocationTargetException)child).getTargetException();
+ } else {
+ this.child = child;
+ }
+ }
+
+ /**
+ * Set the error code.
+ *
+ * @param code The error code
+ */
+ public void setCode( String code ) {
+ this.code = code;
+ }
+
+ /**
+ * Sets the exception message to the specified text. If the message is actually a resource bundle key, the actual message
+ * will be retrieved using that key, the specified parameters will be substituted for placeholders within the message, and the
+ * code will be set to the key.
+ * @param message The message text or a resource bundle message key.
+ * @param parameters The list of parameters to substitute for placeholders in the retrieved message.
+ * @since 3.1
+ */
+ private void setMessage(final String message, final List parameters) {
+ if (message == null) {
+ this.msg = message;
+ } else {
+ final String msg = message;
+// final String msg = TextManager.INSTANCE.getText(message, parameters);
+ final int len = msg.length();
+ if (msg.startsWith("<") && len >= 2) { //$NON-NLS-1$
+ this.msg = msg.substring(1, len - 1);
+ } else {
+ this.msg = msg;
+ setCode(message);
+ }
+ }
+ }
+
+ /**
+ * Returns a string representation of this class.
+ *
+ * @return String representation of instance
+ */
+ public String toString() {
+ return getFullMessage();
+ }
+
+ // =========================================================================
+ // T E S T M E T H O D S
+ // =========================================================================
+
+ /**
+ * Test program for this class.
+ *
+ * @args The command line arguments
+ */
+
+ /*
+ public static void main( String[] args ) {
+ class TestAppException extends MetaMatrixException {
+ public TestAppException( Throwable e ) {
+ super( e );
+ }
+ public TestAppException( Throwable e, String message ) {
+ super( e, message );
+ }
+ } // END INNER CLASS
+
+ System.out.println( "\n2 MetaMatrixExceptions and 1 Exception..." );
+ try {
+ throw new MetaMatrixException(
+ new MetaMatrixException(
+ new Exception( "Non-chained exception" ),
+ "Nested Error" ),
+ "My App Error" );
+ } catch ( MetaMatrixException e ) {
+ System.out.println( "Message is \n" + e.getMessage() );
+ System.out.println( "Full message is \n" + e.getFullMessage() );
+ }
+
+ System.out.println( "\n2 MetaMatrixExceptions..." );
+ try {
+ throw new MetaMatrixException(
+ new MetaMatrixException( 1001, "Nested Error" ),
+ "My App Error" );
+ } catch ( MetaMatrixException e ) {
+ System.out.println( "Message is \n" + e.getMessage() );
+ System.out.println( "Full message is \n" + e.getFullMessage() );
+ }
+
+ System.out.println( "\n2 MetaMatrixExceptions (1 a subclass)..." );
+ try {
+ throw new TestAppException(
+ new MetaMatrixException( 1001, "Nested Error" ),
+ "My App Error" );
+ } catch ( MetaMatrixException e ) {
+ System.out.println( "Message is \n" + e.getMessage() );
+ System.out.println( "Full message is \n" + e.getFullMessage() );
+ }
+
+ System.out.println( "\n2 exceptions (1 MetaMatrixException, 1 null)..." );
+ try {
+ throw new TestAppException(
+ new MetaMatrixException( null, "Nested Error" ),
+ "My App Error" );
+ } catch ( MetaMatrixException e ) {
+ System.out.println( "Message is \n" + e.getMessage() );
+ System.out.println( "Full message is \n" + e.getFullMessage() );
+ }
+
+ System.out.println( "\n1 MetaMatrixException..." );
+ try {
+ throw new MetaMatrixException( 1002, "My App Error" );
+ } catch ( MetaMatrixException e ) {
+ System.out.println( "Message is \n" + e.getMessage() );
+ System.out.println( "Full message is \n" + e.getFullMessage() );
+ }
+
+ System.out.println( "\n5 MetaMatrixExceptions..." );
+ try {
+ MetaMatrixException root = new MetaMatrixException( 50, "Root" );
+ MetaMatrixException cur = root;
+ MetaMatrixException next;
+ for ( int i = 1; i <= 5; i++ ) {
+ next = new MetaMatrixException( 50+i, "Nested exception " + i );
+ cur.setChild( next );
+ cur = next;
+ }
+ throw root;
+ } catch ( MetaMatrixException e ) {
+ System.out.println( "Message is \n" + e.getMessage() );
+ System.out.println( "Full message is \n" + e.getFullMessage() );
+ }
+
+ System.out.println( "\n1 MetaMatrixException (InvocationTargetException)..." );
+ try {
+ throw new TestAppException(
+ new java.lang.reflect.InvocationTargetException(
+ new java.lang.IllegalArgumentException( "You can't do that!" ) ) );
+ } catch ( MetaMatrixException e ) {
+ System.out.println( "Message is \n" + e.getMessage() );
+ System.out.println( "Full message is \n" + e.getFullMessage() );
+ }
+ }
+ */
+ } // END CLASS
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/QueryTestFailedException.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/TransactionRuntimeException.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/TransactionRuntimeException.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/TransactionRuntimeException.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,23 @@
+package org.teiid.test.framework.exception;
+
+/**
+ * The TransactionRuntimeException is thrown outside of running a test.
+ * When this is thrown, the testing process should stop.
+ *
+ *
+ * @author vanhalbert
+ *
+ */
+public class TransactionRuntimeException extends RuntimeException{
+ /**
+ * @since
+ */
+ private static final long serialVersionUID = 1L;
+
+ public TransactionRuntimeException(Exception e){
+ super(e);
+ }
+ public TransactionRuntimeException(String msg){
+ super(msg);
+ }
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/TransactionRuntimeException.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/JNDITransaction.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/JNDITransaction.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/JNDITransaction.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.transaction;
+
+import javax.naming.InitialContext;
+import javax.transaction.UserTransaction;
+
+import org.teiid.test.framework.TransactionContainer;
+import org.teiid.test.framework.TransactionQueryTest;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+import org.teiid.test.framework.connection.ConnectionStrategy;
+
+
+
+
+public class JNDITransaction extends TransactionContainer {
+ UserTransaction userTxn = null;
+
+ public JNDITransaction(ConnectionStrategy strategy) {
+ super(strategy);
+ }
+
+ protected void before(TransactionQueryTest test) {
+ if (this.props.getProperty(ConnectionStrategy.JNDINAME_USERTXN) == null) {
+ throw new TransactionRuntimeException("No JNDI name found for the User Transaction to look up in application server");
+ }
+
+ try {
+
+ // begin the transaction
+ InitialContext ctx = new InitialContext();
+ this.userTxn = (UserTransaction)ctx.lookup(this.props.getProperty(ConnectionStrategy.JNDINAME_USERTXN));
+ this.userTxn.begin();
+ } catch (Exception e) {
+ throw new TransactionRuntimeException(e);
+ }
+ }
+
+ protected void after(TransactionQueryTest test) {
+ try {
+ if (this.userTxn != null) {
+ if (test.rollbackAllways()|| test.exceptionOccurred()) {
+ this.userTxn.rollback();
+ }
+ else {
+ this.userTxn.commit();
+ }
+ this.userTxn = null;
+ }
+ } catch (Exception e) {
+ throw new TransactionRuntimeException(e);
+ }
+ }
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/JNDITransaction.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.transaction;
+
+import java.sql.SQLException;
+
+import org.teiid.test.framework.TransactionContainer;
+import org.teiid.test.framework.TransactionQueryTest;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+import org.teiid.test.framework.connection.ConnectionStrategy;
+
+
+
+/**
+ * A transaction which is user controlled.
+ */
+public class LocalTransaction extends TransactionContainer {
+
+ public LocalTransaction(ConnectionStrategy strategy) {
+ super(strategy);
+
+// this.props.setProperty(ConnectionStrategy.TXN_AUTO_WRAP, ConnectionStrategy.AUTO_WRAP_OFF);
+ }
+
+ protected void before(TransactionQueryTest test) {
+ try {
+ test.getConnection().setAutoCommit(this.connStrategy.getAutocommit());
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ protected void after(TransactionQueryTest test) {
+ try {
+ if (test.rollbackAllways()|| test.exceptionOccurred()) {
+ test.getConnection().rollback();
+
+ }
+ else {
+ test.getConnection().commit();
+ }
+ } catch (SQLException e) {
+ throw new TransactionRuntimeException(e);
+ } finally {
+ try {
+ test.getConnection().setAutoCommit(true);
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/LocalTransaction.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/TransactionFactory.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/TransactionFactory.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/TransactionFactory.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.transaction;
+
+import org.teiid.test.framework.TransactionContainer;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+import org.teiid.test.framework.connection.ConnectionStrategy;
+import org.teiid.test.framework.connection.ConnectionStrategyFactory;
+
+
+
+public class TransactionFactory {
+
+ public static final String LOCAL_TRANSACTION = "local"; //$NON-NLS-1$
+ public static final String XATRANSACTION = "xa"; //$NON-NLS-1$
+ public static final String JNDI_TRANSACTION = "jndi"; //$NON-NLS-1$
+// public static final String OFFWRAP_TRANSACTION = "offwrap"; //$NON-NLS-1$
+// public static final String ONWRAP_TRANSACTION = "onwrap"; //$NON-NLS-1$
+
+
+
+ /**
+ * Transaction Type indicates the type of transaction container to use
+ */
+ public static final String TRANSACTION_TYPE = "transaction-type"; //$NON-NLS-1$
+// public static final String AUTOCOMMIT = "autocommit"; //$NON-NLS-1$
+
+
+ private TransactionFactory(){}
+
+
+ public static TransactionContainer create() {
+ TransactionContainer transacton = null;
+
+ ConnectionStrategy connstrategy = ConnectionStrategyFactory.getInstance().getConnectionStrategy();
+
+
+ String type = connstrategy.getEnvironment().getProperty(TRANSACTION_TYPE, LOCAL_TRANSACTION);
+ if (type == null) {
+ throw new RuntimeException("Property " + TRANSACTION_TYPE + " was specified");
+ }
+
+ if (type.equalsIgnoreCase(LOCAL_TRANSACTION)) {
+ transacton = new LocalTransaction(connstrategy);
+ }
+ else if (type.equalsIgnoreCase(XATRANSACTION)) {
+ transacton = new XATransaction(connstrategy);
+ }
+ else if (type.equalsIgnoreCase(JNDI_TRANSACTION)) {
+ transacton = new JNDITransaction(connstrategy);
+
+ } else {
+ new TransactionRuntimeException("Invalid property value of " + type + " for " + TRANSACTION_TYPE );
+ }
+
+ return transacton;
+ }
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/TransactionFactory.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/XATransaction.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/XATransaction.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/XATransaction.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2000-2007 MetaMatrix, Inc.
+ * All rights reserved.
+ */
+package org.teiid.test.framework.transaction;
+
+import java.util.Random;
+
+import javax.transaction.xa.XAResource;
+
+import org.teiid.test.framework.TransactionContainer;
+import org.teiid.test.framework.TransactionQueryTest;
+import org.teiid.test.framework.exception.TransactionRuntimeException;
+import org.teiid.test.framework.connection.ConnectionStrategy;
+
+import com.metamatrix.common.xa.MMXid;
+
+public class XATransaction extends TransactionContainer {
+ private static Random RANDOM = new Random();
+ private MMXid xid;
+
+ public XATransaction(ConnectionStrategy strategy) {
+ super(strategy);
+ }
+
+ protected void before(TransactionQueryTest test) {
+ try {
+ xid = createXid();
+ XAResource xaResource = getXAConnection().getXAResource();
+ xaResource.setTransactionTimeout(120);
+ xaResource.start(xid, XAResource.TMNOFLAGS);
+ } catch (Exception e) {
+ throw new TransactionRuntimeException(e);
+ }
+ }
+
+ public static MMXid createXid() {
+ byte[] gid = new byte[10];
+ byte[] bid = new byte[10];
+ RANDOM.nextBytes(gid);
+ RANDOM.nextBytes(bid);
+ return new MMXid(0, gid, bid);
+ }
+
+ protected void after(TransactionQueryTest test) {
+ boolean delistSuccessful = false;
+ boolean commit = false;
+ try {
+ XAResource xaResource = getXAConnection().getXAResource();
+
+ xaResource.end(xid, XAResource.TMSUCCESS);
+
+ if (!test.exceptionExpected() && xaResource.prepare(xid) == XAResource.XA_OK) {
+ commit = true;
+ }
+ delistSuccessful = true;
+ } catch (Exception e) {
+ throw new TransactionRuntimeException(e);
+ } finally {
+ try {
+ if (!delistSuccessful || test.rollbackAllways()|| test.exceptionOccurred()) {
+ getXAConnection().getXAResource().rollback(xid);
+ }
+ else if (commit) {
+ getXAConnection().getXAResource().commit(xid, true);
+ }
+ } catch (Exception e) {
+ throw new TransactionRuntimeException(e);
+ }
+ }
+ }
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/XATransaction.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/util/ArgCheck.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/util/ArgCheck.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/util/ArgCheck.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,534 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA.
+ */
+
+package org.teiid.test.util;
+
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * This class contains a set of static utility methods for checking method arguments.
+ * It contains many of the common checks that are done, such as checking that an
+ * Object is non-null, checking the range of a value, etc. All of these methods
+ * throw {@link #java.lang.IllegalArgumentException}.
+ */
+public class ArgCheck {
+
+ /**
+ * Can't construct - utility class
+ */
+ private ArgCheck() {
+ }
+
+ /**
+ * Check that the boolean condition is true; throw an
+ * IllegalArgumentException if not.
+ * @param condition The boolean condition to check
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException if condition is false
+ */
+ public static final void isTrue(boolean condition, String message){
+ if(!condition) {
+ throw new IllegalArgumentException(message);
+ }
+ }
+
+ // ########################## int METHODS ###################################
+
+ /**
+ * Check that the value is non-negative (>=0).
+ * @param value Value
+ * @throws IllegalArgumentException If value is negative (<0)
+ */
+ public static final void isNonNegative(int value) {
+ isNonNegative(value,null);
+ }
+
+ /**
+ * Check that the value is non-negative (>=0).
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is negative (<0)
+ */
+ public static final void isNonNegative(int value, String message) {
+ if(value < 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isNonNegativeInt"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the value is non-positive (<=0).
+ * @param value Value
+ * @throws IllegalArgumentException If value is positive (>0)
+ */
+ public static final void isNonPositive(int value) {
+ isNonPositive(value,null);
+ }
+
+ /**
+ * Check that the value is non-positive (<=0).
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is positive (>0)
+ */
+ public static final void isNonPositive(int value, String message) {
+ if(value > 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isNonPositiveInt"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the value is negative (<0).
+ * @param value Value
+ * @throws IllegalArgumentException If value is non-negative (>=0)
+ */
+ public static final void isNegative(int value) {
+ isNegative(value,null);
+ }
+
+ /**
+ * Check that the value is negative (<0).
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is non-negative (>=0)
+ */
+ public static final void isNegative(int value, String message) {
+ if(value >= 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isNegativeInt"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the value is positive (>0).
+ * @param value Value
+ * @throws IllegalArgumentException If value is non-positive (<=0)
+ */
+ public static final void isPositive(int value) {
+ isPositive(value,null);
+ }
+
+ /**
+ * Check that the value is positive (>0).
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is non-positive (<=0)
+ */
+ public static final void isPositive(int value, String message) {
+ if(value <= 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isPositiveInt"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ // ########################## long METHODS ###################################
+
+ /**
+ * Check that the value is non-negative (>=0).
+ * @param value Value
+ * @throws IllegalArgumentException If value is negative (<0)
+ */
+ public static final void isNonNegative(long value) {
+ isNonNegative(value,null);
+ }
+
+ /**
+ * Check that the value is non-negative (>=0).
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is negative (<0)
+ */
+ public static final void isNonNegative(long value, String message) {
+ if(value < 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isNonNegativeInt"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the value is non-positive (<=0).
+ * @param value Value
+ * @throws IllegalArgumentException If value is positive (>0)
+ */
+ public static final void isNonPositive(long value) {
+ isNonPositive(value,null);
+ }
+
+ /**
+ * Check that the value is non-positive (<=0).
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is positive (>0)
+ */
+ public static final void isNonPositive(long value, String message) {
+ if(value > 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isNonPositiveInt"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the value is negative (<0).
+ * @param value Value
+ * @throws IllegalArgumentException If value is non-negative (>=0)
+ */
+ public static final void isNegative(long value) {
+ isNegative(value,null);
+ }
+
+ /**
+ * Check that the value is negative (<0).
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is non-negative (>=0)
+ */
+ public static final void isNegative(long value, String message) {
+ if(value >= 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isNegativeInt"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the value is positive (>0).
+ * @param value Value
+ * @throws IllegalArgumentException If value is non-positive (<=0)
+ */
+ public static final void isPositive(long value) {
+ isPositive(value,null);
+ }
+
+ /**
+ * Check that the value is positive (>0).
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is non-positive (<=0)
+ */
+ public static final void isPositive(long value, String message) {
+ if(value <= 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isPositiveInt"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ // ########################## String METHODS ###################################
+
+ /**
+ * Check that the string is non-null and has length > 0
+ * @param value Value
+ * @throws IllegalArgumentException If value is null or length == 0
+ */
+ public static final void isNotZeroLength(String value) {
+ isNotZeroLength(value,null);
+ }
+
+ /**
+ * Check that the string is non-null and has length > 0
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is null or length == 0
+ */
+ public static final void isNotZeroLength(String value, String message) {
+ isNotNull(value);
+ if(value.length() <= 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isStringNonZeroLength"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ // ########################## Object METHODS ###################################
+
+ /**
+ * Check that the object is non-null
+ * @param value Value
+ * @throws IllegalArgumentException If value is null
+ */
+ public static final void isNotNull(Object value) {
+ isNotNull(value,null);
+ }
+
+ /**
+ * Check that the object is non-null
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is null
+ */
+ public static final void isNotNull(Object value, String message) {
+ if(value == null) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isNonNull"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the object is null
+ * @param value Value
+ * @throws IllegalArgumentException If value is non-null
+ */
+ public static final void isNull(Object value) {
+ isNull(value,null);
+ }
+
+ /**
+ * Check that the object is null
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is non-null
+ */
+ public static final void isNull(Object value, String message) {
+ if(value != null) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isNull"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the object is an instance of the specified Class
+ * @param theClass Class
+ * @param value Value
+ * @throws IllegalArgumentException If value is null
+ */
+ public static final void isInstanceOf(Class theClass, Object value) {
+ isInstanceOf(theClass,value,null);
+ }
+
+ /**
+ * Check that the object is an instance of the specified Class
+ * @param theClass Class
+ * @param value Value
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If value is null
+ */
+ public static final void isInstanceOf(Class theClass, Object value, String message) {
+ isNotNull(value);
+ if( ! theClass.isInstance(value) ) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isInstanceOf "; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ // ########################## COLLECTION METHODS ###################################
+
+ /**
+ * Check that the collection is not empty
+ * @param collection Collection
+ * @throws IllegalArgumentException If collection is null or empty
+ */
+ public static final void isNotEmpty(Collection collection) {
+ isNotEmpty(collection,null);
+ }
+
+ /**
+ * Check that the collection is not empty
+ * @param collection Collection
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If collection is null or empty
+ */
+ public static final void isNotEmpty(Collection collection, String message) {
+ isNotNull(collection);
+ if(collection.isEmpty()) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isCollectionNotEmpty"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the map is not empty
+ * @param map Map
+ * @throws IllegalArgumentException If map is null or empty
+ */
+ public static final void isNotEmpty(Map map) {
+ isNotEmpty(map,null);
+ }
+
+ /**
+ * Check that the map is not empty
+ * @param map Map
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If map is null or empty
+ */
+ public static final void isNotEmpty(Map map, String message) {
+ isNotNull(map);
+ if(map.isEmpty()) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isMapNotEmpty"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the array is not empty
+ * @param array Array
+ * @throws IllegalArgumentException If array is null or empty
+ * @since 3.1
+ */
+ public static final void isNotEmpty(Object[] array) {
+ isNotEmpty(array,null);
+ }
+
+ /**
+ * Check that the array is not empty
+ * @param array Array
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If array is null or empty
+ * @since 3.1
+ */
+ public static final void isNotEmpty(Object[] array, String message) {
+ isNotNull(array);
+ if(array.length == 0) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.isArrayNotEmpty"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the string is not empty
+ * @param string String
+ * @throws IllegalArgumentException If string is null or empty
+ * @since 3.1
+ */
+ public static final void isNotEmpty(String string) {
+ isNotZeroLength(string,null);
+ }
+
+ /**
+ * Check that the string is not empty
+ * @param string String
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If string is null or empty
+ * @since 3.1
+ */
+ public static final void isNotEmpty(String string, String message) {
+ isNotZeroLength(string,message);
+ }
+
+ /**
+ * Asserts that the specified first object is not the same as (==) the specified second object.
+ * @param firstObject The first object to assert as not the same as the second object.
+ * @param firstName The name that will be used within the exception message for the first object, should an exception be
+ * thrown; if null and <code>firstObject</code> is not null, <code>firstObject.toString()</code> will be
+ * used.
+ * @param secondObject The second object to assert as not the same as the first object.
+ * @param secondName The name that will be used within the exception message for the second object, should an exception be
+ * thrown; if null and <code>secondObject</code> is not null, <code>secondObject.toString()</code> will
+ * be used.
+ * @throws IllegalArgumentException If the specified objects are the same.
+ * @since 3.1
+ */
+ public static void isNotSame(final Object firstObject, String firstName, final Object secondObject, String secondName) {
+ if (firstObject == secondObject) {
+ if (firstName == null && firstObject != null) {
+ firstName = firstObject.toString();
+ }
+ if (secondName == null && secondObject != null) {
+ secondName = secondObject.toString();
+ }
+ throw new IllegalArgumentException("ArgCheck.isNotSame"); //$NON-NLS-1$
+ }
+ }
+
+ /**
+ * Check that the collection contains the value
+ * @param collection Collection to check
+ * @param value Value to check for, may be null
+ * @throws IllegalArgumentException If collection is null or doesn't contain value
+ */
+ public static final void contains(Collection collection, Object value) {
+ contains(collection, value, null);
+ }
+
+ /**
+ * Check that the collection contains the value
+ * @param collection Collection to check
+ * @param value Value to check for, may be null
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If collection is null or doesn't contain value
+ */
+ public static final void contains(Collection collection, Object value, String message) {
+ isNotNull(collection);
+ if(! collection.contains(value)) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.contains"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ /**
+ * Check that the map contains the key
+ * @param map Map to check
+ * @param key Key to check for, may be null
+ * @throws IllegalArgumentException If map is null or doesn't contain key
+ */
+ public static final void containsKey(Map map, Object key) {
+ containsKey(map, key, null);
+ }
+
+ /**
+ * Check that the map contains the key
+ * @param map Map to check
+ * @param key Key to check for, may be null
+ * @param message Exception message if check fails
+ * @throws IllegalArgumentException If map is null or doesn't contain key
+ */
+ public static final void containsKey(Map map, Object key, String message) {
+ isNotNull(map);
+ if(! map.containsKey(key)) {
+ final String msg = message != null ?
+ message :
+ "ArgCheck.containsKey"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/util/ArgCheck.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/util/ChecksumUtil.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/util/ChecksumUtil.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/util/ChecksumUtil.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,97 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA.
+ */
+
+package org.teiid.test.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.CRC32;
+import java.util.zip.Checksum;
+
+/**
+ * This utility class provides mechanisms for computing the checksum.
+ */
+public class ChecksumUtil {
+
+ protected static final int BUFFER_SIZE = 1024;
+
+ /**
+ * Compute and return the checksum (using the default CRC-32 algorithm)
+ * of the contents on the specified stream.
+ * This method closes the stream upon completion.
+ * @param stream the stream containing the contents for which
+ * the checksum is to be computed; may not be null
+ * @return the Checksum for the contents
+ * @throws AssertionError if <code>stream</code> is null
+ * @throws IOException if there is an error reading the stream
+ */
+ public static Checksum computeChecksum( InputStream stream ) throws IOException {
+ Checksum checksum = new CRC32();
+ computeChecksum(stream,checksum);
+ return checksum;
+ }
+
+ /**
+ * Compute the checksum of the contents on the specified stream
+ * using the supplied Checksum algorithm, and modify that
+ * Checksum instance with the checksum value.
+ * This method closes the stream upon completion.
+ * @param stream the stream containing the contents for which
+ * the checksum is to be computed; may not be null
+ * @param algorithm the checksum algorithm to be used.
+ * @return the number of bytes from <code>stream</code>
+ * that were processed
+ * @throws AssertionError if <code>stream</code> or
+ * <code>algorithm</code> is null
+ * @throws IOException if there is an error reading the stream
+ */
+ public static long computeChecksum( InputStream stream, Checksum algorithm ) throws IOException {
+ byte[] buffer = new byte[BUFFER_SIZE];
+ int n = 0;
+ long sizeInBytes = 0;
+
+ // Compute the checksum ...
+ IOException ioe = null;
+ try {
+ while ((n = stream.read(buffer)) > -1){
+ algorithm.update(buffer, 0, n);
+ sizeInBytes += n;
+ }
+ } catch ( IOException e ) {
+ ioe = e;
+ } finally {
+ try {
+ stream.close();
+ } catch ( IOException e ) {
+ //Throw this only if there was no IOException from processing above
+ if ( ioe == null ) {
+ ioe = e;
+ }
+ }
+ }
+ if ( ioe != null ) {
+ throw ioe;
+ }
+ return sizeInBytes;
+ }
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/util/ChecksumUtil.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/util/FileUtils.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/util/FileUtils.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/util/FileUtils.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,871 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA.
+ */
+
+package org.teiid.test.util;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileFilter;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+
+public final class FileUtils {
+
+ public interface Constants {
+ char CURRENT_FOLDER_SYMBOL_CHAR = '.';
+ char DRIVE_SEPARATOR_CHAR = ':';
+ char FILE_EXTENSION_SEPARATOR_CHAR = '.';
+ char FILE_NAME_WILDCARD_CHAR = '*';
+
+ String CURRENT_FOLDER_SYMBOL = String.valueOf(CURRENT_FOLDER_SYMBOL_CHAR);
+ String DRIVE_SEPARATOR = String.valueOf(DRIVE_SEPARATOR_CHAR);
+ String FILE_EXTENSION_SEPARATOR = String.valueOf(FILE_EXTENSION_SEPARATOR_CHAR);
+ String FILE_NAME_WILDCARD = String.valueOf(FILE_NAME_WILDCARD_CHAR);
+ String PARENT_FOLDER_SYMBOL = ".."; //$NON-NLS-1$
+ }
+
+ public static final char SEPARATOR = '/';
+
+ public static int DEFAULT_BUFFER_SIZE = 2048;
+ public static String TEMP_DIRECTORY;
+ public static String LINE_SEPARATOR = System.getProperty("line.separator"); //$NON-NLS-1$
+ public static char[] LINE_SEPARATOR_CHARS = LINE_SEPARATOR.toCharArray();
+
+ public final static String JAVA_IO_TEMP_DIR="java.io.tmpdir";//$NON-NLS-1$
+ public final static char[] SUFFIX_class = ".class".toCharArray(); //$NON-NLS-1$
+ public final static char[] SUFFIX_CLASS = ".CLASS".toCharArray(); //$NON-NLS-1$
+ public final static char[] SUFFIX_java = ".java".toCharArray(); //$NON-NLS-1$
+ public final static char[] SUFFIX_JAVA = ".JAVA".toCharArray(); //$NON-NLS-1$
+ public final static char[] SUFFIX_jar = ".jar".toCharArray(); //$NON-NLS-1$
+ public final static char[] SUFFIX_JAR = ".JAR".toCharArray(); //$NON-NLS-1$
+ public final static char[] SUFFIX_zip = ".zip".toCharArray(); //$NON-NLS-1$
+ public final static char[] SUFFIX_ZIP = ".ZIP".toCharArray(); //$NON-NLS-1$
+
+
+ private static final String TEMP_FILE = "delete.me"; //$NON-NLS-1$
+ private static final String TEMP_FILE_RENAMED = "delete.me.old"; //$NON-NLS-1$
+
+
+
+ static {
+ String tempDirPath = System.getProperty(JAVA_IO_TEMP_DIR);
+ TEMP_DIRECTORY = (tempDirPath.endsWith(File.separator) ? tempDirPath : tempDirPath + File.separator);
+ }
+
+ private FileUtils() {}
+
+ /**<p>
+ * Convert the specified file name to end with the specified extension if it doesn't already end with an extension.
+ * </p>
+ * @param name
+ * The file name.
+ * @param extension
+ * The extension to append to the file name.
+ * @return The file name with an extension.
+ * @since 4.0
+ */
+ public static String toFileNameWithExtension(final String name,
+ final String extension) {
+ return toFileNameWithExtension(name, extension, false);
+ }
+
+ /**<p>
+ * Convert the specified file name to end with the specified extension if it doesn't already end with an extension. If force
+ * is true, the specified extension will be appended to the name if the name doesn't end with that particular extension.
+ * </p>
+ * @param name
+ * The file name.
+ * @param extension
+ * The extension to append to the file name.
+ * @param force
+ * Indicates whether to force the specified extension as the extension of the file name.
+ * @return The file name with an extension.
+ * @since 4.0
+ */
+ public static String toFileNameWithExtension(final String name,
+ final String extension,
+ final boolean force) {
+ if (name == null) {
+ final String msg = "FileUtils.The_name_of_the_file_may_not_be_null"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ if (extension == null) {
+ final String msg = "FileUtils.The_file_extension_may_not_be_null"; //$NON-NLS-1$
+ throw new IllegalArgumentException(msg);
+ }
+ if (name.endsWith(extension)) {
+ return name;
+ }
+ if (!force && name.indexOf(Constants.FILE_EXTENSION_SEPARATOR_CHAR) >= 0) {
+ return name;
+ }
+ final int nameLen = name.length() - 1;
+ final int extLen = extension.length();
+ final boolean nameEndsWithExtChr = (nameLen >= 0 && name.charAt(nameLen) == Constants.FILE_EXTENSION_SEPARATOR_CHAR);
+ final boolean extBeginsWithExtChr = (extLen > 0 && extension.charAt(0) == Constants.FILE_EXTENSION_SEPARATOR_CHAR);
+ if (nameEndsWithExtChr && extBeginsWithExtChr) {
+ return name.substring(0, nameLen) + extension;
+ }
+ if (!nameEndsWithExtChr && !extBeginsWithExtChr) {
+ return name + Constants.FILE_EXTENSION_SEPARATOR + extension;
+ }
+ return name + extension;
+ }
+
+ /**
+ * Determine whether the specified name is valid for a file or folder on the current file system.
+ * @param newName the new name to be checked
+ * @return true if the name is null or contains no invalid characters for a folder or file, or false otherwise
+ */
+ public static boolean isFilenameValid( String newName ) {
+ return true; //TODO: just catch an exception when the file is accessed or created
+ }
+
+ /**
+ * Copy a file. Overwrites the destination file if it exists.
+ * @param fromFileName
+ * @param toFileName
+ * @throws Exception
+ * @since 4.3
+ */
+ public static void copy(String fromFileName, String toFileName) throws IOException {
+ copy(fromFileName, toFileName, true);
+ }
+
+ /**
+ * Copy a file
+ * @param fromFileName
+ * @param toFileName
+ * @param overwrite whether to overwrite the destination file if it exists.
+ * @throws MetaMatrixCoreException
+ * @since 4.3
+ */
+ public static void copy(String fromFileName, String toFileName, boolean overwrite) throws IOException {
+ File toFile = new File(toFileName);
+
+ if (toFile.exists()) {
+ if (overwrite) {
+ toFile.delete();
+ } else {
+ final String msg = "FileUtils.File_already_exists " + toFileName; //$NON-NLS-1$
+ throw new IOException(msg);
+ }
+ }
+
+ File fromFile = new File(fromFileName);
+ if (!fromFile.exists()) {
+ throw new FileNotFoundException("FileUtils.File_does_not_exist " + fromFileName); //$NON-NLS-1$
+ }
+
+ FileInputStream fis = null;
+ try {
+ fis = new FileInputStream(fromFile);
+ write(fis, toFileName);
+ } finally {
+ if (fis != null) {
+ fis.close();
+ }
+ }
+ }
+
+ /**
+ * Copy recursively the contents of <code>sourceDirectory</code> to
+ * the <code>targetDirectory</code>. Note that <code>sourceDirectory</code>
+ * will <b>NOT</b> be copied. If <code>targetDirectory</code> does not exist, it will be created.
+ * @param sourceDirectory The source directory to copy
+ * @param targetDirectory The target directory to copy to
+ * @throws Exception If the source directory does not exist.
+ * @since 4.3
+ */
+ public static void copyDirectoryContentsRecursively(File sourceDirectory, File targetDirectory) throws Exception {
+ copyRecursively(sourceDirectory, targetDirectory, false);
+ }
+
+ /**
+ * Copy file from orginating directory to the destination directory.
+ *
+ * @param orginDirectory
+ * @param destDirectory
+ * @param fileName
+ * @throws Exception
+ * @since 4.4
+ */
+ public static void copyFile(String orginDirectory,
+ String destDirectory,
+ String fileName) throws Exception {
+
+ copyFile(orginDirectory, fileName, destDirectory, fileName);
+ }
+
+ /**
+ * Copy file from orginating directory to the destination directory.
+ *
+ * @param orginDirectory
+ * @param orginFileName
+ * @param destDirectory
+ * @param destFileName
+ * @throws Exception
+ * @since 4.4
+ */
+ public static void copyFile(String orginDirectory,
+ String orginFileName,
+ String destDirectory,
+ String destFileName) throws Exception {
+
+ FileUtils.copy(orginDirectory + File.separator + orginFileName, destDirectory + File.separator + destFileName);
+ }
+
+ /**
+ * Copy recursively the <code>sourceDirectory</code> and all its contents
+ * to the <code>targetDirectory</code>. If <code>targetDirectory</code>
+ * does not exist, it will be created.
+ * @param sourceDirectory The source directory to copy
+ * @param targetDirectory The target directory to copy to
+ * @throws Exception If the source directory does not exist.
+ * @since 4.3
+ */
+ public static void copyDirectoriesRecursively(File sourceDirectory, File targetDirectory) throws Exception {
+ copyRecursively(sourceDirectory, targetDirectory, true);
+ }
+
+ /**
+ * Copy recursively from the <code>sourceDirectory</code> all its contents
+ * to the <code>targetDirectory</code>. if
+ * <code>includeSourceRoot<code> == <code>true</code>, copy <code>sourceDirectory</code>
+ * itself, else only copy <code>sourceDirectory</code>'s contents.
+ * If <code>targetDirectory</code> does not exist, it will be created.
+ * @param sourceDirectory
+ * @param targetDirectory
+ * @throws FileNotFoundException
+ * @throws Exception
+ * @since 4.3
+ */
+ private static void copyRecursively(File sourceDirectory,
+ File targetDirectory,
+ boolean includeSourceRoot) throws FileNotFoundException,
+ Exception {
+ if (!sourceDirectory.exists()) {
+ throw new FileNotFoundException("FileUtils.File_does_not_exist " + sourceDirectory); //$NON-NLS-1$
+ }
+
+ if (!sourceDirectory.isDirectory()) {
+ throw new FileNotFoundException("FileUtils.Not_a_directory " + sourceDirectory); //$NON-NLS-1$
+ }
+
+ File targetDir = new File(targetDirectory.getAbsolutePath() + File.separatorChar + sourceDirectory.getName());
+ if (includeSourceRoot) {
+ // copy source directory
+ targetDir.mkdir();
+ } else {
+ // copy only source directory contents
+ targetDir = new File(targetDirectory.getAbsolutePath() + File.separatorChar);
+ }
+ File[] sourceFiles = sourceDirectory.listFiles();
+ for (int i = 0; i < sourceFiles.length; i++) {
+ File srcFile = sourceFiles[i];
+ if (srcFile.isDirectory()) {
+ File childTargetDir = new File(targetDir.getAbsolutePath());
+ copyRecursively(srcFile, childTargetDir, true);
+ } else {
+ copy(srcFile.getAbsolutePath(), targetDir.getAbsolutePath() + File.separatorChar + srcFile.getName());
+ }
+ }
+ }
+
+ /**
+ * Write an InputStream to a file.
+ */
+ public static void write(InputStream is, String fileName) throws IOException {
+ File f = new File(fileName);
+ write(is,f);
+ }
+
+ /**
+ * Write an InputStream to a file.
+ */
+ public static void write(InputStream is, File f) throws IOException {
+ write(is, f, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * Write an InputStream to a file.
+ */
+ public static void write(InputStream is, File f, int bufferSize) throws IOException {
+ f.delete();
+ final File parentDir = f.getParentFile();
+ if (parentDir !=null) {
+ parentDir.mkdirs();
+ }
+
+ FileOutputStream fio = null;
+ BufferedOutputStream bos = null;
+ try {
+ fio = new FileOutputStream(f);
+ bos = new BufferedOutputStream(fio);
+ if (bufferSize > 0) {
+ byte[] buff = new byte[bufferSize];
+ int bytesRead;
+
+ // Simple read/write loop.
+ while(-1 != (bytesRead = is.read(buff, 0, buff.length))) {
+ bos.write(buff, 0, bytesRead);
+ }
+ }
+ bos.flush();
+ } finally {
+ if (bos != null) {
+ bos.close();
+ }
+ if (fio != null) {
+ fio.close();
+ }
+ }
+ }
+
+
+ /**
+ * Write an File to an OutputStream
+ * Note: this will not close the outputStream;
+ */
+ public static void write(File f, OutputStream outputStream) throws IOException {
+ write(f, outputStream, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * Write an File to an OutputStream
+ * Note: this will not close the outputStream;
+ */
+ public static void write(File f, OutputStream outputStream, int bufferSize) throws IOException {
+ FileInputStream fis = null;
+ try {
+ fis = new FileInputStream(f);
+ write(fis, outputStream, bufferSize);
+ } finally {
+ if (fis != null) {
+ fis.close();
+ }
+ }
+ }
+
+ /**
+ * Write the given input stream to outputstream
+ * Note: this will not close in/out streams
+ */
+ public static void write(InputStream fis, OutputStream outputStream, int bufferSize) throws IOException {
+ byte[] buff = new byte[bufferSize];
+ int bytesRead;
+
+ // Simple read/write loop.
+ while(-1 != (bytesRead = fis.read(buff, 0, buff.length))) {
+ outputStream.write(buff, 0, bytesRead);
+ }
+ outputStream.flush();
+ }
+
+ /**
+ * Write a byte array to a file.
+ */
+ public static void write(byte[] data, String fileName) throws IOException {
+ ByteArrayInputStream bais = null;
+ InputStream is = null;
+ try {
+ bais = new ByteArrayInputStream(data);
+ is = new BufferedInputStream(bais);
+
+ write(is, fileName);
+ } finally {
+ if (is != null) {
+ is.close();
+ }
+ if (bais != null) {
+ bais.close();
+ }
+ }
+ }
+
+ /**
+ * Write a byte array to a file.
+ */
+ public static void write(byte[] data, File file) throws IOException {
+ ByteArrayInputStream bais = null;
+ InputStream is = null;
+ try {
+ bais = new ByteArrayInputStream(data);
+ is = new BufferedInputStream(bais);
+
+ write(is, file);
+ } finally {
+ if (is != null) {
+ is.close();
+ }
+ if (bais != null) {
+ bais.close();
+ }
+ }
+ }
+
+ /**
+ * Returns a <code>File</code> array that will contain all the files that
+ * exist in the specified directory or any nested directories
+ * @return File[] of files in the directory
+ */
+ public static File[] findAllFilesInDirectoryRecursively(final String dir) {
+
+ // Recursively navigate through the contents of this directory
+ // gathering up all the files
+ List allFiles = new ArrayList();
+ File directory = new File(dir);
+ addFilesInDirectoryRecursively(directory, allFiles);
+
+ return (File[])allFiles.toArray(new File[allFiles.size()]);
+
+ }
+
+ private static void addFilesInDirectoryRecursively(final File directory, final List allFiles) {
+ File[] files = directory.listFiles();
+ if (files != null) {
+ for (int i=0; i < files.length; i++) {
+ File file = files[i];
+ if (file.isDirectory()) {
+ addFilesInDirectoryRecursively(file, allFiles);
+ } else {
+ allFiles.add(file);
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns a <code>File</code> array that will contain all the files that exist in the directory
+ *
+ * @return File[] of files in the directory
+ */
+ public static File[] findAllFilesInDirectory(String dir) {
+
+ // Find all files in the specified directory
+ File modelsDirFile = new File(dir);
+ FileFilter fileFilter = new FileFilter() {
+
+ public boolean accept(File file) {
+ if (file.isDirectory()) {
+ return false;
+ }
+
+ String fileName = file.getName();
+
+ if (fileName == null || fileName.length() == 0) {
+ return false;
+ }
+
+ return true;
+
+ }
+ };
+
+ File[] modelFiles = modelsDirFile.listFiles(fileFilter);
+
+ return modelFiles;
+
+ }
+
+ /**
+ * Returns a <code>File</code> array that will contain all the files that
+ * exist in the directory that have the specified extension.
+ * @return File[] of files having a certain extension
+ */
+ public static File[] findAllFilesInDirectoryHavingExtension(String dir, final String extension) {
+
+ // Find all files in that directory that end in XML and attempt to
+ // load them into the runtime metadata database.
+ File modelsDirFile = new File(dir);
+ FileFilter fileFilter = new FileFilter() {
+ public boolean accept(File file) {
+ if(file.isDirectory()) {
+ return false;
+ }
+
+
+ String fileName = file.getName();
+
+ if (fileName==null || fileName.length()==0) {
+ return false;
+ }
+
+ return (fileName.endsWith(extension));
+ // here we check to see if the file is an .xml file...
+// int index = fileName.lastIndexOf("."); //$NON-NLS-1$
+//
+// if (index<0 || index==fileName.length()) {
+// return false;
+// }
+//
+// if (fileName.substring(index, fileName.length()).equalsIgnoreCase(extension)) {
+// return true;
+// }
+// return false;
+ }
+ };
+
+ File[] modelFiles = modelsDirFile.listFiles(fileFilter);
+
+ return modelFiles;
+
+ }
+
+ /**
+ * @param string
+ * @return
+ */
+ public static String getFilenameWithoutExtension( final String filename ) {
+ if ( filename == null || filename.length() == 0 ) {
+ return filename;
+ }
+ final int extensionIndex = filename.lastIndexOf(Constants.FILE_EXTENSION_SEPARATOR_CHAR);
+ if ( extensionIndex == -1 ) {
+ return filename; // not found
+ }
+ if ( extensionIndex == 0 ) {
+ return ""; //$NON-NLS-1$
+ }
+ return filename.substring(0,extensionIndex);
+ }
+
+ public static String getBaseFileNameWithoutExtension(String path) {
+ return StringUtil.getFirstToken(StringUtil.getLastToken(path, "/"), "."); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ /**
+ * Obtains the file extension of the specified <code>File</code>. The extension is considered to be all the
+ * characters after the last occurrence of {@link Constants#FILE_EXTENSION_SEPARATOR_CHAR} in the pathname
+ * of the input.
+ * @param theFile the file whose extension is being requested
+ * @return the extension or <code>null</code> if not found
+ * @since 4.2
+ */
+ public static String getExtension(File theFile) {
+ return getExtension(theFile.getPath());
+ }
+
+ /**
+ * Obtains the file extension of the specified file name. The extension is considered to be all the
+ * characters after the last occurrence of {@link Constants#FILE_EXTENSION_SEPARATOR_CHAR}.
+ * @param theFileName the file whose extension is being requested
+ * @return the extension or <code>null</code> if not found
+ * @since 4.2
+ */
+ public static String getExtension(String theFileName) {
+ String result = null;
+ final int index = theFileName.lastIndexOf(Constants.FILE_EXTENSION_SEPARATOR_CHAR);
+
+ // make sure extension char is found and is not the last char in the path
+ if ((index != -1) && ((index + 1) != theFileName.length())) {
+ result = theFileName.substring(index + 1);
+ }
+
+ return result;
+ }
+
+ /**
+ * Returns true iff str.toLowerCase().endsWith(".jar") || str.toLowerCase().endsWith(".zip")
+ * implementation is not creating extra strings.
+ */
+ public final static boolean isArchiveFileName(String name) {
+ int nameLength = name == null ? 0 : name.length();
+ int suffixLength = SUFFIX_JAR.length;
+ if (nameLength < suffixLength) return false;
+
+ // try to match as JAR file
+ for (int i = 0; i < suffixLength; i++) {
+ char c = name.charAt(nameLength - i - 1);
+ int suffixIndex = suffixLength - i - 1;
+ if (c != SUFFIX_jar[suffixIndex] && c != SUFFIX_JAR[suffixIndex]) {
+
+ // try to match as ZIP file
+ suffixLength = SUFFIX_ZIP.length;
+ if (nameLength < suffixLength) return false;
+ for (int j = 0; j < suffixLength; j++) {
+ c = name.charAt(nameLength - j - 1);
+ suffixIndex = suffixLength - j - 1;
+ if (c != SUFFIX_zip[suffixIndex] && c != SUFFIX_ZIP[suffixIndex]) return false;
+ }
+ return true;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Returns true iff str.toLowerCase().endsWith(".class")
+ * implementation is not creating extra strings.
+ */
+ public final static boolean isClassFileName(String name) {
+ int nameLength = name == null ? 0 : name.length();
+ int suffixLength = SUFFIX_CLASS.length;
+ if (nameLength < suffixLength) return false;
+
+ for (int i = 0; i < suffixLength; i++) {
+ char c = name.charAt(nameLength - i - 1);
+ int suffixIndex = suffixLength - i - 1;
+ if (c != SUFFIX_class[suffixIndex] && c != SUFFIX_CLASS[suffixIndex]) return false;
+ }
+ return true;
+ }
+
+ /**
+ * Returns true iff str.toLowerCase().endsWith(".java")
+ * implementation is not creating extra strings.
+ */
+ public final static boolean isJavaFileName(String name) {
+ int nameLength = name == null ? 0 : name.length();
+ int suffixLength = SUFFIX_JAVA.length;
+ if (nameLength < suffixLength) return false;
+
+ for (int i = 0; i < suffixLength; i++) {
+ char c = name.charAt(nameLength - i - 1);
+ int suffixIndex = suffixLength - i - 1;
+ if (c != SUFFIX_java[suffixIndex] && c != SUFFIX_JAVA[suffixIndex]) return false;
+ }
+ return true;
+ }
+
+
+ public static File convertByteArrayToFile(final byte[] contents, final String parentDirectoryPath, final String fileName) {
+ if (contents != null) {
+ FileOutputStream os = null;
+ try {
+ final File temp = new File(parentDirectoryPath,fileName);
+ os = new FileOutputStream(temp);
+ os.write(contents);
+ return temp;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ } finally {
+ if (os != null) {
+ try {
+ os.close();
+ } catch (IOException e1) {
+ // do nothing
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ public static void removeDirectoryAndChildren(File directory) {
+ removeChildrenRecursively(directory);
+ if(!directory.delete()) {
+ directory.deleteOnExit();
+ }
+ }
+
+ public static void removeChildrenRecursively(File directory) {
+ File[] files = directory.listFiles();
+ if(files != null) {
+ for(int i=0; i < files.length; i++) {
+ File file = files[i];
+ if (file.isDirectory()) {
+ removeDirectoryAndChildren(file);
+ } else {
+ if(!file.delete()) {
+ file.deleteOnExit();
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Builds a file directory path from a physical location and a location that needs
+ * to be appended to the physical. This is used so that the correct File.separator
+ * is used and that no additional separator is added when not needed.
+ * @param physicalDirectory
+ * @param appendLocation
+ * @return
+ * @since 4.3
+ */
+ public static String buildDirectoryPath(String[] paths) {
+// String physicalDirectory, String appendLocation) {
+
+ if (paths == null || paths.length == 0) {
+ return ""; //$NON-NLS-1$
+ }
+ if (paths.length == 1) {
+ return (paths[0]!=null?paths[0]:"");//$NON-NLS-1$
+ }
+ int l = paths.length;
+ StringBuffer sb = new StringBuffer();
+ for (int cur=0;cur<l; cur++) {
+ int next = cur+1;
+
+ String value = paths[cur]!=null?paths[cur]:"";//$NON-NLS-1$
+ if (value.equals("")) {//$NON-NLS-1$
+ continue;
+ }
+ sb.append(value);
+
+ if (next < l) {
+ String nextValue = paths[next]!=null?paths[next]:"";//$NON-NLS-1$
+ if (value.endsWith(File.separator)) {
+
+ } else if (!nextValue.startsWith(File.separator)) {
+ sb.append(File.separator);
+ }
+
+ }
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ * Compute checksum for the given file.
+ * @param f The file for which checksum needs to be computed
+ * @return The checksum
+ * @since 4.3
+ */
+ public static long getCheckSum(final File f) throws Exception {
+ ArgCheck.isNotNull(f);
+ FileInputStream is = null;
+ try {
+ is = new FileInputStream(f);
+ return ChecksumUtil.computeChecksum(is).getValue();
+ } finally {
+ if (is != null) {
+ try {
+ is.close();
+ } catch (IOException err1) {
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Test whether it's possible to read and write files in the specified directory.
+ * @param dirPath Name of the directory to test
+ * @throws MetaMatrixException
+ * @since 4.3
+ */
+ public static void testDirectoryPermissions(String dirPath) throws Exception {
+
+ //try to create a file
+ File tmpFile = new File(dirPath + File.separatorChar + TEMP_FILE);
+ boolean success = false;
+ try {
+ success = tmpFile.createNewFile();
+ } catch (IOException e) {
+ }
+ if (!success) {
+ final String msg = "FileUtils.Unable_to_create_file_in " + dirPath; //$NON-NLS-1$
+ throw new Exception(msg);
+ }
+
+
+ //test if file can be written to
+ if (!tmpFile.canWrite()) {
+ final String msg = "FileUtils.Unable_to_write_file_in " + dirPath; //$NON-NLS-1$
+ throw new Exception(msg);
+ }
+
+ //test if file can be read
+ if (!tmpFile.canRead()) {
+ final String msg = "FileUtils.Unable_to_read_file_in " + dirPath; //$NON-NLS-1$
+ throw new Exception(msg);
+ }
+
+ //test if file can be renamed
+ File newFile = new File(dirPath + File.separatorChar + TEMP_FILE_RENAMED);
+ success = false;
+ try {
+ success = tmpFile.renameTo(newFile);
+ } catch (Exception e) {
+ }
+ if (!success) {
+ final String msg = "FileUtils.Unable_to_rename_file_in " + dirPath; //$NON-NLS-1$
+ throw new Exception(msg);
+ }
+
+ //test if file can be deleted
+ success = false;
+ try {
+ success = newFile.delete();
+ } catch (Exception e) {
+ }
+ if (!success) {
+ final String msg = "FileUtils.Unable_to_delete_file_in " + dirPath; //$NON-NLS-1$
+ throw new Exception(msg);
+ }
+ }
+
+ /**
+ * Rename a file.
+ * @param oldFilePath
+ * @param newFilePath
+ * @param overwrite If true, overwrite the old file if it exists. If false, throw an exception if the old file exists.
+ * @throws MetaMatrixCoreException
+ * @since 4.3
+ */
+ public static void rename(String oldFilePath, String newFilePath, boolean overwrite) throws IOException {
+ File oldFile = new File(oldFilePath);
+ File newFile = new File(newFilePath);
+
+ if (newFile.exists()) {
+ if (overwrite) {
+ newFile.delete();
+ } else {
+ final String msg = "FileUtils.File_already_exists " + newFilePath; //$NON-NLS-1$
+ throw new IOException(msg);
+ }
+ }
+
+ boolean renamed = oldFile.renameTo(newFile);
+
+ //Sometimes file.renameTo will silently fail, for example attempting to rename from different UNIX partitions.
+ //Try to copy instead.
+ if (!renamed) {
+ copy(oldFilePath, newFilePath);
+ oldFile.delete();
+ }
+ }
+
+
+
+
+
+ public static void remove(String filePath) throws IOException {
+ File file = new File(filePath);
+ if (file.exists()) {
+ file.delete();
+ }
+ }
+
+}
\ No newline at end of file
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/util/FileUtils.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/util/PropUtils.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/util/PropUtils.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/util/PropUtils.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,14 @@
+package org.teiid.test.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+import org.teiid.test.framework.connection.ConnectionStrategyFactory;
+
+public class PropUtils {
+
+
+
+
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/util/PropUtils.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Added: trunk/test-integration/db/src/main/java/org/teiid/test/util/StringUtil.java
===================================================================
--- trunk/test-integration/db/src/main/java/org/teiid/test/util/StringUtil.java (rev 0)
+++ trunk/test-integration/db/src/main/java/org/teiid/test/util/StringUtil.java 2009-09-11 19:18:01 UTC (rev 1325)
@@ -0,0 +1,906 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ *
+ * Copyright (c) 2000, 2008 IBM Corporation and others.
+ * All rights reserved.
+ * This code is made available under the terms of the Eclipse Public
+ * License, version 1.0.
+ */
+
+package org.teiid.test.util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.regex.Pattern;
+
+/**
+ * This is a common place to put String utility methods.
+ */
+public final class StringUtil {
+
+ public interface Constants {
+ char CARRIAGE_RETURN_CHAR = '\r';
+ char LINE_FEED_CHAR = '\n';
+ char NEW_LINE_CHAR = LINE_FEED_CHAR;
+ char SPACE_CHAR = ' ';
+ char DOT_CHAR = '.';
+ char TAB_CHAR = '\t';
+
+ String CARRIAGE_RETURN = String.valueOf(CARRIAGE_RETURN_CHAR);
+ String EMPTY_STRING = ""; //$NON-NLS-1$
+ String DBL_SPACE = " "; //$NON-NLS-1$
+ String LINE_FEED = String.valueOf(LINE_FEED_CHAR);
+ String NEW_LINE = String.valueOf(NEW_LINE_CHAR);
+ String SPACE = String.valueOf(SPACE_CHAR);
+ String DOT = String.valueOf(DOT_CHAR);
+ String TAB = String.valueOf(TAB_CHAR);
+
+ String[] EMPTY_STRING_ARRAY = new String[0];
+
+ // all patterns below copied from Eclipse's PatternConstructor class.
+ final Pattern PATTERN_BACK_SLASH = Pattern.compile("\\\\"); //$NON-NLS-1$
+ final Pattern PATTERN_QUESTION = Pattern.compile("\\?"); //$NON-NLS-1$
+ final Pattern PATTERN_STAR = Pattern.compile("\\*"); //$NON-NLS-1$
+ }
+
+ /**
+ * The String "'"
+ */
+ public static final String SINGLE_QUOTE = "'"; //$NON-NLS-1$
+
+ /**
+ * The name of the System property that specifies the string that should be used to separate
+ * lines. This property is a standard environment property that is usually set automatically.
+ */
+ public static final String LINE_SEPARATOR_PROPERTY_NAME = "line.separator"; //$NON-NLS-1$
+
+ /**
+ * The String that should be used to separate lines; defaults to
+ * {@link #NEW_LINE}
+ */
+ public static final String LINE_SEPARATOR = System.getProperty(LINE_SEPARATOR_PROPERTY_NAME, Constants.NEW_LINE);
+
+ public static final Comparator CASE_INSENSITIVE_ORDER = String.CASE_INSENSITIVE_ORDER;
+
+ public static final Comparator CASE_SENSITIVE_ORDER = new Comparator() {
+ /**
+ * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
+ * @since 4.2
+ */
+ public int compare(Object o1, Object o2) {
+ if ( o1 == o2 ) {
+ return 0;
+ }
+ return ((String)o1).compareTo((String)o2);
+ }
+ };
+
+ public static String getLineSeparator() {
+ return LINE_SEPARATOR;
+ }
+
+ /**
+ * Utility to return a string enclosed in ''.
+ * Creation date: (12/2/99 12:05:10 PM)
+ */
+ public static String enclosedInSingleQuotes(String aString) {
+ StringBuffer sb = new StringBuffer();
+ sb.append(SINGLE_QUOTE);
+ sb.append(aString);
+ sb.append(SINGLE_QUOTE);
+ return sb.toString();
+ }
+
+ public static String removeChars(final String value, final char[] chars) {
+ final StringBuffer result = new StringBuffer();
+ if (value != null && chars != null && chars.length > 0) {
+ final String removeChars = String.valueOf(chars);
+ for (int i = 0; i < value.length(); i++) {
+ final String character = value.substring(i, i + 1);
+ if (removeChars.indexOf(character) == -1) {
+ result.append(character);
+ }
+ }
+ } else {
+ result.append(value);
+ }
+ return result.toString();
+ }
+
+ /**
+ * Join string pieces and separate with a delimiter. Similar to the perl function of
+ * the same name. If strings or delimiter are null, null is returned. Otherwise, at
+ * least an empty string will be returned.
+ * @see #split
+ *
+ * @param strings String pieces to join
+ * @param delimiter Delimiter to put between string pieces
+ * @return One merged string
+ */
+ public static String join(List strings, String delimiter) {
+ if(strings == null || delimiter == null) {
+ return null;
+ }
+
+ StringBuffer str = new StringBuffer();
+
+ // This is the standard problem of not putting a delimiter after the last
+ // string piece but still handling the special cases. A typical way is to check every
+ // iteration if it is the last one and skip the delimiter - this is avoided by
+ // looping up to the last one, then appending just the last one.
+
+ // First we loop through all but the last one (if there are at least 2) and
+ // put the piece and a delimiter after it. An iterator is used to walk the list.
+ int most = strings.size()-1;
+ if(strings.size() > 1) {
+ Iterator iter = strings.iterator();
+ for(int i=0; i<most; i++) {
+ str.append(iter.next());
+ str.append(delimiter);
+ }
+ }
+
+ // If there is at least one element, put the last one on with no delimiter after.
+ if(strings.size() > 0) {
+ str.append(strings.get(most));
+ }
+
+ return str.toString();
+ }
+
+ /**
+ * Return a stringified version of the array.
+ * @param array the array
+ * @param delim the delimiter to use between array components
+ * @return the string form of the array
+ */
+ public static String toString( final Object[] array, final String delim ) {
+ if ( array == null ) {
+ return ""; //$NON-NLS-1$
+ }
+ if ( array.length == 0 ) {
+ return "[]"; //$NON-NLS-1$
+ }
+ final StringBuffer sb = new StringBuffer();
+ sb.append('[');
+ for (int i = 0; i < array.length; ++i) {
+ if ( i != 0 ) {
+ sb.append(delim);
+ }
+ sb.append(array[i]);
+ }
+ sb.append(']');
+ return sb.toString();
+ }
+
+ /**
+ * Return a stringified version of the array, using a ',' as a delimiter
+ * @param array the array
+ * @return the string form of the array
+ * @see #toString(Object[], String)
+ */
+ public static String toString( final Object[] array ) {
+ return toString(array,","); //$NON-NLS-1$
+ }
+
+ /**
+ * Split a string into pieces based on delimiters. Similar to the perl function of
+ * the same name. The delimiters are not included in the returned strings.
+ * @see #join
+ *
+ * @param str Full string
+ * @param splitter Characters to split on
+ * @return List of String pieces from full string
+ */
+ public static List split(String str, String splitter) {
+ StringTokenizer tokens = new StringTokenizer(str, splitter);
+ ArrayList l = new ArrayList(tokens.countTokens());
+ while(tokens.hasMoreTokens()) {
+ l.add(tokens.nextToken());
+ }
+ return l;
+ }
+
+ /**
+ * Break a string into pieces based on matching the full delimiter string in the text.
+ * The delimiter is not included in the returned strings.
+ * @param target The text to break up.
+ * @param delimiter The sub-string which is used to break the target.
+ * @return List of String from the target.
+ */
+ public static List splitOnEntireString(String target, String delimiter) {
+ ArrayList result = new ArrayList();
+ if (delimiter.length() > 0) {
+ int index = 0;
+ int indexOfNextMatch = target.indexOf(delimiter);
+ while (indexOfNextMatch > -1) {
+ result.add(target.substring(index, indexOfNextMatch));
+ index = indexOfNextMatch + delimiter.length();
+ indexOfNextMatch = target.indexOf(delimiter, index);
+ }
+ if (index <= target.length()) {
+ result.add(target.substring(index));
+ }
+ } else {
+ result.add(target);
+ }
+ return result;
+ }
+
+ /**
+ * Split a string into pieces based on delimiters preserving spaces in
+ * quoted substring as on element in the returned list. The delimiters are
+ * not included in the returned strings.
+ * @see #join
+ *
+ * @param str Full string
+ * @param splitter Characters to split on
+ * @return List of String pieces from full string
+ */
+ public static List splitPreservingQuotedSubstring(String str, String splitter) {
+ ArrayList l = new ArrayList();
+ StringTokenizer tokens = new StringTokenizer(str, splitter);
+ StringBuffer token = new StringBuffer();
+ while(tokens.hasMoreTokens()) {
+ token.setLength(0);
+ token.append(tokens.nextToken());
+ if ( token.charAt(0) == '"' ) {
+ token.deleteCharAt(0);
+ while ( tokens.hasMoreTokens() ) {
+ token.append(Constants.SPACE + tokens.nextToken());
+ if ( token.charAt(token.length() -1) == '"' ) {
+ token.deleteCharAt(token.length() - 1);
+ break;
+ }
+ }
+ }
+ l.add(token.toString().trim());
+ }
+ return l;
+ }
+
+ /*
+ * Replace a single occurrence of the search string with the replace string
+ * in the source string. If any of the strings is null or the search string
+ * is zero length, the source string is returned.
+ * @param source the source string whose contents will be altered
+ * @param search the string to search for in source
+ * @param replace the string to substitute for search if present
+ * @return source string with the *first* occurrence of the search string
+ * replaced with the replace string
+ */
+ public static String replace(String source, String search, String replace) {
+ if (source != null && search != null && search.length() > 0 && replace != null) {
+ int start = source.indexOf(search);
+ if (start > -1) {
+ return new StringBuffer(source).replace(start, start + search.length(), replace).toString();
+ }
+ }
+ return source;
+ }
+
+ /*
+ * Replace all occurrences of the search string with the replace string
+ * in the source string. If any of the strings is null or the search string
+ * is zero length, the source string is returned.
+ * @param source the source string whose contents will be altered
+ * @param search the string to search for in source
+ * @param replace the string to substitute for search if present
+ * @return source string with *all* occurrences of the search string
+ * replaced with the replace string
+ */
+ public static String replaceAll(String source, String search, String replace) {
+ if (source != null && search != null && search.length() > 0 && replace != null) {
+ int start = source.indexOf(search);
+ if (start > -1) {
+ StringBuffer newString = new StringBuffer(source);
+ replaceAll(newString, search, replace);
+ return newString.toString();
+ }
+ }
+ return source;
+ }
+
+ public static void replaceAll(StringBuffer source, String search, String replace) {
+ if (source != null && search != null && search.length() > 0 && replace != null) {
+ int start = source.toString().indexOf(search);
+ while (start > -1) {
+ int end = start + search.length();
+ source.replace(start, end, replace);
+ start = source.toString().indexOf(search, start + replace.length());
+ }
+ }
+ }
+
+ /**
+ * Simple static method to tuncate Strings to given length.
+ * @param in the string that may need tuncating.
+ * @param len the lenght that the string should be truncated to.
+ * @return a new String containing chars with length <= len or <code>null</code>
+ * if input String is <code>null</code>.
+ */
+ public static String truncString(String in, int len) {
+ String out = in;
+ if ( in != null && len > 0 && in.length() > len ) {
+ out = in.substring(0, len);
+ }
+ return out;
+ }
+
+ /**
+ * Simple utility method to wrap a string by inserting line separators creating
+ * multiple lines each with length no greater than the user specified maximum.
+ * The method parses the given string into tokens using a space delimiter then
+ * reassembling the tokens into the resulting string while inserting separators
+ * when required. If the number of characters in a single token is greater
+ * than the specified maximum, the token will not be split but instead the
+ * maximum will be exceeded.
+ * @param str the string that may need tuncating.
+ * @param maxCharPerLine the max number of characters per line
+ * @return a new String containing line separators or the original string
+ * if its length was less than the maximum.
+ */
+ public static String wrap(String str, int maxCharPerLine) {
+ int strLength = str.length();
+ if (strLength > maxCharPerLine) {
+ StringBuffer sb = new StringBuffer(str.length()+(strLength/maxCharPerLine)+1);
+ strLength = 0;
+ List tokens = StringUtil.split(str,Constants.SPACE);
+ Iterator itr = tokens.iterator();
+ while (itr.hasNext()) {
+ String token = (String) itr.next();
+ if ( strLength+token.length() > maxCharPerLine ) {
+// sb.append(getLineSeparator());
+ sb.append(Constants.NEW_LINE);
+ strLength = 0;
+ }
+ sb.append(token);
+ sb.append(Constants.SPACE);
+ strLength += token.length()+1;
+ }
+ return sb.toString();
+ }
+ return str;
+ }
+
+ /**
+ * Return the tokens in a string in a list. This is particularly
+ * helpful if the tokens need to be processed in reverse order. In that case,
+ * a list iterator can be acquired from the list for reverse order traversal.
+ *
+ * @param str String to be tokenized
+ * @param delimiter Characters which are delimit tokens
+ * @return List of string tokens contained in the tokenized string
+ */
+ public static List getTokens(String str, String delimiter) {
+ ArrayList l = new ArrayList();
+ StringTokenizer tokens = new StringTokenizer(str, delimiter);
+ while(tokens.hasMoreTokens()) {
+ l.add(tokens.nextToken());
+ }
+ return l;
+ }
+
+ /**
+ * Return the number of tokens in a string that are seperated by the delimiter.
+ *
+ * @param str String to be tokenized
+ * @param delimiter Characters which are delimit tokens
+ * @return Number of tokens seperated by the delimiter
+ */
+ public static int getTokenCount(String str, String delimiter) {
+ StringTokenizer tokens = new StringTokenizer(str, delimiter);
+ return tokens.countTokens();
+ }
+
+ /**
+ * Return the number of occurrences of token string that occurs in input string.
+ * Note: token is case sensitive.
+ *
+ * @param input
+ * @param token
+ * @return int
+ */
+ public static int occurrences(String input, String token) {
+ int num = 0;
+ int index = input.indexOf(token);
+ while (index >= 0) {
+ num++;
+ index = input.indexOf(token, index+1);
+ }
+ return num;
+ }
+
+ /**
+ * Return the last token in the string.
+ *
+ * @param str String to be tokenized
+ * @param delimiter Characters which are delimit tokens
+ * @return the last token contained in the tokenized string
+ */
+ public static String getLastToken(String str, String delimiter) {
+ if (str == null) {
+ return Constants.EMPTY_STRING;
+ }
+ int beginIndex = 0;
+ if (str.lastIndexOf(delimiter) > 0) {
+ beginIndex = str.lastIndexOf(delimiter)+1;
+ }
+ return str.substring(beginIndex,str.length());
+ }
+
+
+ /**
+ * Return the first token in the string.
+ *
+ * @param str String to be tokenized
+ * @param delimiter Characters which are delimit tokens
+ * @return the first token contained in the tokenized string
+ */
+ public static String getFirstToken(String str, String delimiter) {
+ if (str == null) {
+ return Constants.EMPTY_STRING;
+ }
+ int endIndex = str.indexOf(delimiter);
+ if (endIndex < 0) {
+ endIndex = str.length();
+ }
+ return str.substring(0,endIndex);
+ }
+
+
+ public static String computePluralForm(String str) {
+ return computePluralForm(str, Constants.EMPTY_STRING);
+ }
+
+ public static String computePluralForm(String str, String defaultValue ) {
+ if ( str == null || str.length() == 0 ) {
+ return defaultValue;
+ }
+ String result = str;
+ if ( result.endsWith("es") ) { //$NON-NLS-1$
+ // do nothing
+ } else if ( result.endsWith("ss") || //$NON-NLS-1$
+ result.endsWith("x") || //$NON-NLS-1$
+ result.endsWith("ch") || //$NON-NLS-1$
+ result.endsWith("sh") ) { //$NON-NLS-1$
+ result = result + "es"; //$NON-NLS-1$
+ } else if ( result.endsWith("y") && ! ( //$NON-NLS-1$
+ result.endsWith("ay") || //$NON-NLS-1$
+ result.endsWith("ey") || //$NON-NLS-1$
+ result.endsWith("iy") || //$NON-NLS-1$
+ result.endsWith("oy") || //$NON-NLS-1$
+ result.endsWith("uy") || //$NON-NLS-1$
+ result.equalsIgnoreCase("any") ) ) { //$NON-NLS-1$
+ result = result.substring(0, result.length()-1) + "ies"; //$NON-NLS-1$
+ } else {
+ result += "s"; //$NON-NLS-1$
+ }
+ return result;
+ }
+
+ public static String getStackTrace( final Throwable t ) {
+ final ByteArrayOutputStream bas = new ByteArrayOutputStream();
+ final PrintWriter pw = new PrintWriter(bas);
+ t.printStackTrace(pw);
+ pw.close();
+ return bas.toString();
+ }
+
+ /**
+ * Returns whether the specified text represents a boolean value, i.e., whether it equals "true" or "false"
+ * (case-insensitive).
+ * @since 4.0
+ */
+ public static boolean isBoolean(final String text) {
+ return (Boolean.TRUE.toString().equalsIgnoreCase(text) || Boolean.FALSE.toString().equalsIgnoreCase(text));
+ }
+
+ /**<p>
+ * Returns whether the specified text is either empty or null.
+ * </p>
+ * @param text The text to check; may be null;
+ * @return True if the specified text is either empty or null.
+ * @since 4.0
+ */
+ public static boolean isEmpty(final String text) {
+ return (text == null || text.length() == 0);
+ }
+
+ /**
+ * Returns the index within this string of the first occurrence of the
+ * specified substring. The integer returned is the smallest value
+ * <i>k</i> such that:
+ * <blockquote><pre>
+ * this.startsWith(str, <i>k</i>)
+ * </pre></blockquote>
+ * is <code>true</code>.
+ *
+ * @param text any string.
+ * @param str any string.
+ * @return if the str argument occurs as a substring within text,
+ * then the index of the first character of the first
+ * such substring is returned; if it does not occur as a
+ * substring, <code>-1</code> is returned. If the text or
+ * str argument is null or empty then <code>-1</code> is returned.
+ */
+ public static int indexOfIgnoreCase(final String text, final String str) {
+ if (isEmpty(text)) {
+ return -1;
+ }
+ if (isEmpty(str)) {
+ return -1;
+ }
+ final String lowerText = text.toLowerCase();
+ final String lowerStr = str.toLowerCase();
+ return lowerText.indexOf(lowerStr);
+ }
+
+ /**
+ * Tests if the string starts with the specified prefix.
+ *
+ * @param text the string to test.
+ * @param prefix the prefix.
+ * @return <code>true</code> if the character sequence represented by the
+ * argument is a prefix of the character sequence represented by
+ * this string; <code>false</code> otherwise.
+ * Note also that <code>true</code> will be returned if the
+ * prefix is an empty string or is equal to the text
+ * <code>String</code> object as determined by the
+ * {@link #equals(Object)} method. If the text or
+ * prefix argument is null <code>false</code> is returned.
+ * @since JDK1. 0
+ */
+ public static boolean startsWithIgnoreCase(final String text, final String prefix) {
+ if (isEmpty(text)) {
+ return false;
+ }
+ if (prefix == null) {
+ return false;
+ }
+ int textLength = text.length();
+ int prefixLength = prefix.length();
+ if (prefixLength == 0) {
+ return true;
+ }
+ if (prefixLength > textLength) {
+ return false;
+ }
+ char[] chArray = prefix.toCharArray();
+ for (int i = 0; i != chArray.length; ++i) {
+ char ch1 = chArray[i];
+ char ch2 = text.charAt(i);
+ if (ch1 == ch2 || Character.toLowerCase(ch1) == Character.toLowerCase(ch2)) {
+ // continue
+ } else {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Tests if the string ends with the specified suffix.
+ *
+ * @param text the string to test.
+ * @param suffix the suffix.
+ * @return <code>true</code> if the character sequence represented by the
+ * argument is a suffix of the character sequence represented by
+ * this object; <code>false</code> otherwise. Note that the
+ * result will be <code>true</code> if the suffix is the
+ * empty string or is equal to this <code>String</code> object
+ * as determined by the {@link #equals(Object)} method. If the text or
+ * suffix argument is null <code>false</code> is returned.
+ */
+ public static boolean endsWithIgnoreCase(final String text, final String suffix) {
+ if (isEmpty(text)) {
+ return false;
+ }
+ if (suffix == null) {
+ return false;
+ }
+ int textLength = text.length();
+ int suffixLength = suffix.length();
+ if (suffixLength == 0) {
+ return true;
+ }
+ if (suffixLength > textLength) {
+ return false;
+ }
+ int offset = textLength - suffixLength;
+ char[] chArray = suffix.toCharArray();
+ for (int i = 0; i != chArray.length; ++i) {
+ char ch1 = chArray[i];
+ char ch2 = text.charAt(offset + i);
+ if (ch1 == ch2 || Character.toLowerCase(ch1) == Character.toLowerCase(ch2)) {
+ // continue
+ } else {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Determine if the string passed in has all digits as its contents
+ * @param str
+ * @return true if digits; false otherwise
+ */
+ public static boolean isDigits(String str) {
+ for(int i=0; i<str.length(); i++) {
+ if(!StringUtil.isDigit(str.charAt(i))) {
+ return false;
+ }
+ }
+ return true;
+ }
+ //============================================================================================================================
+ // Constructors
+
+ /**<p>
+ * Prevents instantiation.
+ * </p>
+ * @since 4.0
+ */
+ private StringUtil() {
+ }
+
+ /*
+ * Converts user string to regular expres '*' and '?' to regEx variables.
+ * copied from eclipse's PatternConstructor
+ */
+ static String asRegEx(String pattern) {
+ // Replace \ with \\, * with .* and ? with .
+ // Quote remaining characters
+ String result1 = Constants.PATTERN_BACK_SLASH.matcher(pattern).replaceAll(
+ "\\\\E\\\\\\\\\\\\Q"); //$NON-NLS-1$
+ String result2 = Constants.PATTERN_STAR.matcher(result1).replaceAll(
+ "\\\\E.*\\\\Q"); //$NON-NLS-1$
+ String result3 = Constants.PATTERN_QUESTION.matcher(result2).replaceAll(
+ "\\\\E.\\\\Q"); //$NON-NLS-1$
+ return "\\Q" + result3 + "\\E"; //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ /**
+ * Creates a regular expression pattern from the pattern string (which is
+ * our old 'StringMatcher' format). Copied from Eclipse's PatternConstructor class.
+ *
+ * @param pattern
+ * The search pattern
+ * @param isCaseSensitive
+ * Set to <code>true</code> to create a case insensitve pattern
+ * @return The created pattern
+ */
+ public static Pattern createPattern(String pattern, boolean isCaseSensitive) {
+ if (isCaseSensitive)
+ return Pattern.compile(asRegEx(pattern));
+ return Pattern.compile(asRegEx(pattern), Pattern.CASE_INSENSITIVE
+ | Pattern.UNICODE_CASE);
+ }
+
+ /**
+ * Removes extraneous whitespace from a string. By it's nature, it will be trimmed also.
+ * @param raw
+ * @return
+ * @since 5.0
+ */
+ public static String collapseWhitespace(String raw) {
+ StringBuffer rv = new StringBuffer(raw.length());
+
+ StringTokenizer izer = new StringTokenizer(raw, " "); //$NON-NLS-1$
+ while (izer.hasMoreTokens()) {
+ String tok = izer.nextToken();
+ // Added one last check here so we don't append a "space" on the end of the string
+ rv.append(tok);
+ if( izer.hasMoreTokens() ) {
+ rv.append(' ');
+ }
+ } // endwhile
+
+ return rv.toString();
+ }
+
+ /**
+ * If input == null OR input.length() < desiredLength, pad to desiredLength with spaces.
+ * If input.length() > desiredLength, chop at desiredLength.
+ * @param input Input text
+ * @param desiredLength Desired length
+ * @return
+ * @since 5.0
+ */
+ public static String toFixedLength(String input, int desiredLength) {
+ if(input == null) {
+ input = ""; //$NON-NLS-1$
+ }
+
+ if(input.length() == desiredLength) {
+ return input;
+ }
+
+ if(input.length() < desiredLength) {
+ StringBuffer str = new StringBuffer(input);
+ int needSpaces = desiredLength - input.length();
+ for(int i=0; i<needSpaces; i++) {
+ str.append(' ');
+ }
+ return str.toString();
+ }
+
+ // Else too long - chop
+ return input.substring(0, desiredLength);
+ }
+
+
+ public static boolean isLetter(char c) {
+ return isBasicLatinLetter(c) || Character.isLetter(c);
+ }
+ public static boolean isDigit(char c) {
+ return isBasicLatinDigit(c) || Character.isDigit(c);
+ }
+ public static boolean isLetterOrDigit(char c) {
+ return isBasicLatinLetter(c) || isBasicLatinDigit(c) || Character.isLetterOrDigit(c);
+ }
+
+ public static String toUpperCase(String str) {
+ String newStr = convertBasicLatinToUpper(str);
+ if (newStr == null) {
+ return str.toUpperCase();
+ }
+ return newStr;
+ }
+
+ public static String toLowerCase(String str) {
+ String newStr = convertBasicLatinToLower(str);
+ if (newStr == null) {
+ return str.toLowerCase();
+ }
+ return newStr;
+ }
+
+ /**
+ * Create a valid filename from the given String.
+ *
+ * @param str The String to convert to a valid filename.
+ * @param defaultName The default name to use if only special characters exist.
+ * @return String A valid filename.
+ */
+ public static String createFileName(String str) {
+
+ /** Replace some special chars */
+ str = str.replaceAll(" \\| ", "_"); //$NON-NLS-1$ //$NON-NLS-2$
+ str = str.replaceAll(">", "_"); //$NON-NLS-1$ //$NON-NLS-2$
+ str = str.replaceAll(": ", "_"); //$NON-NLS-1$ //$NON-NLS-2$
+ str = str.replaceAll(" ", "_"); //$NON-NLS-1$ //$NON-NLS-2$
+ str = str.replaceAll("\\?", "_"); //$NON-NLS-1$ //$NON-NLS-2$
+ str = str.replaceAll("/", "_"); //$NON-NLS-1$ //$NON-NLS-2$
+
+ /** If filename only contains of special chars */
+ if (str.matches("[_]+")) //$NON-NLS-1$
+ str = "file"; //$NON-NLS-1$
+
+ return str;
+ }
+
+
+ /**
+ * Make the first letter uppercase
+ * @param str
+ * @return The string with the first letter being changed to uppercase
+ * @since 5.5
+ */
+ public static String firstLetterUppercase(String str) {
+ if(str == null || str.length() == 0) {
+ return null;
+ }
+ if(str.length() == 1) {
+ return str.toUpperCase();
+ }
+ return str.substring(0, 1).toUpperCase() + str.substring(1);
+ }
+
+ private static String convertBasicLatinToUpper(String str) {
+ char[] chars = str.toCharArray();
+ for (int i = 0; i < chars.length; i++) {
+ if (isBasicLatinLowerCase(chars[i])) {
+ chars[i] = (char)('A' + (chars[i] - 'a'));
+ } else if (!isBasicLatinChar(chars[i])) {
+ return null;
+ }
+ }
+ return new String(chars);
+ }
+
+ private static String convertBasicLatinToLower(String str) {
+ char[] chars = str.toCharArray();
+ for (int i = 0; i < chars.length; i++) {
+ if (isBasicLatinUpperCase(chars[i])) {
+ chars[i] = (char)('a' + (chars[i] - 'A'));
+ } else if (!isBasicLatinChar(chars[i])) {
+ return null;
+ }
+ }
+ return new String(chars);
+ }
+
+ private static boolean isBasicLatinUpperCase(char c) {
+ return c >= 'A' && c <= 'Z';
+ }
+ private static boolean isBasicLatinLowerCase(char c) {
+ return c >= 'a' && c <= 'z';
+ }
+ private static boolean isBasicLatinLetter(char c) {
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+ }
+ private static boolean isBasicLatinDigit(char c) {
+ return c >= '0' && c <= '9';
+ }
+ private static boolean isBasicLatinChar(char c) {
+ return c <= '\u007F';
+ }
+
+ /**
+ * Convert the given value to specified type.
+ * @param value
+ * @param type
+ * @return
+ */
+ @SuppressWarnings("unchecked")
+ public static <T> T valueOf(String value, Class type){
+
+ if(type == String.class) {
+ return (T) value;
+ }
+ else if(type == Boolean.class || type == Boolean.TYPE) {
+ return (T) Boolean.valueOf(value);
+ }
+ else if (type == Integer.class || type == Integer.TYPE) {
+ return (T) Integer.decode(value);
+ }
+ else if (type == Float.class || type == Float.TYPE) {
+ return (T) Float.valueOf(value);
+ }
+ else if (type == Double.class || type == Double.TYPE) {
+ return (T) Double.valueOf(value);
+ }
+ else if (type == Long.class || type == Long.TYPE) {
+ return (T) Long.decode(value);
+ }
+ else if (type == Short.class || type == Short.TYPE) {
+ return (T) Short.decode(value);
+ }
+ else if (type.isAssignableFrom(List.class)) {
+ return (T)new ArrayList<String>(Arrays.asList(value.split(","))); //$NON-NLS-1$
+ }
+ else if (type == Void.class) {
+ return null;
+ }
+ else if (type.isEnum()) {
+ return (T)Enum.valueOf(type, value);
+ }
+
+ else if (type.isAssignableFrom(Map.class)) {
+ List<String> l = Arrays.asList(value.split(",")); //$NON-NLS-1$
+ Map m = new HashMap<String, String>();
+ for(String key: l) {
+ int index = key.indexOf('=');
+ if (index != -1) {
+ m.put(key.substring(0, index), key.substring(index+1));
+ }
+ }
+ return (T)m;
+ }
+
+ throw new IllegalArgumentException("Conversion from String to "+ type.getName() + " is not supported"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+}
Property changes on: trunk/test-integration/db/src/main/java/org/teiid/test/util/StringUtil.java
___________________________________________________________________
Name: svn:mime-type
+ text/plain
16 years, 7 months
- 1
- 0
teiid SVN: r1324 - in trunk/test-integration: db and 7 other directories.
by teiid-commits＠lists.jboss.org
Author: vhalbert(a)redhat.com
Date: 2009-09-11 15:17:13 -0400 (Fri, 11 Sep 2009)
New Revision: 1324
Added:
trunk/test-integration/db/
trunk/test-integration/db/src/
trunk/test-integration/db/src/main/
trunk/test-integration/db/src/main/java/
trunk/test-integration/db/src/main/java/org/
trunk/test-integration/db/src/main/java/org/teiid/
trunk/test-integration/db/src/main/java/org/teiid/test/
trunk/test-integration/db/src/main/java/org/teiid/test/framework/
trunk/test-integration/db/src/main/java/org/teiid/test/framework/connection/
trunk/test-integration/db/src/main/java/org/teiid/test/framework/datasource/
trunk/test-integration/db/src/main/java/org/teiid/test/framework/exception/
trunk/test-integration/db/src/main/java/org/teiid/test/framework/transaction/
trunk/test-integration/db/src/main/java/org/teiid/test/util/
Log:
Teiid 773 - organize integration test
16 years, 7 months
- 1
- 0
teiid SVN: r1323 - trunk/client-jdbc/src/main/java/com/metamatrix/jdbc.
by teiid-commits＠lists.jboss.org
Author: rareddy
Date: 2009-09-11 14:20:36 -0400 (Fri, 11 Sep 2009)
New Revision: 1323
Modified:
trunk/client-jdbc/src/main/java/com/metamatrix/jdbc/MMStatement.java
Log:
TEIID-826: Results are fetched in synchronously, so the situation where the execute occurs and close being called on the statement object is not possible in a single threaded application. Teiid only supports single threaded connection.
Modified: trunk/client-jdbc/src/main/java/com/metamatrix/jdbc/MMStatement.java
===================================================================
--- trunk/client-jdbc/src/main/java/com/metamatrix/jdbc/MMStatement.java 2009-09-11 18:15:56 UTC (rev 1322)
+++ trunk/client-jdbc/src/main/java/com/metamatrix/jdbc/MMStatement.java 2009-09-11 18:20:36 UTC (rev 1323)
@@ -285,19 +285,9 @@
}
// close the the server's statement object (if necessary)
- if(currentRequestID > -1) {
- if(resultSet == null) {
- try {
- this.getDQP().closeRequest(currentRequestID);
- } catch (MetaMatrixProcessingException e) {
- throw MMSQLException.create(e);
- } catch (MetaMatrixComponentException e) {
- throw MMSQLException.create(e);
- }
- } else {
- resultSet.close();
- resultSet = null;
- }
+ if(resultSet != null) {
+ resultSet.close();
+ resultSet = null;
}
isClosed = true;
16 years, 7 months
- 1
- 0
teiid SVN: r1322 - trunk/engine/src/main/java/org/teiid/dqp/internal/process.
by teiid-commits＠lists.jboss.org
Author: rareddy
Date: 2009-09-11 14:15:56 -0400 (Fri, 11 Sep 2009)
New Revision: 1322
Modified:
trunk/engine/src/main/java/org/teiid/dqp/internal/process/DQPCore.java
Log:
TEIID-826: This error occurs because teiid allows asynchronous closes. Check to make sure the request is still active before closing the lob stream. Closing of the request implicitly closes any lob streams. So, there is no reason for throwing an exception as this timing issue between the request closing before the lob stream closing.
Modified: trunk/engine/src/main/java/org/teiid/dqp/internal/process/DQPCore.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/dqp/internal/process/DQPCore.java 2009-09-11 17:43:30 UTC (rev 1321)
+++ trunk/engine/src/main/java/org/teiid/dqp/internal/process/DQPCore.java 2009-09-11 18:15:56 UTC (rev 1322)
@@ -327,11 +327,11 @@
LogManager.logDetail(LogConstants.CTX_DQP, "Request to close the Lob stream with Stream id="+streamId+" instance id="+lobRequestId); //$NON-NLS-1$//$NON-NLS-2$
}
DQPWorkContext workContext = DQPWorkContext.getWorkContext();
- RequestWorkItem workItem = getRequestWorkItem(workContext.getRequestID(requestId));
- workItem.removeLobStream(lobRequestId);
- ResultsFuture<Void> resultsFuture = new ResultsFuture<Void>();
- resultsFuture.getResultsReceiver().receiveResults(null);
- return resultsFuture;
+ RequestWorkItem workItem = safeGetWorkItem(workContext.getRequestID(requestId));
+ if (workItem != null) {
+ workItem.removeLobStream(lobRequestId);
+ }
+ return null;
}
public ResultsFuture<LobChunk> requestNextLobChunk(int lobRequestId,
16 years, 7 months
- 1
- 0
teiid SVN: r1321 - in trunk: engine/src/main/resources/com/metamatrix/dqp and 1 other directories.
by teiid-commits＠lists.jboss.org
Author: shawkins
Date: 2009-09-11 13:43:30 -0400 (Fri, 11 Sep 2009)
New Revision: 1321
Modified:
trunk/engine/src/main/java/org/teiid/dqp/internal/process/DQPCore.java
trunk/engine/src/main/resources/com/metamatrix/dqp/i18n.properties
trunk/runtime/src/main/resources/com/metamatrix/dqp/embedded/i18n.properties
Log:
TEIID-825 cleanup of log messages seen in the debug log
Modified: trunk/engine/src/main/java/org/teiid/dqp/internal/process/DQPCore.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/dqp/internal/process/DQPCore.java 2009-09-11 16:13:38 UTC (rev 1320)
+++ trunk/engine/src/main/java/org/teiid/dqp/internal/process/DQPCore.java 2009-09-11 17:43:30 UTC (rev 1321)
@@ -364,7 +364,7 @@
RequestWorkItem getRequestWorkItem(RequestID reqID) throws MetaMatrixProcessingException {
RequestWorkItem result = this.requests.get(reqID);
if (result == null) {
- throw new MetaMatrixProcessingException(DQPPlugin.Util.getString("DQPCore.The_request_has_been_cancelled.", reqID));//$NON-NLS-1$
+ throw new MetaMatrixProcessingException(DQPPlugin.Util.getString("DQPCore.The_request_has_been_closed.", reqID));//$NON-NLS-1$
}
return result;
}
Modified: trunk/engine/src/main/resources/com/metamatrix/dqp/i18n.properties
===================================================================
--- trunk/engine/src/main/resources/com/metamatrix/dqp/i18n.properties 2009-09-11 16:13:38 UTC (rev 1320)
+++ trunk/engine/src/main/resources/com/metamatrix/dqp/i18n.properties 2009-09-11 17:43:30 UTC (rev 1321)
@@ -128,7 +128,7 @@
DQPCore.Clearing_prepared_plan_cache=Clearing prepared plan cache
DQPCore.Clearing_code_table_cache=Clearing code table cache
DQPCore.Unable_to_check_license_for_update_capability._Updates_will_not_be_allowed_3=Unable to check license for update capability. Updates will not be allowed
-DQPCore.The_request_has_been_cancelled.=The request {0} has been cancelled.
+DQPCore.The_request_has_been_closed.=The request {0} has been closed.
DQPCore.The_atomic_request_has_been_cancelled=The atomic request {0} has been cancelled.
DQPCore.The_atomic_request_cancelled_not_closed=The atomic request {0}.{1} has been cancelled, but closed yet.
DQPCore.The_atomic_request_closed_queued=The atomic request {0} has queued to close, another request in progress.
@@ -154,7 +154,7 @@
ProcessWorker.ProcessWorker.Failed_starting_processing._1=ProcessWorker.Failed_starting_processing.
ProcessWorker.failed_rollback=Failed to properly rollback autowrap transaction properly
ProcessWorker.error=Unexpected exception for request {0}
-ProcessWorker.processing_error=Processing exception ''{0}'' for request {1}. Exception type {2} throw from {3}. Enable detail logging to see the entire stacktrace.
+ProcessWorker.processing_error=Processing exception ''{0}'' for request {1}. Exception type {2} thrown from {3}. Enable more detailed logging to see the entire stacktrace.
SharedCacheFinder.Didnt_find_caps=Unable to find capabilities for {0}
Modified: trunk/runtime/src/main/resources/com/metamatrix/dqp/embedded/i18n.properties
===================================================================
--- trunk/runtime/src/main/resources/com/metamatrix/dqp/embedded/i18n.properties 2009-09-11 16:13:38 UTC (rev 1320)
+++ trunk/runtime/src/main/resources/com/metamatrix/dqp/embedded/i18n.properties 2009-09-11 17:43:30 UTC (rev 1321)
@@ -267,7 +267,7 @@
LogonImpl.Invalid_use_of_credentials_and_token=Conflicting use of both client session token and credentials.
ServerWorkItem.Received_exception_processing_request=Unexpected exception for session {0}
-ServerWorkItem.processing_error=Processing exception ''{0}'' for session {1}. Exception type {2} throw from {3}. Enable detail logging to see the entire stacktrace.
+ServerWorkItem.processing_error=Processing exception ''{0}'' for session {1}. Exception type {2} thrown from {3}. Enable more detailed logging to see the entire stacktrace.
ServerWorkItem.Component_Not_Found=Component not found: {0}
SocketTransport.1=Bound to address {0} listening on port {1}
16 years, 7 months
- 1
- 0
teiid SVN: r1320 - trunk/build/kit-adminshell.
by teiid-commits＠lists.jboss.org
Author: rareddy
Date: 2009-09-11 12:13:38 -0400 (Fri, 11 Sep 2009)
New Revision: 1320
Modified:
trunk/build/kit-adminshell/adminshell.bat
Log:
Fixing the path issue, as the executable is in the same directory.
Modified: trunk/build/kit-adminshell/adminshell.bat
===================================================================
--- trunk/build/kit-adminshell/adminshell.bat 2009-09-10 18:32:02 UTC (rev 1319)
+++ trunk/build/kit-adminshell/adminshell.bat 2009-09-11 16:13:38 UTC (rev 1320)
@@ -34,7 +34,7 @@
set DIRNAME=.\
)
-pushd %DIRNAME%..
+pushd %DIRNAME%
if "x%TEIID_HOME%" == "x" (
set "TEIID_HOME=%CD%"
)
16 years, 7 months
- 1
- 0
teiid SVN: r1319 - in trunk/test-integration: common and 1 other directory.
by teiid-commits＠lists.jboss.org
Author: vhalbert(a)redhat.com
Date: 2009-09-10 14:32:02 -0400 (Thu, 10 Sep 2009)
New Revision: 1319
Added:
trunk/test-integration/common/pom.xml
Removed:
trunk/test-integration/src/
Modified:
trunk/test-integration/pom.xml
Log:
Teiid 773 - organize integration test
Added: trunk/test-integration/common/pom.xml
===================================================================
--- trunk/test-integration/common/pom.xml (rev 0)
+++ trunk/test-integration/common/pom.xml 2009-09-10 18:32:02 UTC (rev 1319)
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <parent>
+ <artifactId>teiid-test-integration</artifactId>
+ <groupId>org.jboss.teiid</groupId>
+ <version>6.2.0-SNAPSHOT</version>
+ </parent>
+ <modelVersion>4.0.0</modelVersion>
+ <artifactId>common</artifactId>
+
+ <name>Common Integration Tests</name>
+ <groupId>org.jboss.teiid.teiid-test-integration</groupId>
+ <description>Common Integration tests that do not require external dependencies</description>
+
+</project>
\ No newline at end of file
Property changes on: trunk/test-integration/common/pom.xml
___________________________________________________________________
Name: svn:mime-type
+ text/plain
Modified: trunk/test-integration/pom.xml
===================================================================
--- trunk/test-integration/pom.xml 2009-09-10 18:23:29 UTC (rev 1318)
+++ trunk/test-integration/pom.xml 2009-09-10 18:32:02 UTC (rev 1319)
@@ -8,9 +8,20 @@
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>teiid-test-integration</artifactId>
+ <packaging>pom</packaging>
<name>Integration Tests</name>
<description>Integration tests spanning
server/embedded/connectors.</description>
+
+ <properties>
+ <apache.ant.version>1.7.0</apache.ant.version>
+
+ <!-- Database Driver Versions -->
+ <mysql.connector.version>5.1.5</mysql.connector.version>
+ <postgresql.version>8.3-603.jdbc3</postgresql.version>
+ <derby.version>10.2.1.6</derby.version>
+ </properties>
+
<dependencies>
<dependency>
<groupId>org.jboss.teiid</groupId>
@@ -52,6 +63,12 @@
</dependency>
<dependency>
<groupId>org.jboss.teiid</groupId>
+ <artifactId>teiid-connector-metadata</artifactId>
+ <type>test-jar</type>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.jboss.teiid</groupId>
<artifactId>teiid-client-jdbc</artifactId>
<type>test-jar</type>
</dependency>
@@ -77,42 +94,46 @@
<groupId>org.jboss.teiid.connectors</groupId>
<artifactId>connector-loopback</artifactId>
<version>${project.version}</version>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.jboss.teiid.connectors</groupId>
<artifactId>connector-text</artifactId>
<version>${project.version}</version>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.jboss.teiid.connectors</groupId>
<artifactId>connector-text</artifactId>
<type>test-jar</type>
<version>${project.version}</version>
+ <scope>test</scope>
</dependency>
+
<dependency>
- <groupId>org.jboss.teiid</groupId>
- <artifactId>teiid-connector-metadata</artifactId>
- <type>test-jar</type>
- <version>${project.version}</version>
- </dependency>
- <dependency>
<groupId>org.jboss.teiid.connectors</groupId>
<artifactId>connector-jdbc</artifactId>
<version>${project.version}</version>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.jboss.teiid.connectors</groupId>
<artifactId>connector-jdbc</artifactId>
<type>test-jar</type>
<version>${project.version}</version>
+ <scope>test</scope>
</dependency>
<!-- external dependencies -->
<dependency>
<groupId>org.apache.derby</groupId>
<artifactId>derby</artifactId>
- <version>10.2.1.6</version>
+ <version>${derby.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
+
+ <modules>
+ <module>common</module>
+ </modules>
</project>
\ No newline at end of file
16 years, 7 months
- 1
- 0
teiid SVN: r1318 - in trunk/test-integration: common and 1 other directory.
by teiid-commits＠lists.jboss.org
Author: vhalbert(a)redhat.com
Date: 2009-09-10 14:23:29 -0400 (Thu, 10 Sep 2009)
New Revision: 1318
Added:
trunk/test-integration/common/
trunk/test-integration/common/src/
Log:
Teiid 773 - organize integration test
Copied: trunk/test-integration/common/src (from rev 1312, trunk/test-integration/src)
16 years, 7 months
- 1
- 0
teiid SVN: r1317 - in trunk: runtime/src/main/java/com/metamatrix/dqp/embedded/services and 1 other directory.
by teiid-commits＠lists.jboss.org
Author: rareddy
Date: 2009-09-10 12:28:41 -0400 (Thu, 10 Sep 2009)
New Revision: 1317
Modified:
trunk/build/kit-runtime/deploy/log4j.xml
trunk/runtime/src/main/java/com/metamatrix/dqp/embedded/services/EmbeddedBufferService.java
Log:
TEIID-825
Modified: trunk/build/kit-runtime/deploy/log4j.xml
===================================================================
--- trunk/build/kit-runtime/deploy/log4j.xml 2009-09-10 16:06:35 UTC (rev 1316)
+++ trunk/build/kit-runtime/deploy/log4j.xml 2009-09-10 16:28:41 UTC (rev 1317)
@@ -59,10 +59,12 @@
</appender>
-->
- <!-- ======================================================== -->
- <!-- Loggers -->
- <!-- Supported logging levels DEBUG, INFO, WARN, ERROR, FATAL -->
- <!-- ======================================================== -->
+ <!-- =============================================================================== -->
+ <!-- Loggers -->
+ <!-- Supported logging levels DEBUG, INFO, WARN, ERROR, FATAL -->
+ <!-- setting log level to DEBUG will increase the volume of messages that are logged -->
+ <!-- Consider increasing "MaxFileSize" in the "appender" to hold more data per file -->
+ <!-- =============================================================================== -->
<logger name="org.jgroups">
<level value="WARN"/>
Modified: trunk/runtime/src/main/java/com/metamatrix/dqp/embedded/services/EmbeddedBufferService.java
===================================================================
--- trunk/runtime/src/main/java/com/metamatrix/dqp/embedded/services/EmbeddedBufferService.java 2009-09-10 16:06:35 UTC (rev 1316)
+++ trunk/runtime/src/main/java/com/metamatrix/dqp/embedded/services/EmbeddedBufferService.java 2009-09-10 16:28:41 UTC (rev 1317)
@@ -52,7 +52,7 @@
// Constants
private static final String DEFAULT_MANAGEMENT_INTERVAL = "500"; //$NON-NLS-1$
- private static final String DEFAULT_LOG_STATS_INTERVAL = DEFAULT_MANAGEMENT_INTERVAL;
+ private static final String DEFAULT_LOG_STATS_INTERVAL = "60000"; //$NON-NLS-1$ // every minute
private static final String DEFAULT_SESSION_USE_PERCENTAGE = "100"; //$NON-NLS-1$
private static final String DEFAULT_MAX_OPEN_FILES = "10"; //$NON-NLS-1$
16 years, 7 months
- 1
- 0
teiid SVN: r1316 - trunk/common-internal/src/main/java/com/metamatrix/common/log.
by teiid-commits＠lists.jboss.org
Author: shawkins
Date: 2009-09-10 12:06:35 -0400 (Thu, 10 Sep 2009)
New Revision: 1316
Modified:
trunk/common-internal/src/main/java/com/metamatrix/common/log/LogManager.java
Log:
TEIID-825 fix for exception not being displayed
Modified: trunk/common-internal/src/main/java/com/metamatrix/common/log/LogManager.java
===================================================================
--- trunk/common-internal/src/main/java/com/metamatrix/common/log/LogManager.java 2009-09-10 15:05:24 UTC (rev 1315)
+++ trunk/common-internal/src/main/java/com/metamatrix/common/log/LogManager.java 2009-09-10 16:06:35 UTC (rev 1316)
@@ -243,7 +243,7 @@
* not logged if this parameter is null
* @param message the log message (may be null)
*/
- public static void logDetail(String context, Throwable e, String message) {
+ public static void logDetail(String context, Throwable e, Object ... message) {
log(MessageLevel.DETAIL,context,e,message);
}
16 years, 7 months
- 1
- 0