Convenient superclass for JUnit 3.8 based tests depending on a Spring - * context. The test instance itself is populated by Dependency Injection. - * - *
Supports Setter Dependency Injection: simply express dependencies - * on objects in the test fixture, and they will be satisfied by autowiring - * by type. - * - * @author Rod Johnson - * @author Rob Harrop - * @author Rick Evans - * @author Sam Brannen - * @since 1.1.1 - * @deprecated as of Spring 3.0, in favor of using the listener-based test context framework - * ({@link org.springframework.test.context.junit38.AbstractJUnit38SpringContextTests}) - */ -@Deprecated -public abstract class AbstractDependencyInjectionSpringContextTests extends AbstractSingleSpringContextTests { - - /** - * Constant that indicates no autowiring at all. - * @see #setAutowireMode - */ - protected static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO; - - /** - * Constant that indicates autowiring bean properties by name. - * @see #setAutowireMode - */ - protected static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME; - - /** - * Constant that indicates autowiring bean properties by type. - * @see #setAutowireMode - */ - protected static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE; - - private int autowireMode = AUTOWIRE_BY_TYPE; - - private boolean dependencyCheck = true; - - - /** - * Set the autowire mode for test properties set by Dependency Injection. - *
The default is {@link #AUTOWIRE_BY_TYPE}. Can be set to - * {@link #AUTOWIRE_BY_NAME} or {@link #AUTOWIRE_NO} instead. - * @see #AUTOWIRE_BY_TYPE - * @see #AUTOWIRE_BY_NAME - * @see #AUTOWIRE_NO - */ - protected final void setAutowireMode(final int autowireMode) { - this.autowireMode = autowireMode; - } - - /** - * Return the autowire mode for test properties set by Dependency Injection. - */ - protected final int getAutowireMode() { - return this.autowireMode; - } - - /** - * Set whether or not dependency checking should be performed for test - * properties set by Dependency Injection. - *
The default is {@code true}, meaning that tests cannot be run - * unless all properties are populated. - */ - protected final void setDependencyCheck(final boolean dependencyCheck) { - this.dependencyCheck = dependencyCheck; - } - - /** - * Return whether or not dependency checking should be performed for test - * properties set by Dependency Injection. - */ - protected final boolean isDependencyCheck() { - return this.dependencyCheck; - } - - /** - * Prepare this test instance, injecting dependencies into its bean properties. - *
Note: if the {@link ApplicationContext} for this test instance has not - * been configured (e.g., is {@code null}), dependency injection - * will naturally not be performed, but an informational - * message will be written to the log. - * @see #injectDependencies() - */ - @Override - protected void prepareTestInstance() throws Exception { - if (getApplicationContext() == null) { - if (this.logger.isInfoEnabled()) { - this.logger.info("ApplicationContext has not been configured for test [" + getClass().getName() - + "]: dependency injection will NOT be performed."); - } - } - else { - Assert.state(getApplicationContext() != null, - "injectDependencies() called without first configuring an ApplicationContext"); - - getApplicationContext().getBeanFactory().autowireBeanProperties(this, getAutowireMode(), isDependencyCheck()); - } - } - -} diff --git a/spring-orm/src/test/java/org/springframework/test/AbstractSingleSpringContextTests.java b/spring-orm/src/test/java/org/springframework/test/AbstractSingleSpringContextTests.java deleted file mode 100644 index a022c32cd29..00000000000 --- a/spring-orm/src/test/java/org/springframework/test/AbstractSingleSpringContextTests.java +++ /dev/null @@ -1,231 +0,0 @@ -/* - * Copyright 2002-2015 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.springframework.test; - -import org.springframework.beans.factory.support.DefaultListableBeanFactory; -import org.springframework.beans.factory.xml.XmlBeanDefinitionReader; -import org.springframework.context.ConfigurableApplicationContext; -import org.springframework.context.annotation.AnnotationConfigUtils; -import org.springframework.context.support.GenericApplicationContext; -import org.springframework.core.io.support.ResourcePatternUtils; -import org.springframework.util.ClassUtils; -import org.springframework.util.ResourceUtils; -import org.springframework.util.StringUtils; - -/** - * This class is only used within tests in the spring-orm module. - * - *
Abstract JUnit 3.8 test class that holds and exposes a single Spring - * {@link org.springframework.context.ApplicationContext ApplicationContext}. - * - *
This class will cache contexts based on a context key: normally the - * config locations String array describing the Spring resource descriptors - * making up the context. Unless the {@link #setDirty()} method is called by a - * test, the context will not be reloaded, even across different subclasses of - * this test. This is particularly beneficial if your context is slow to - * construct, for example if you are using Hibernate and the time taken to load - * the mappings is an issue. - * - *
For such standard usage, simply override the {@link #getConfigLocations()} - * method and provide the desired config files. For alternative configuration - * options, see {@link #getConfigPaths()}. - * - *
WARNING: When doing integration tests from within Eclipse, only use - * classpath resource URLs. Else, you may see misleading failures when changing - * context locations. - * - * @author Juergen Hoeller - * @author Rod Johnson - * @author Sam Brannen - * @since 2.0 - * @see #getConfigLocations() - * @see #getApplicationContext() - * @deprecated as of Spring 3.0, in favor of using the listener-based test context framework - * ({@link org.springframework.test.context.junit38.AbstractJUnit38SpringContextTests}) - */ -@Deprecated -abstract class AbstractSingleSpringContextTests extends AbstractSpringContextTests { - - private static final String SLASH = "/"; - - /** Application context this test will run against */ - protected ConfigurableApplicationContext applicationContext; - - /** - * This implementation is final. Override {@code onSetUp} for custom behavior. - * @see #onSetUp() - */ - @Override - protected final void setUp() throws Exception { - // lazy load, in case getApplicationContext() has not yet been called. - if (this.applicationContext == null) { - this.applicationContext = getContext(getConfigLocations()); - } - prepareTestInstance(); - onSetUp(); - } - - /** - * Prepare this test instance, for example populating its fields. - * The context has already been loaded at the time of this callback. - *
The default implementation does nothing. - * @throws Exception in case of preparation failure - */ - protected void prepareTestInstance() throws Exception { - } - - /** - * Subclasses can override this method in place of the {@code setUp()} - * method, which is final in this class. - *
The default implementation does nothing. - * @throws Exception simply let any exception propagate - */ - protected void onSetUp() throws Exception { - } - - /** - * This implementation is final. Override {@code onTearDown} for - * custom behavior. - * @see #onTearDown() - */ - @Override - protected final void tearDown() throws Exception { - onTearDown(); - } - - /** - * Subclasses can override this to add custom behavior on teardown. - * @throws Exception simply let any exception propagate - */ - protected void onTearDown() throws Exception { - } - - /** - * Load a Spring ApplicationContext from the given config locations. - *
The default implementation creates a standard - * {@link #createApplicationContext GenericApplicationContext}, allowing - * for customizing the internal bean factory through - * {@link #customizeBeanFactory}. - * @param locations the config locations (as Spring resource locations, - * e.g. full classpath locations or any kind of URL) - * @return the corresponding ApplicationContext instance (potentially cached) - * @throws Exception if context loading failed - * @see #createApplicationContext(String[]) - */ - @Override - protected ConfigurableApplicationContext loadContext(String... locations) throws Exception { - if (this.logger.isInfoEnabled()) { - this.logger.info("Loading context for locations: " + StringUtils.arrayToCommaDelimitedString(locations)); - } - return createApplicationContext(locations); - } - - /** - * Create a Spring {@link ConfigurableApplicationContext} for use by this test. - *
The default implementation creates a standard {@link GenericApplicationContext} - * instance, calls the {@link #prepareApplicationContext} prepareApplicationContext} - * method and the {@link #customizeBeanFactory customizeBeanFactory} method to allow - * for customizing the context and its DefaultListableBeanFactory, populates the - * context from the specified config {@code locations} through the configured - * {@link #createBeanDefinitionReader(GenericApplicationContext) BeanDefinitionReader}, - * and finally {@link ConfigurableApplicationContext#refresh() refreshes} the context. - * @param locations the config locations (as Spring resource locations, - * e.g. full classpath locations or any kind of URL) - * @return the GenericApplicationContext instance - * @see #loadContext(String...) - * @see #customizeBeanFactory(DefaultListableBeanFactory) - * @see #createBeanDefinitionReader(GenericApplicationContext) - */ - private ConfigurableApplicationContext createApplicationContext(String... locations) { - GenericApplicationContext context = new GenericApplicationContext(); - new XmlBeanDefinitionReader(context).loadBeanDefinitions(locations); - AnnotationConfigUtils.registerAnnotationConfigProcessors(context); - context.refresh(); - return context; - } - - /** - * Subclasses can override this method to return the locations of their - * config files. - *
A plain path will be treated as class path location, e.g.: - * "org/springframework/whatever/foo.xml". Note however that you may prefix - * path locations with standard Spring resource prefixes. Therefore, a - * config location path prefixed with "classpath:" with behave the same as a - * plain path, but a config location such as - * "file:/some/path/path/location/appContext.xml" will be treated as a - * filesystem location. - *
The default implementation builds config locations for the config paths - * specified through {@link #getConfigPaths()}. - * @return an array of config locations - * @see #getConfigPaths() - * @see org.springframework.core.io.ResourceLoader#getResource(String) - */ - protected final String[] getConfigLocations() { - String[] paths = getConfigPaths(); - String[] convertedPaths = new String[paths.length]; - for (int i = 0; i < paths.length; i++) { - String path = paths[i]; - if (path.startsWith(SLASH)) { - convertedPaths[i] = ResourceUtils.CLASSPATH_URL_PREFIX + path; - } - else if (!ResourcePatternUtils.isUrl(path)) { - convertedPaths[i] = ResourceUtils.CLASSPATH_URL_PREFIX + SLASH - + StringUtils.cleanPath(ClassUtils.classPackageAsResourcePath(getClass()) + SLASH + path); - } - else { - convertedPaths[i] = StringUtils.cleanPath(path); - } - } - return convertedPaths; - } - - /** - * Subclasses must override this method to return paths to their config - * files, relative to the concrete test class. - *
A plain path, e.g. "context.xml", will be loaded as classpath resource - * from the same package that the concrete test class is defined in. A path - * starting with a slash is treated as fully qualified class path location, - * e.g.: "/org/springframework/whatever/foo.xml". - *
The default implementation returns an empty array. - * @return an array of config locations - * @see java.lang.Class#getResource(String) - */ - protected abstract String[] getConfigPaths(); - - /** - * Return the ApplicationContext that this base class manages; may be - * {@code null}. - */ - protected final ConfigurableApplicationContext getApplicationContext() { - // lazy load, in case setUp() has not yet been called. - if (this.applicationContext == null) { - try { - this.applicationContext = getContext(getConfigLocations()); - } - catch (Exception e) { - // log and continue... - if (this.logger.isDebugEnabled()) { - this.logger.debug("Caught exception while retrieving the ApplicationContext for test [" + - getClass().getName() + "." + getName() + "].", e); - } - } - } - - return this.applicationContext; - } - -} diff --git a/spring-orm/src/test/java/org/springframework/test/AbstractSpringContextTests.java b/spring-orm/src/test/java/org/springframework/test/AbstractSpringContextTests.java deleted file mode 100644 index d6eefe161d9..00000000000 --- a/spring-orm/src/test/java/org/springframework/test/AbstractSpringContextTests.java +++ /dev/null @@ -1,113 +0,0 @@ -/* - * Copyright 2002-2016 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.springframework.test; - -import java.util.HashMap; -import java.util.Map; - -import junit.framework.TestCase; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -import org.springframework.context.ConfigurableApplicationContext; -import org.springframework.util.Assert; -import org.springframework.util.ObjectUtils; - -/** - * This class is only used within tests in the spring-orm module. - * - *
Superclass for JUnit 3.8 test cases using Spring - * {@link org.springframework.context.ApplicationContext ApplicationContexts}. - * - *
Maintains a static cache of contexts by key. This has significant performance - * benefit if initializing the context would take time. While initializing a - * Spring context itself is very quick, some beans in a context, such as a - * LocalSessionFactoryBean for working with Hibernate, may take some time to - * initialize. Hence it often makes sense to do that initializing once. - * - *
Any ApplicationContext created by this class will be asked to register a JVM
- * shutdown hook for itself. Unless the context gets closed early, all context
- * instances will be automatically closed on JVM shutdown. This allows for
- * freeing external resources held by beans within the context, e.g. temporary
- * files.
- *
- * @author Rod Johnson
- * @author Juergen Hoeller
- * @author Sam Brannen
- * @since 1.1.1
- * @see AbstractSingleSpringContextTests
- * @see AbstractDependencyInjectionSpringContextTests
- * @see AbstractTransactionalSpringContextTests
- * @see AbstractTransactionalDataSourceSpringContextTests
- * @deprecated as of Spring 3.0, in favor of using the listener-based test context framework
- * ({@link org.springframework.test.context.junit38.AbstractJUnit38SpringContextTests})
- */
-@Deprecated
-abstract class AbstractSpringContextTests extends TestCase {
-
- protected final Log logger = LogFactory.getLog(getClass());
-
- private static Map This is not meant to be used by subclasses. It is rather exposed for
- * special test suite environments.
- * @param locations the context key
- * @param context the ApplicationContext instance
- */
- public final void addContext(String[] locations, ConfigurableApplicationContext context) {
- Assert.notNull(context, "ApplicationContext must not be null");
- contextKeyToContextMap.put(contextKey(locations), context);
- }
-
- /**
- * Obtain an ApplicationContext for the given key, potentially cached.
- * @param locations the context key; may be {@code null}.
- * @return the corresponding ApplicationContext instance (potentially cached),
- * or {@code null} if the provided {@code key} is empty
- */
- protected final ConfigurableApplicationContext getContext(String... locations) throws Exception {
- if (ObjectUtils.isEmpty(locations)) {
- return null;
- }
- String key = contextKey(locations);
- ConfigurableApplicationContext ctx = contextKeyToContextMap.get(key);
- if (ctx == null) {
- ctx = loadContext(locations);
- ctx.registerShutdownHook();
- contextKeyToContextMap.put(key, ctx);
- }
- return ctx;
- }
-
- private final String contextKey(String... locations) {
- return ObjectUtils.nullSafeToString(locations);
- }
-
- /**
- * Load a new ApplicationContext for the given key.
- * To be implemented by subclasses.
- * @param key the context key
- * @return the corresponding ApplicationContext instance (new)
- */
- protected abstract ConfigurableApplicationContext loadContext(String... locations) throws Exception;
-
-}
diff --git a/spring-orm/src/test/java/org/springframework/test/AbstractTransactionalSpringContextTests.java b/spring-orm/src/test/java/org/springframework/test/AbstractTransactionalSpringContextTests.java
deleted file mode 100644
index 11d0722deb4..00000000000
--- a/spring-orm/src/test/java/org/springframework/test/AbstractTransactionalSpringContextTests.java
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- * Copyright 2002-2015 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.test;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import javax.sql.DataSource;
-
-import org.springframework.core.io.Resource;
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
-import org.springframework.transaction.PlatformTransactionManager;
-import org.springframework.transaction.TransactionDefinition;
-import org.springframework.transaction.TransactionException;
-import org.springframework.transaction.TransactionStatus;
-import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
-import org.springframework.transaction.interceptor.TransactionAttributeSource;
-import org.springframework.transaction.support.DefaultTransactionDefinition;
-
-/**
- * This class is only used within tests in the spring-orm module.
- *
- * Convenient base class for JUnit 3.8 based tests that should occur in a
- * transaction, but normally will roll the transaction back on the completion of
- * each test.
- *
- * This is useful in a range of circumstances, allowing the following benefits:
- * This class is typically very fast, compared to traditional setup/teardown
- * scripts.
- *
- * If data should be left in the database, call the {@link #setComplete()}
- * method in each test. The {@link #setDefaultRollback "defaultRollback"}
- * property, which defaults to "true", determines whether transactions will
- * complete by default.
- *
- * It is even possible to end the transaction early; for example, to verify lazy
- * loading behavior of an O/R mapping tool. (This is a valuable away to avoid
- * unexpected errors when testing a web UI, for example.) Simply call the
- * {@link #endTransaction()} method. Execution will then occur without a
- * transactional context.
- *
- * The {@link #startNewTransaction()} method may be called after a call to
- * {@link #endTransaction()} if you wish to create a new transaction, quite
- * independent of the old transaction. The new transaction's default fate will
- * be to roll back, unless {@link #setComplete()} is called again during the
- * scope of the new transaction. Any number of transactions may be created and
- * ended in this way. The final transaction will automatically be rolled back
- * when the test case is torn down.
- *
- * Transactional behavior requires a single bean in the context implementing the
- * {@link PlatformTransactionManager} interface. This will be set by the
- * superclass's Dependency Injection mechanism. If using the superclass's Field
- * Injection mechanism, the implementation should be named "transactionManager".
- * This mechanism allows the use of the
- * {@link AbstractDependencyInjectionSpringContextTests} superclass even when
- * there is more than one transaction manager in the context.
- *
- * This base class can also be used without transaction management, if no
- * PlatformTransactionManager bean is found in the context provided. Be
- * careful about using this mode, as it allows the potential to permanently
- * modify data. This mode is available only if dependency checking is turned off
- * in the {@link AbstractDependencyInjectionSpringContextTests} superclass. The
- * non-transactional capability is provided to enable use of the same subclass
- * in different environments.
- *
- * Adds some convenience functionality for JDBC access. Expects a
- * {@link javax.sql.DataSource} bean to be defined in the Spring application
- * context.
- *
- * This class exposes a {@link org.springframework.jdbc.core.JdbcTemplate}
- * and provides an easy way to delete from the database in a new transaction.
- *
- * Test methods can be annotated with the regular Spring
- * {@link org.springframework.transaction.annotation.Transactional @Transactional}
- * annotation — for example, to force execution in a read-only transaction
- * or to prevent any transaction from being created at all by setting the propagation
- * level to {@code NOT_SUPPORTED}.
- *
- * @author Rod Johnson
- * @author Juergen Hoeller
- * @author Thomas Risberg
- * @author Sam Brannen
- * @since 1.1.1
- * @deprecated as of Spring 3.0, in favor of using the listener-based test context framework
- * ({@link org.springframework.test.context.junit38.AbstractJUnit38SpringContextTests})
- */
-@Deprecated
-public abstract class AbstractTransactionalSpringContextTests extends AbstractDependencyInjectionSpringContextTests {
-
- /** The transaction manager to use */
- protected PlatformTransactionManager transactionManager;
-
- /** Should we roll back by default? */
- private boolean defaultRollback = true;
-
- /** Should we commit the current transaction? */
- private boolean complete = false;
-
- /** Number of transactions started */
- private int transactionsStarted = 0;
-
- /**
- * Transaction definition used by this test class: by default, a plain
- * DefaultTransactionDefinition. Subclasses can change this to cause
- * different behavior.
- */
- protected TransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
-
- private final TransactionAttributeSource transactionAttributeSource = new AnnotationTransactionAttributeSource();
-
- /**
- * TransactionStatus for this test. Typical subclasses won't need to use it.
- */
- protected TransactionStatus transactionStatus;
-
- protected JdbcTemplate jdbcTemplate;
-
- /**
- * Did this test delete any tables? If so, we forbid transaction completion,
- * and only allow rollback.
- */
- private boolean zappedTables;
-
-
- /**
- * Setter: DataSource is provided by Dependency Injection.
- */
- public void setDataSource(DataSource dataSource) {
- this.jdbcTemplate = new JdbcTemplate(dataSource);
- }
-
- /**
- * Specify the transaction manager to use. No transaction management will be
- * available if this is not set. Populated through dependency injection by
- * the superclass.
- *
- * This mode works only if dependency checking is turned off in the
- * {@link AbstractDependencyInjectionSpringContextTests} superclass.
- */
- public void setTransactionManager(PlatformTransactionManager transactionManager) {
- this.transactionManager = transactionManager;
- }
-
- /**
- * Subclasses can set this value in their constructor to change the default,
- * which is always to roll the transaction back.
- */
- protected void setDefaultRollback(final boolean defaultRollback) {
- this.defaultRollback = defaultRollback;
- }
-
- /**
- * Get the default rollback flag for this test.
- * @see #setDefaultRollback(boolean)
- * @return The default rollback flag.
- */
- protected boolean isDefaultRollback() {
- return this.defaultRollback;
- }
-
- /**
- * Determine whether or not to roll back transactions for the current test.
- * The default implementation simply delegates to {@link #isDefaultRollback()}.
- * Subclasses can override as necessary.
- * @return the rollback flag for the current test
- */
- protected boolean isRollback() {
- boolean rollback = isDefaultRollback();
- if (this.logger.isDebugEnabled()) {
- this.logger.debug("Using default rollback [" + rollback + "] for test [" + getName() + "].");
- }
- return rollback;
- }
-
- /**
- * Call this method in an overridden {@link #runBare()} method to prevent
- * transactional execution.
- */
- protected void preventTransaction() {
- this.transactionDefinition = null;
- }
-
- /**
- * Call this method in an overridden {@link #runBare()} method to override
- * the transaction attributes that will be used, so that {@link #setUp()}
- * and {@link #tearDown()} behavior is modified.
- * @param customDefinition the custom transaction definition
- */
- protected void setTransactionDefinition(TransactionDefinition customDefinition) {
- this.transactionDefinition = customDefinition;
- }
-
- /**
- * This implementation creates a transaction before test execution.
- * Override {@link #onSetUpBeforeTransaction()} and/or
- * {@link #onSetUpInTransaction()} to add custom set-up behavior for
- * transactional execution. Alternatively, override this method for general
- * set-up behavior, calling {@code super.onSetUp()} as part of your
- * method implementation.
- * @throws Exception simply let any exception propagate
- * @see #onTearDown()
- */
- @Override
- protected void onSetUp() throws Exception {
- this.complete = !this.isRollback();
-
- if (this.transactionManager == null) {
- this.logger.info("No transaction manager set: test will NOT run within a transaction");
- }
- else if (this.transactionDefinition == null) {
- this.logger.info("No transaction definition set: test will NOT run within a transaction");
- }
- else {
- onSetUpBeforeTransaction();
- startNewTransaction();
- try {
- onSetUpInTransaction();
- }
- catch (final Exception ex) {
- endTransaction();
- throw ex;
- }
- }
- }
-
- /**
- * Subclasses can override this method to perform any setup operations, such
- * as populating a database table, before the transaction created by
- * this class. Only invoked if there is a transaction: that is, if
- * {@link #preventTransaction()} has not been invoked in an overridden
- * {@link #runTest()} method.
- * @throws Exception simply let any exception propagate
- */
- protected void onSetUpBeforeTransaction() throws Exception {
- }
-
- /**
- * Subclasses can override this method to perform any setup operations, such
- * as populating a database table, within the transaction created by
- * this class.
- * NB: Not called if there is no transaction management, due to no
- * transaction manager being provided in the context.
- * If any {@link Throwable} is thrown, the transaction that has been started
- * prior to the execution of this method will be
- * {@link #endTransaction() ended} (or rather an attempt will be made to
- * {@link #endTransaction() end it gracefully}); The offending
- * {@link Throwable} will then be rethrown.
- * @throws Exception simply let any exception propagate
- */
- protected void onSetUpInTransaction() throws Exception {
- }
-
- /**
- * This implementation ends the transaction after test execution.
- * Override {@link #onTearDownInTransaction()} and/or
- * {@link #onTearDownAfterTransaction()} to add custom tear-down behavior
- * for transactional execution. Alternatively, override this method for
- * general tear-down behavior, calling {@code super.onTearDown()} as
- * part of your method implementation.
- * Note that {@link #onTearDownInTransaction()} will only be called if a
- * transaction is still active at the time of the test shutdown. In
- * particular, it will not be called if the transaction has been
- * completed with an explicit {@link #endTransaction()} call before.
- * @throws Exception simply let any exception propagate
- * @see #onSetUp()
- */
- @Override
- protected void onTearDown() throws Exception {
- // Call onTearDownInTransaction and end transaction if the transaction
- // is still active.
- if (this.transactionStatus != null && !this.transactionStatus.isCompleted()) {
- try {
- onTearDownInTransaction();
- }
- finally {
- endTransaction();
- }
- }
-
- // Call onTearDownAfterTransaction if there was at least one
- // transaction, even if it has been completed early through an
- // endTransaction() call.
- if (this.transactionsStarted > 0) {
- onTearDownAfterTransaction();
- }
- }
-
- /**
- * Subclasses can override this method to run invariant tests here. The
- * transaction is still active at this point, so any changes made in
- * the transaction will still be visible. However, there is no need to clean
- * up the database, as a rollback will follow automatically.
- * NB: Not called if there is no actual transaction, for example due
- * to no transaction manager being provided in the application context.
- * @throws Exception simply let any exception propagate
- */
- protected void onTearDownInTransaction() throws Exception {
- }
-
- /**
- * Subclasses can override this method to perform cleanup after a
- * transaction here. At this point, the transaction is not active anymore.
- * @throws Exception simply let any exception propagate
- */
- protected void onTearDownAfterTransaction() throws Exception {
- }
-
- /**
- * Overridden to populate transaction definition from annotations.
- */
- @Override
- public void runBare() throws Throwable {
- final Method testMethod = getTestMethod();
-
- TransactionDefinition explicitTransactionDefinition = this.transactionAttributeSource.getTransactionAttribute(
- testMethod, getClass());
- if (explicitTransactionDefinition != null) {
- this.logger.info("Custom transaction definition [" + explicitTransactionDefinition + "] for test method ["
- + getName() + "].");
- setTransactionDefinition(explicitTransactionDefinition);
- }
-
- if (this.transactionDefinition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
- preventTransaction();
- }
-
- super.runBare();
- }
-
- /**
- * Get the current test method.
- */
- protected Method getTestMethod() {
- assertNotNull("TestCase.getName() cannot be null", getName());
- Method testMethod = null;
- try {
- // Use same algorithm as JUnit itself to retrieve the test method
- // about to be executed (the method name is returned by getName). It
- // has to be public so we can retrieve it.
- testMethod = getClass().getMethod(getName(), (Class[]) null);
- }
- catch (NoSuchMethodException ex) {
- fail("Method '" + getName() + "' not found");
- }
- if (!Modifier.isPublic(testMethod.getModifiers())) {
- fail("Method '" + getName() + "' should be public");
- }
- return testMethod;
- }
-
- /**
- * Cause the transaction to commit for this test method, even if the test
- * method is configured to {@link #isRollback() rollback}.
- * @throws IllegalStateException if the operation cannot be set to complete
- * as no transaction manager was provided
- */
- protected void setComplete() {
- if (this.transactionManager == null) {
- throw new IllegalStateException("No transaction manager set");
- }
- if (this.zappedTables) {
- throw new IllegalStateException("Cannot set complete after deleting tables");
- }
- this.complete = true;
- }
-
- /**
- * Immediately force a commit or rollback of the transaction, according to
- * the {@code complete} and {@link #isRollback() rollback} flags.
- * Can be used to explicitly let the transaction end early, for example to
- * check whether lazy associations of persistent objects work outside of a
- * transaction (that is, have been initialized properly).
- * @see #setComplete()
- */
- protected void endTransaction() {
- final boolean commit = this.complete || !isRollback();
- if (this.transactionStatus != null) {
- try {
- if (commit) {
- this.transactionManager.commit(this.transactionStatus);
- this.logger.debug("Committed transaction after execution of test [" + getName() + "].");
- }
- else {
- this.transactionManager.rollback(this.transactionStatus);
- this.logger.debug("Rolled back transaction after execution of test [" + getName() + "].");
- }
- }
- finally {
- this.transactionStatus = null;
- }
- }
- }
-
- /**
- * Start a new transaction. Only call this method if
- * {@link #endTransaction()} has been called. {@link #setComplete()} can be
- * used again in the new transaction. The fate of the new transaction, by
- * default, will be the usual rollback.
- * @throws TransactionException if starting the transaction failed
- */
- protected void startNewTransaction() throws TransactionException {
- if (this.transactionStatus != null) {
- throw new IllegalStateException("Cannot start new transaction without ending existing transaction: "
- + "Invoke endTransaction() before startNewTransaction()");
- }
- if (this.transactionManager == null) {
- throw new IllegalStateException("No transaction manager set");
- }
-
- this.transactionStatus = this.transactionManager.getTransaction(this.transactionDefinition);
- ++this.transactionsStarted;
- this.complete = !this.isRollback();
-
- if (this.logger.isDebugEnabled()) {
- this.logger.debug("Began transaction (" + this.transactionsStarted + "): transaction manager ["
- + this.transactionManager + "]; rollback [" + this.isRollback() + "].");
- }
- }
-
- /**
- * Convenient method to delete all rows from these tables.
- * Calling this method will make avoidance of rollback by calling
- * {@code setComplete()} impossible.
- * @see #setComplete
- */
- protected void deleteFromTables(String... names) {
- for (String name : names) {
- int rowCount = this.jdbcTemplate.update("DELETE FROM " + name);
- if (logger.isInfoEnabled()) {
- logger.info("Deleted " + rowCount + " rows from table " + name);
- }
- }
- this.zappedTables = true;
- }
-
- /**
- * Count the rows in the given table
- * @param tableName table name to count rows in
- * @return the number of rows in the table
- */
- protected int countRowsInTable(String tableName) {
- return this.jdbcTemplate.queryForObject("SELECT COUNT(0) FROM " + tableName, Integer.class);
- }
-
- /**
- * Execute the given SQL script.
- * Use with caution outside of a transaction!
- * The script will normally be loaded by classpath.
- * Do not use this method to execute DDL if you expect rollback.
- * @param sqlResourcePath the Spring resource path for the SQL script
- * @param continueOnError whether or not to continue without throwing an
- * exception in the event of an error
- * @throws DataAccessException if there is an error executing a statement
- * @see ResourceDatabasePopulator
- * @see #setSqlScriptEncoding
- */
- protected void executeSqlScript(String sqlResourcePath, boolean continueOnError) throws DataAccessException {
- Resource resource = this.applicationContext.getResource(sqlResourcePath);
- new ResourceDatabasePopulator(continueOnError, false, null, resource).execute(jdbcTemplate.getDataSource());
- }
-
-}
diff --git a/spring-orm/src/test/java/org/springframework/test/jpa/AbstractJpaTests.java b/spring-orm/src/test/java/org/springframework/test/jpa/AbstractJpaTests.java
deleted file mode 100644
index a688b70a1f6..00000000000
--- a/spring-orm/src/test/java/org/springframework/test/jpa/AbstractJpaTests.java
+++ /dev/null
@@ -1,354 +0,0 @@
-/*
- * Copyright 2002-2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.test.jpa;
-
-import java.lang.instrument.ClassFileTransformer;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.HashMap;
-import java.util.Map;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-
-import junit.framework.TestCase;
-
-import org.springframework.beans.BeanUtils;
-import org.springframework.beans.BeansException;
-import org.springframework.beans.factory.config.BeanPostProcessor;
-import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
-import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.DefaultListableBeanFactory;
-import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
-import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.context.support.GenericApplicationContext;
-import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver;
-import org.springframework.instrument.classloading.LoadTimeWeaver;
-import org.springframework.instrument.classloading.ResourceOverridingShadowingClassLoader;
-import org.springframework.instrument.classloading.ShadowingClassLoader;
-import org.springframework.orm.jpa.ExtendedEntityManagerCreator;
-import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
-import org.springframework.orm.jpa.SharedEntityManagerCreator;
-import org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager;
-import org.springframework.test.AbstractTransactionalSpringContextTests;
-import org.springframework.util.ReflectionUtils;
-import org.springframework.util.StringUtils;
-
-/**
- * This class is only used within tests in the spring-orm module.
- *
- * Convenient support class for JPA-related tests. Offers the same contract as
- * AbstractTransactionalDataSourceSpringContextTests and equally good performance,
- * even when performing the instrumentation required by the JPA specification.
- *
- * Exposes an EntityManagerFactory and a shared EntityManager.
- * Requires an EntityManagerFactory to be injected, plus the DataSource and
- * JpaTransactionManager through the superclass.
- *
- * When using Xerces, make sure a post 2.0.2 version is available on the classpath
- * to avoid a critical
- * bug
- * that leads to StackOverflow. Maven users are likely to encounter this problem since
- * 2.0.2 is used by default.
- *
- * A workaround is to explicitly specify the Xerces version inside the Maven POM:
- * The default implementation deactivates shadow class loading if Spring's
- * InstrumentationSavingAgent has been configured on VM startup.
- */
- protected boolean shouldUseShadowLoader() {
- return !InstrumentationLoadTimeWeaver.isInstrumentationAvailable();
- }
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
- @Override
- public void runBare() throws Throwable {
- if (!shouldUseShadowLoader()) {
- super.runBare();
- return;
- }
-
- String combinationOfContextLocationsForThisTestClass = cacheKeys();
- ClassLoader classLoaderForThisTestClass = getClass().getClassLoader();
- // save the TCCL
- ClassLoader initialClassLoader = Thread.currentThread().getContextClassLoader();
-
- if (this.shadowParent != null) {
- Thread.currentThread().setContextClassLoader(classLoaderForThisTestClass);
- super.runBare();
- }
-
- else {
- ShadowingClassLoader shadowingClassLoader = (ShadowingClassLoader) classLoaderCache.get(combinationOfContextLocationsForThisTestClass);
-
- if (shadowingClassLoader == null) {
- shadowingClassLoader = (ShadowingClassLoader) createShadowingClassLoader(classLoaderForThisTestClass);
- classLoaderCache.put(combinationOfContextLocationsForThisTestClass, shadowingClassLoader);
- }
- try {
- Thread.currentThread().setContextClassLoader(shadowingClassLoader);
- String[] configLocations = getConfigLocations();
-
- // Do not strongly type, to avoid ClassCastException.
- Object cachedContext = contextCache.get(combinationOfContextLocationsForThisTestClass);
-
- if (cachedContext == null) {
-
- // Create the LoadTimeWeaver.
- Class shadowingLoadTimeWeaverClass = shadowingClassLoader.loadClass(ShadowingLoadTimeWeaver.class.getName());
- Constructor constructor = shadowingLoadTimeWeaverClass.getConstructor(ClassLoader.class);
- constructor.setAccessible(true);
- Object ltw = constructor.newInstance(shadowingClassLoader);
-
- // Create the BeanFactory.
- Class beanFactoryClass = shadowingClassLoader.loadClass(DefaultListableBeanFactory.class.getName());
- Object beanFactory = BeanUtils.instantiateClass(beanFactoryClass);
-
- // Create the BeanDefinitionReader.
- Class beanDefinitionReaderClass = shadowingClassLoader.loadClass(XmlBeanDefinitionReader.class.getName());
- Class beanDefinitionRegistryClass = shadowingClassLoader.loadClass(BeanDefinitionRegistry.class.getName());
- Object reader = beanDefinitionReaderClass.getConstructor(beanDefinitionRegistryClass).newInstance(beanFactory);
-
- // Load the bean definitions into the BeanFactory.
- Method loadBeanDefinitions = beanDefinitionReaderClass.getMethod("loadBeanDefinitions", String[].class);
- loadBeanDefinitions.invoke(reader, new Object[] {configLocations});
-
- // Create LoadTimeWeaver-injecting BeanPostProcessor.
- Class loadTimeWeaverInjectingBeanPostProcessorClass = shadowingClassLoader.loadClass(LoadTimeWeaverInjectingBeanPostProcessor.class.getName());
- Class loadTimeWeaverClass = shadowingClassLoader.loadClass(LoadTimeWeaver.class.getName());
- Constructor bppConstructor = loadTimeWeaverInjectingBeanPostProcessorClass.getConstructor(loadTimeWeaverClass);
- bppConstructor.setAccessible(true);
- Object beanPostProcessor = bppConstructor.newInstance(ltw);
-
- // Add LoadTimeWeaver-injecting BeanPostProcessor.
- Class beanPostProcessorClass = shadowingClassLoader.loadClass(BeanPostProcessor.class.getName());
- Method addBeanPostProcessor = beanFactoryClass.getMethod("addBeanPostProcessor", beanPostProcessorClass);
- addBeanPostProcessor.invoke(beanFactory, beanPostProcessor);
-
- // Create the GenericApplicationContext.
- Class genericApplicationContextClass = shadowingClassLoader.loadClass(GenericApplicationContext.class.getName());
- Class defaultListableBeanFactoryClass = shadowingClassLoader.loadClass(DefaultListableBeanFactory.class.getName());
- cachedContext = genericApplicationContextClass.getConstructor(defaultListableBeanFactoryClass).newInstance(beanFactory);
-
- // Invoke the context's "refresh" method.
- genericApplicationContextClass.getMethod("refresh").invoke(cachedContext);
-
- // Store the context reference in the cache.
- contextCache.put(combinationOfContextLocationsForThisTestClass, cachedContext);
- }
- // create the shadowed test
- Class shadowedTestClass = shadowingClassLoader.loadClass(getClass().getName());
-
- // So long as JUnit is excluded from shadowing we
- // can minimize reflective invocation here
- TestCase shadowedTestCase = (TestCase) BeanUtils.instantiateClass(shadowedTestClass);
-
- /* shadowParent = this */
- Class thisShadowedClass = shadowingClassLoader.loadClass(AbstractJpaTests.class.getName());
- Field shadowed = thisShadowedClass.getDeclaredField("shadowParent");
- shadowed.setAccessible(true);
- shadowed.set(shadowedTestCase, this);
-
- /* AbstractSpringContextTests.addContext(Object, ApplicationContext) */
- Class applicationContextClass = shadowingClassLoader.loadClass(ConfigurableApplicationContext.class.getName());
- Method addContextMethod = shadowedTestClass.getMethod("addContext", String[].class, applicationContextClass);
- ReflectionUtils.makeAccessible(addContextMethod);
- addContextMethod.invoke(shadowedTestCase, configLocations, cachedContext);
-
- // Invoke tests on shadowed test case
- shadowedTestCase.setName(getName());
- shadowedTestCase.runBare();
- }
- catch (InvocationTargetException ex) {
- // Unwrap this for better exception reporting
- // when running tests
- throw ex.getTargetException();
- }
- finally {
- Thread.currentThread().setContextClassLoader(initialClassLoader);
- }
- }
- }
-
- protected String cacheKeys() {
- return StringUtils.arrayToCommaDelimitedString(getConfigLocations());
- }
-
- /**
- * NB: This method must not have a return type of ShadowingClassLoader as that would cause that
- * class to be loaded eagerly when this test case loads, creating verify errors at runtime.
- */
- protected ClassLoader createShadowingClassLoader(ClassLoader classLoader) {
- OrmXmlOverridingShadowingClassLoader orxl = new OrmXmlOverridingShadowingClassLoader(classLoader,
- getActualOrmXmlLocation());
- customizeResourceOverridingShadowingClassLoader(orxl);
- return orxl;
- }
-
- /**
- * Customize the shadowing class loader.
- * @param shadowingClassLoader this parameter is actually of type
- * ResourceOverridingShadowingClassLoader, and can safely to be cast to
- * that type. However, the signature must not be of that type as that
- * would cause the present class loader to load that type.
- */
- protected void customizeResourceOverridingShadowingClassLoader(ClassLoader shadowingClassLoader) {
- // empty
- }
-
- /**
- * Subclasses can override this to return the real location path for
- * orm.xml or null if they do not wish to find any orm.xml
- * @return orm.xml path or null to hide any such file
- */
- protected String getActualOrmXmlLocation() {
- return DEFAULT_ORM_XML_LOCATION;
- }
-
-
- private static class LoadTimeWeaverInjectingBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
-
- private final LoadTimeWeaver ltw;
-
- @SuppressWarnings("unused")
- public LoadTimeWeaverInjectingBeanPostProcessor(LoadTimeWeaver ltw) {
- this.ltw = ltw;
- }
-
- @Override
- public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
- if (bean instanceof LocalContainerEntityManagerFactoryBean) {
- ((LocalContainerEntityManagerFactoryBean) bean).setLoadTimeWeaver(this.ltw);
- }
- if (bean instanceof DefaultPersistenceUnitManager) {
- ((DefaultPersistenceUnitManager) bean).setLoadTimeWeaver(this.ltw);
- }
- return bean;
- }
- }
-
-
- private static class ShadowingLoadTimeWeaver implements LoadTimeWeaver {
-
- private final ClassLoader shadowingClassLoader;
-
- @SuppressWarnings("unused")
- public ShadowingLoadTimeWeaver(ClassLoader shadowingClassLoader) {
- this.shadowingClassLoader = shadowingClassLoader;
- }
-
- @Override
- public void addTransformer(ClassFileTransformer transformer) {
- try {
- Method addClassFileTransformer =
- this.shadowingClassLoader.getClass().getMethod("addTransformer", ClassFileTransformer.class);
- addClassFileTransformer.setAccessible(true);
- addClassFileTransformer.invoke(this.shadowingClassLoader, transformer);
- }
- catch (Exception ex) {
- throw new RuntimeException(ex);
- }
- }
-
- @Override
- public ClassLoader getInstrumentableClassLoader() {
- return this.shadowingClassLoader;
- }
-
- @Override
- public ClassLoader getThrowawayClassLoader() {
- // Be sure to copy the same resource overrides and same class file transformers:
- // We want the throwaway class loader to behave like the instrumentable class loader.
- ResourceOverridingShadowingClassLoader roscl =
- new ResourceOverridingShadowingClassLoader(getClass().getClassLoader());
- if (this.shadowingClassLoader instanceof ShadowingClassLoader) {
- roscl.copyTransformers((ShadowingClassLoader) this.shadowingClassLoader);
- }
- if (this.shadowingClassLoader instanceof ResourceOverridingShadowingClassLoader) {
- roscl.copyOverrides((ResourceOverridingShadowingClassLoader) this.shadowingClassLoader);
- }
- return roscl;
- }
- }
-
-}
diff --git a/spring-orm/src/test/java/org/springframework/test/jpa/OrmXmlOverridingShadowingClassLoader.java b/spring-orm/src/test/java/org/springframework/test/jpa/OrmXmlOverridingShadowingClassLoader.java
deleted file mode 100644
index 9cf1ded10a8..00000000000
--- a/spring-orm/src/test/java/org/springframework/test/jpa/OrmXmlOverridingShadowingClassLoader.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright 2002-2012 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.test.jpa;
-
-import org.springframework.instrument.classloading.ResourceOverridingShadowingClassLoader;
-
-/**
- * Subclass of ShadowingClassLoader that overrides attempts to
- * locate {@code orm.xml}.
- *
- * This class must not be an inner class of AbstractJpaTests
- * to avoid it being loaded until first used.
- *
- * @author Rod Johnson
- * @author Adrian Colyer
- * @author Juergen Hoeller
- * @since 2.0
- */
-class OrmXmlOverridingShadowingClassLoader extends ResourceOverridingShadowingClassLoader {
-
- /**
- * Default location of the {@code orm.xml} file in the class path:
- * "META-INF/orm.xml"
- */
- public static final String DEFAULT_ORM_XML_LOCATION = "META-INF/orm.xml";
-
-
- public OrmXmlOverridingShadowingClassLoader(ClassLoader loader, String realOrmXmlLocation) {
- super(loader);
-
- // Automatically exclude classes from these well-known persistence providers.
- // Do NOT exclude Hibernate classes --
- // this causes class casts due to use of CGLIB by Hibernate.
- // Same goes for OpenJPA which will not enhance the domain classes.
- excludePackage("oracle.toplink.essentials");
- excludePackage("junit");
-
- override(DEFAULT_ORM_XML_LOCATION, realOrmXmlLocation);
- }
-
-}
diff --git a/spring-orm/src/test/resources/org/springframework/beans/factory/xml/child.xml b/spring-orm/src/test/resources/org/springframework/beans/factory/xml/child.xml
deleted file mode 100644
index 44ca56ef3ad..00000000000
--- a/spring-orm/src/test/resources/org/springframework/beans/factory/xml/child.xml
+++ /dev/null
@@ -1,51 +0,0 @@
-
-
-
-
- *
- *
- *
- * <dependency>
- * <groupId>xerces</groupId>
- * <artifactId>xercesImpl</artifactId>
- * <version>2.8.1</version>
- * </dependency>
- *
- *
- * @author Rod Johnson
- * @author Rob Harrop
- * @author Juergen Hoeller
- * @since 2.0
- * @deprecated as of Spring 3.0, in favor of using the listener-based test context framework
- * ({@link org.springframework.test.context.junit38.AbstractJUnit38SpringContextTests})
- */
-@Deprecated
-public abstract class AbstractJpaTests extends AbstractTransactionalSpringContextTests {
-
- private static final String DEFAULT_ORM_XML_LOCATION = "META-INF/orm.xml";
-
- /**
- * Map from String defining unique combination of config locations, to ApplicationContext.
- * Values are intentionally not strongly typed, to avoid potential class cast exceptions
- * through use between different class loaders.
- */
- private static Map
-
-
-
-