FunctionalTestCase (Hibernate Core Aggregator 3.6.10.Final API)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - org.hibernate.testing.junit.UnitTestCase
    - - org.hibernate.testing.junit.functional.FunctionalTestCase

All Implemented Interfaces:

junit.framework.Test, ExecutionEnvironment.Settings

Direct Known Subclasses:

BaseCacheTestCase, DatabaseSpecificFunctionalTestCase
```
public abstract class FunctionalTestCase
extends UnitTestCase
implements ExecutionEnvironment.Settings
```
Most of the Hibernate test suite in fact is a series of functional tests, not unit tests. Here is a base class for these functional tests.

Author:

Steve Ebersole

Field Summary

Fields
Modifier and Type Field and Description

static Class[] NO_CLASSES

static String[] NO_MAPPINGS

Fields
Modifier and Type	Field and Description
`static Class[]`	`NO_CLASSES`
`static String[]`	`NO_MAPPINGS`

Constructor Summary

Constructors
Constructor and Description

FunctionalTestCase(String string)

Constructors
Constructor and Description
`FunctionalTestCase(String string)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`afterConfigurationBuilt(Mappings mappings, Dialect dialect)`
`void`	`afterSessionFactoryBuilt(SessionFactoryImplementor sfi)`
`protected boolean`	`allowsPhysicalColumnNameInHaving(String testDescription)` Does the db/dialect support using a column's physical name in the having clause even after it has been aliased in the select/group-by clause.
`protected boolean`	`allowsPhysicalColumnNameInOrderby(String testDescription)` Does the db/dialect support using a column's physical name in the order-by clause even after it has been aliased in the select clause.
`boolean`	`appliesTo(Dialect dialect)` Intended to indicate that this test class as a whole is intended for a dialect or series of dialects.
`protected void`	`assertAllDataRemoved()`
`protected void`	`cleanupTest()`
`void`	`configure(Configuration cfg)`
`boolean`	`createSchema()`
`protected boolean`	`dialectIs(Class dialectClass)`
`protected boolean`	`dialectIsCaseSensitive(String testDescription)` Is the db/dialect sensitive in terms of string comparisons?
`protected boolean`	`dialectIsNot(Class dialectClass)`
`protected boolean`	`dialectIsNot(Class[] dialectClasses)`
`protected boolean`	`dialectIsOneOf(Class[] dialectClasses)`
`protected boolean`	`dialectSupportsEmptyInList(String testDescription)` Does the db/dialect support empty lists in the IN operator? For example, is "...
`Class[]`	`getAnnotatedClasses()`
`String`	`getBaseForMappings()`
`String`	`getCacheConcurrencyStrategy()`
`protected Configuration`	`getCfg()`
`protected Dialect`	`getDialect()`
`ExecutionEnvironment`	`getEnvironment()`
`String[]`	`getMappings()`
`protected SessionFactory`	`getSessions()` Get the factory for this test environment.
`protected boolean`	`isSerializableIsolationEnforced()` Do connections enforce SERIALIZABLE isolation...
`Session`	`openSession()`
`Session`	`openSession(Interceptor interceptor)`
`boolean`	`overrideCacheStrategy()`
`protected void`	`prepareTest()`
`protected boolean`	`readCommittedIsolationMaintained(String scenario)` Is connection at least read committed? Not, that this skip check relies on the JDBC driver reporting the true isolation level correctly.
`boolean`	`recreateSchemaAfterFailure()`
`protected void`	`runTest()` runTest is overridden in order to apply session closure assertions.
`void`	`setEnvironment(ExecutionEnvironment environment)`
`protected void`	`setUp()` Override `TestCase.setUp()` to check if we need to build a locally managed execution environment.
`protected SessionFactoryImplementor`	`sfi()` Get the factory for this test environment, casted to `SessionFactoryImplementor`.
`protected void`	`skipExpectedFailure(Throwable error)`
`protected boolean`	`supportsCircularCascadeDelete()`
`protected boolean`	`supportsExpectedLobUsagePattern()` Expected LOB usage pattern is such that I can perform an insert via prepared statement with a parameter binding for a LOB value without crazy casting to JDBC driver implementation-specific classes...
`protected boolean`	`supportsLobValueChangePropogation()` Does the current dialect support propogating changes to LOB values back to the database? Talking about mutating the underlying value as opposed to supplying a new LOB instance...
`protected boolean`	`supportsResultSetPositionQueryMethodsOnForwardOnlyCursor()`
`protected boolean`	`supportsSubqueryOnMutatingTable()`
`protected boolean`	`supportsSubselectOnLeftSideIn()`
`protected boolean`	`supportsUnboundedLobLocatorMaterialization()` Is it supported to materialize a LOB locator outside the transaction in which it was created? Again, part of the trickiness here is the fact that this is largely driver dependent.
`protected void`	`tearDown()` Override `TestCase.tearDown()` to tear down the execution environment if it is locally managed.

Methods inherited from class org.hibernate.testing.junit.UnitTestCase
assertClassAssignability, assertElementTypeAssignability, createFailureExpectedSuite, fullTestName, reportSkip, runBare

Methods inherited from class junit.framework.TestCase
countTestCases, createResult, getName, run, run, setName, toString

Methods inherited from class junit.framework.Assert
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, fail, fail, failNotEquals, failNotSame, failSame

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - NO_MAPPINGS
```
public static final String[] NO_MAPPINGS
```
  - NO_CLASSES
```
public static final Class[] NO_CLASSES
```
- Constructor Detail
  - FunctionalTestCase
```
public FunctionalTestCase(String string)
```
- Method Detail
  - getEnvironment
```
public ExecutionEnvironment getEnvironment()
```
  - setEnvironment
```
public void setEnvironment(ExecutionEnvironment environment)
```
  - prepareTest
```
protected void prepareTest()
                    throws Exception
```
    Throws:
    
    Exception
  - cleanupTest
```
protected void cleanupTest()
                    throws Exception
```
    Throws:
    
    Exception
  - setUp
```
protected final void setUp()
                    throws Exception
```
    Override TestCase.setUp() to check if we need to build a locally managed execution environment.
    
    Overrides:
    
    setUp in class junit.framework.TestCase
    
    Throws:
    
    Exception
  - tearDown
```
protected final void tearDown()
                       throws Exception
```
    Override TestCase.tearDown() to tear down the execution environment if it is locally managed.
    
    Overrides:
    
    tearDown in class junit.framework.TestCase
    
    Throws:
    
    Exception
  - runTest
```
protected void runTest()
                throws Throwable
```
    runTest is overridden in order to apply session closure assertions.
    
    Overrides:
    
    runTest in class junit.framework.TestCase
    
    Throws:
    
    Throwable
  - assertAllDataRemoved
```
protected void assertAllDataRemoved()
```
  - skipExpectedFailure
```
protected void skipExpectedFailure(Throwable error)
```
    Overrides:
    
    skipExpectedFailure in class UnitTestCase
  - getMappings
```
public String[] getMappings()
```
    Specified by:
    
    getMappings in interface ExecutionEnvironment.Settings
  - getBaseForMappings
```
public String getBaseForMappings()
```
    Specified by:
    
    getBaseForMappings in interface ExecutionEnvironment.Settings
  - getAnnotatedClasses
```
public Class[] getAnnotatedClasses()
```
    Specified by:
    
    getAnnotatedClasses in interface ExecutionEnvironment.Settings
  - createSchema
```
public boolean createSchema()
```
    Specified by:
    
    createSchema in interface ExecutionEnvironment.Settings
  - recreateSchemaAfterFailure
```
public boolean recreateSchemaAfterFailure()
```
    Specified by:
    
    recreateSchemaAfterFailure in interface ExecutionEnvironment.Settings
  - configure
```
public void configure(Configuration cfg)
```
    Specified by:
    
    configure in interface ExecutionEnvironment.Settings
  - overrideCacheStrategy
```
public boolean overrideCacheStrategy()
```
    Specified by:
    
    overrideCacheStrategy in interface ExecutionEnvironment.Settings
  - getCacheConcurrencyStrategy
```
public String getCacheConcurrencyStrategy()
```
    Specified by:
    
    getCacheConcurrencyStrategy in interface ExecutionEnvironment.Settings
  - afterSessionFactoryBuilt
```
public void afterSessionFactoryBuilt(SessionFactoryImplementor sfi)
```
    Specified by:
    
    afterSessionFactoryBuilt in interface ExecutionEnvironment.Settings
  - afterConfigurationBuilt
```
public void afterConfigurationBuilt(Mappings mappings,
                           Dialect dialect)
```
    Specified by:
    
    afterConfigurationBuilt in interface ExecutionEnvironment.Settings
  - appliesTo
```
public boolean appliesTo(Dialect dialect)
```
    Intended to indicate that this test class as a whole is intended for a dialect or series of dialects. Skips here (appliesTo = false) therefore simply indicate that the given tests target a particular feature of the checked database and none of the tests on this class should be run for the checked dialect.
    
    Specified by:
    
    appliesTo in interface ExecutionEnvironment.Settings
    
    Parameters:
    dialect - The dialect to be checked.
    
    Returns:
    False if the test class as a whole is specifically targetting a dialect (or series of dialects) other than the indicated dialect and the test should therefore be skipped in its entirety; true otherwise.
  - getSessions
```
protected SessionFactory getSessions()
```
    Get the factory for this test environment.
    
    Returns:
    The factory.
  - sfi
```
protected SessionFactoryImplementor sfi()
```
    Get the factory for this test environment, casted to SessionFactoryImplementor.
    Shorthand for ( SessionFactoryImplementor ) getSessions()...
    
    Returns:
    The factory
  - getDialect
```
protected Dialect getDialect()
```
  - getCfg
```
protected Configuration getCfg()
```
  - openSession
```
public Session openSession()
                    throws HibernateException
```
    Throws:
    
    HibernateException
  - openSession
```
public Session openSession(Interceptor interceptor)
                    throws HibernateException
```
    Throws:
    
    HibernateException
  - isSerializableIsolationEnforced
```
protected boolean isSerializableIsolationEnforced()
                                           throws Exception
```
    Do connections enforce SERIALIZABLE isolation...
    
    Returns:
    
    Throws:
    
    Exception
  - readCommittedIsolationMaintained
```
protected boolean readCommittedIsolationMaintained(String scenario)
```
    Is connection at least read committed?
    Not, that this skip check relies on the JDBC driver reporting the true isolation level correctly. HSQLDB, for example, will report whatever you specify as the isolation (Connection.setTransationIsolation()), even though it only supports read-uncommitted.
    
    Parameters:
    scenario - text description of the scenario being tested.
    
    Returns:
    true if read-committed isolation is maintained.
  - allowsPhysicalColumnNameInOrderby
```
protected boolean allowsPhysicalColumnNameInOrderby(String testDescription)
```
    Does the db/dialect support using a column's physical name in the order-by clause even after it has been aliased in the select clause. This is not actually required by the SQL spec, although virtually ever DB in the world supports this (the most glaring omission here being IBM-variant DBs ala DB2 and Derby).
    
    Parameters:
    testDescription - description of the scenario being tested.
    
    Returns:
    true if is allowed
  - allowsPhysicalColumnNameInHaving
```
protected boolean allowsPhysicalColumnNameInHaving(String testDescription)
```
    Does the db/dialect support using a column's physical name in the having clause even after it has been aliased in the select/group-by clause. This is not actually required by the SQL spec, although virtually ever DB in the world supports this.
    
    Parameters:
    testDescription - description of the scenario being tested.
    
    Returns:
    true if is allowed
  - dialectSupportsEmptyInList
```
protected boolean dialectSupportsEmptyInList(String testDescription)
```
    Does the db/dialect support empty lists in the IN operator?
    For example, is "... a.b IN () ..." supported?
    
    Parameters:
    testDescription - description of the scenario being tested.
    
    Returns:
    true if is allowed
  - dialectIsCaseSensitive
```
protected boolean dialectIsCaseSensitive(String testDescription)
```
    Is the db/dialect sensitive in terms of string comparisons?
    
    Parameters:
    testDescription - description of the scenario being tested.
    
    Returns:
    true if sensitive
  - supportsResultSetPositionQueryMethodsOnForwardOnlyCursor
```
protected boolean supportsResultSetPositionQueryMethodsOnForwardOnlyCursor()
```
  - supportsCircularCascadeDelete
```
protected boolean supportsCircularCascadeDelete()
```
  - supportsSubselectOnLeftSideIn
```
protected boolean supportsSubselectOnLeftSideIn()
```
  - supportsExpectedLobUsagePattern
```
protected boolean supportsExpectedLobUsagePattern()
```
    Expected LOB usage pattern is such that I can perform an insert via prepared statement with a parameter binding for a LOB value without crazy casting to JDBC driver implementation-specific classes...
    Part of the trickiness here is the fact that this is largely driver dependent. For Oracle, which is notoriously bad with LOB support in their drivers actually does a pretty good job with LOB support as of the 10.2.x versions of their drivers...
    
    Returns:
    True if expected usage pattern is support; false otherwise.
  - supportsLobValueChangePropogation
```
protected boolean supportsLobValueChangePropogation()
```
    Does the current dialect support propogating changes to LOB values back to the database? Talking about mutating the underlying value as opposed to supplying a new LOB instance...
    
    Returns:
    True if the changes are propogated back to the database; false otherwise.
  - supportsUnboundedLobLocatorMaterialization
```
protected boolean supportsUnboundedLobLocatorMaterialization()
```
    Is it supported to materialize a LOB locator outside the transaction in which it was created?
    Again, part of the trickiness here is the fact that this is largely driver dependent.
    NOTE: all database I have tested which supportsExpectedLobUsagePattern() also support the ability to materialize a LOB outside the owning transaction...
    
    Returns:
    True if unbounded materialization is supported; false otherwise.
  - supportsSubqueryOnMutatingTable
```
protected boolean supportsSubqueryOnMutatingTable()
```
  - dialectIs
```
protected boolean dialectIs(Class dialectClass)
```
  - dialectIsOneOf
```
protected boolean dialectIsOneOf(Class[] dialectClasses)
```
  - dialectIsNot
```
protected boolean dialectIsNot(Class dialectClass)
```
  - dialectIsNot
```
protected boolean dialectIsNot(Class[] dialectClasses)
```

Class FunctionalTestCase

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.hibernate.testing.junit.UnitTestCase

Methods inherited from class junit.framework.TestCase

Methods inherited from class junit.framework.Assert

Methods inherited from class java.lang.Object

Field Detail

NO_MAPPINGS

NO_CLASSES

Constructor Detail

FunctionalTestCase

Method Detail

getEnvironment

setEnvironment

prepareTest

cleanupTest

setUp

tearDown

runTest

assertAllDataRemoved

skipExpectedFailure

getMappings

getBaseForMappings

getAnnotatedClasses

createSchema

recreateSchemaAfterFailure

configure

overrideCacheStrategy

getCacheConcurrencyStrategy

afterSessionFactoryBuilt

afterConfigurationBuilt

appliesTo

getSessions

sfi

getDialect

getCfg

openSession

openSession

isSerializableIsolationEnforced

readCommittedIsolationMaintained

allowsPhysicalColumnNameInOrderby

allowsPhysicalColumnNameInHaving

dialectSupportsEmptyInList

dialectIsCaseSensitive

supportsResultSetPositionQueryMethodsOnForwardOnlyCursor

supportsCircularCascadeDelete

supportsSubselectOnLeftSideIn

supportsExpectedLobUsagePattern

supportsLobValueChangePropogation

supportsUnboundedLobLocatorMaterialization

supportsSubqueryOnMutatingTable

dialectIs

dialectIsOneOf

dialectIsNot

dialectIsNot