ObMimic Community/Professional Edition “Read Me”
ObMimic™ from OpenBrace is a library of fully-configurable plain-Java™ implementations of the Servlet API’s interfaces and abstract classes, for use as test doubles in “out-of-container” testing of servlets, filters, listeners and any other code that uses the Servlet API (including, for example JSF pages).
We call these implementations of the Servlet API classes “mimics”, because they accurately mimic the behaviour of the corresponding real Servlet API objects in normal servlet-container implementations.
With ObMimic, your tests can use normal Java code to create and
configure instances of HttpServletRequest, HttpServletResponse,
ServletContext, HttpSession, and other Servlet API interfaces
and classes for use in your tests. At its simplest, you can (for
new HttpServletRequestMimic() to
obtain a complete, ready-to-use HttpServletRequest with
reasonable default/example content (including a suitable default
Each mimic instance contains a mimicState object that encapsulates the logical state of the instance, and provides comprehensive facilities for configuring and examining the instance’s logical state. This includes direct control over everything that affects the behaviour and return values of the instance’s Servlet API methods (whilst maintaining consistency between related Servlet API methods, and with these state-manipulation facilities being quite distinct and separate from the Servlet API methods themselves).
You can thus construct “mimic” instances, configure them to have any required internal state, pass them to the servlets or other components that you want to test, and then check their resulting state — all within normal Java code (for example, within a normal JUnit or TestNG test case), without any need for packaging and deployment into a servlet container, without any need for complex “in-container” testing tools, and without any networking overheads.
You can also freely configure differing “deployment
descriptor” values within your tests without having to
manipulate web.xml files and without having to redeploy or
restart anything (for example, to test a Servlet or Filter with a
variety of different “init parameter” values).
Similarly, you can programmatically control the behaviour of
container-dependent features (such as whether or not the use of
HttpServletRequest.getHeaderNames method to
access HTTP header names is supported). In addition, ObMimic can
detect and report API calls that make incorrect or ambiguous use
of the Servlet API. With a “Professional” or
“Enterprise” licence you can configure how ObMimic
handles such calls.
With a “Professional” or “Enterprise” licence, you can also use the mimicHistory object contained in each mimic instance to optionally record the details and results of a sequence of calls to the instance’s Servlet API methods for subsequent examination; or you can use the mimicListeners object contained in each mimic instance to intercept and examine (and optionally even modify) the details and results of each call to the instance’s Servlet API methods as each call occurs. You can also explicitly test your code against different versions of the Servlet API.
Unlike traditional “mocks” and “stubs”, ObMimic’s “mimic” classes provide complete, ready-made implementations that fully implement all of the behaviour defined by the Servlet API (including, for example, RequestDispatcher “forward”s and “include”s, filter chains, cross-context session-handling, notification of listeners etc), and correctly handle even complex sequences of Servlet API calls. As a result, tests that use ObMimic do not depend on your own expectations of how the Servlet API methods should behave. Nor do you need to know the precise sequence of Servlet API calls that will result from your code and the responses that are required from each of these calls.
As well as making your tests more meaningful and less fragile, this also means that with suitable configuration you can use ObMimic to test the overall operation of multiple components and “framework” code. You can even use it where your code involves third-party libraries and frameworks that make their own internal calls to the Servlet API. For example, you can use ObMimic for out-of-container testing of JSF pages, as described in the “How To” guide How to test JSF pages.
Note that whilst ObMimic provides implementations of the Servlet API interfaces and classes as defined by their Javadoc, it is not itself a servlet container, nor is it an implementation of the “Servlet Specification”, nor is any of its code intended for use inside a servlet container.
2 Supported Servlet API Versions
By default, this release of ObMimic simulates the Servlet 2.5 API as defined by the Servlet 2.5 MR2 Javadoc.
With a “Professional” or “Enterprise” licence, ObMimic can be configured to simulate any of the following versions of the Servlet API (either globally for all tests or programmatically within individual tests, as described in the accompanying document “How to configure the Servlet API version to be simulated”):
- Servlet 2.3 as defined by the Servlet 2.3 Javadoc.
- Servlet 2.4 as defined by the Servlet 2.4 Javadoc.
- Servlet 2.5 as defined by the Servlet 2.5 MR2 Javadoc.
However, Servlet 3.0 and Servlet 3.1 are not yet supported. The current plan is for support for these to be introduced progressively in subsequent releases of ObMimic. More specifically:
- This release of ObMimic is compatible with Servlet 3.0 and 3.1 API libraries but does not yet provide support for any of the features or changes introduced in Servlet 3.0 and 3.1, and cannot be configured to simulate Servlet 3.0 or 3.1.
- Any attempt to call a Servlet API method that is only present in Servlet 3.0 or 3.1 will fail with an exception. This will be an ObMimic “ApiElementAbsentException” if the method is not present in the Servlet API library being used. Otherwise it will be an ObMimic “ApiElementUnavailableException” to indicate that the relevant method is not available in the Servlet API version being simulated, unless ObMimic is configured to allow such calls to “unavailable” methods. In the latter case, ObMimic’s current implementation of the method will be called, with this implementation throwing an UnsupportedOperationException.
- Note, however, that in the latter case the call to ObMimic’s current implementation of the relevant API method remains subject to the usual MimicListeners facilities (as described in the “How To” guide How to Intercept, Examine and Modify the Servlet API Calls to a Mimic). It is therefore possible to use the MimicListeners facilities to override the normal ObMimic behaviour of throwing an UnsupportedOperationException, and to instead explicitly provide any desired processing and outcome for the call.
- Our current plan for Servlet 3.0 and 3.1 is to progressively add support for their new methods, interfaces and classes into future releases of ObMimic, under the guise of artificial “3.0-Partial” and “3.1-Partial” version numbers. Once they are fully implemented, official support for simulating them using their normal 3.0 and 3.1 version numbers will be enabled, with 3.1 as the default version. The “3.0-Partial” and “3.1-Partial” version numbers will then be retained for compatibility but treated as identical to “3.0” and “3.1” respectively.
Please feel free to contact us if you need further details of this, or if you have any specific requirements or priorities for Servlet 3.0 and 3.1 facilities.
3 Installation Instructions
For a simple, typical installation of ObMimic:
- Unzip the ObMimic-1.2.001.zip archive into the location where you wish to install ObMimic. This will result in an “ObMimic-1.2.001” directory at that location, with contents as described in 5 Directory Structure below.
- Create an OBMIMIC_HOME environment variable and set it to the path of the root of the ObMimic installation (its “ObMimic-1.2.001” directory).
- If you have a “Professional” or “Enterprise” licence for ObMimic, place the licence file into the ObMimic installation’s /licence subdirectory.
For more complete details and alternative options, refer to the installation instructions given in the accompanying Getting Started (Detailed Version) document and the “How To” guides How to enable “Professional” and “Enterprise” edition features and How to set an ObMimic configuration property.
4 System Requirements
An installation of ObMimic occupies less than 50 MB of disk space.
Compiling and running tests that make use of ObMimic requires a JDK or JRE for Java™ SE 5 or higher (with Java SE 8 recommended).
In addition, any code that makes use of ObMimic will require the following to be on its classpath:
- ObMimic’s obmimic.jar archive (as supplied in ObMimic’s /lib directory).
- A Servlet API or Java EE API library that is suitable for use at run-time. That is, a “servlet.jar”, “servlet-api.jar”, “javax.servlet.jar”, “javax.servlet-api.jar”, “javaee.jar” or other such library that provides the Servlet API and is not one of the Java EE API jars that are deliberately restricted to compile-time use only (such as the “javaee-api-7.0.jar” and “javaee-web-api-7.0.jar” archives from the java.net website and elsewhere, as described below). For this release of ObMimic, this must be for version 2.4, 2.5, 3.0 or 3.1 of the Servlet API.
- If running on Java SE 5 and not using a full Java EE API
library for Java EE 5 or higher, a suitable
“Common Annotations” library will also be
required to provide the
javax.annotationpackage (note that this is automatically present when running on Java SE 6 or higher, or if using a full Java EE API for Java EE 5 or higher). Refer to the notes below for further details, including where to obtain such a library if you need one.
- Whilst ObMimic remains compatible with Java SE 5 onwards, any other libraries that you are using may impose higher requirements (for example, if you are using a Servlet 3.1 or Java EE 7 API library this will itself require the use of Java SE 7 or higher). In addition, once Java SE 9 is released it is likely that compatibility with Java SE 5 will be dropped and Java SE 6 or higher will be required.
- Any code being tested using ObMimic will, almost by definition, already be dependent on the Servlet API. It will therefore already need a suitable Servlet API library to be present in its compilation classpath, regardless of whether or not ObMimic is being used. The only additional requirement introduced by the use of ObMimic is that the Servlet API library will be needed for the ObMimic-based tests of the code as well as for compiling the code (and such tests will need a Servlet API library for Servlet 2.4 or higher even if an earlier Servlet API version is being used for other purposes). However, note that some Java EE API jars are deliberately restricted to compile-time use only, and are therefore not suitable for use with ObMimic — if one of these libraries is already being used, then a different or additional library will be needed on the classpath used for running any ObMimic-based tests (see below for further details).
- As of late 2013, some Java EE API jars are deliberately restricted to compile-time use only, and cannot be used at run-time (for example, when running tests using ObMimic). These Java EE API jars deliberately omit various classes and resources that their own internal code makes use of. Some of the classes in these jars may therefore fail with various exceptions (typically “ClassNotFoundException”, “NoClassDefFoundError” or “ExceptionInInitializerError”) if these classes are loaded for run-time use (for example, when running ObMimic-based tests). In particular, this is true of the “javaee-api-7.0.jar” and “javaee-web-api-7.0.jar” libraries provided by the java.net website, and the copies of these jars available from various Maven™ repositories. ObMimic attempts to detect the presence of such a library as soon as possible during any run and throws an “UnacceptableApiJarException” if such a library is detected, so as to provide a clearer indication of this than would otherwise result from the library's own internal failure. If your project is using such a library, you will need to replace or supplement it with a different Java EE API or Servlet API library for your ObMimic-based test runs. For more complete details and explanation, see the FAQ entry “Why do I get an UnacceptableApiJarException?”.
- If you do not otherwise have a suitable Servlet API or Java
EE API library, you can obtain a suitable library for
Servlet 3.1 from any of the following locations (for
- The “javax.servlet-api.jar” file from within the /glassfish/modules directory of the GlassFish Open Source Edition 4.0 application server (which can be downloaded from https://glassfish.java.net/download.html, or as part of the Java EE 7 SDK which can be downloaded via http://www.oracle.com/technetwork/java/javaee/downloads/index.html).
- The “servlet-api.jar” from the /lib directory of the Apache Tomcat™ 8 binary distribution (which can be downloaded from the Tomcat 8 download page).
- An appropriate Maven repository or other such public repository, for example by downloading the servlet-api-3.1.0.jar file from http://repo1.maven.org/maven2/javax/servlet/javax.servlet-api/3.1.0/javax.servlet-api-3.1.0.jar.
- You can obtain a “servlet-api.jar” for earlier versions of the Servlet API from the /lib directory of the relevant Apache Tomcat™ binary distribution (which can be downloaded from the Tomcat 6 download page for Servlet 2.5 or from the Tomcat 7 download page for Servlet 3.0).
- Similarly, equivalent files for various versions of the Servlet API or Java EE are typically bundled in other such servlet containers and application servers and in relevant development tools, and can similarly be downloaded from appropriate Maven repositories and other such sources.
javax.annotation“Common Annotations” package is a standard feature of both Java SE 6 onwards and Java EE 5 onwards, and is thus automatically present when running on Java SE 6 or higher or using a suitable Java EE 5 or higher “javaee.jar”. However, if running on Java SE 5 and not using a Java EE 5 or higher library, this package will need to be provided by a separate library. Also note that the version of this package provided by Java EE 6 requires Java SE 6 or higher, so if using a Java EE 6 library but running on Java SE 5 this package will need to be provided separately and placed ahead of the Java EE 6 library on your classpath. If you do need to obtain a separate library for this, one example is the “annotations-api.jar” from the /lib directory of an Apache Tomcat 6 binary distribution.
- In general, ObMimic requires a Servlet API library for the highest version of the Servlet API that you wish to simulate, and will throw an “ApiElementAbsentException” if an attempt is made to invoke a Servlet API method that does not exist in the Servlet API library being used. (However, as there are only minimal differences between Servlet 2.4 and Servlet 2.5, ObMimic accommodates the differences between these two particular versions and can simulate Servlet 2.5 even when using a Servlet 2.4 library).
5 Directory Structure
The directory structure and contents of an ObMimic installation are as follows.
The root directory of the ObMimic installation contains:
- This README.html file.
- LICENCE.html: The ObMimic “Community/Professional Edition” licence agreement.
Note that these README.html and LICENCE.html files make use of stylesheets, images and other resources from within the main ObMimic documentation in the /docs directory.
This is the default location for ObMimic’s configuration file, with contents:
- config.properties: The default properties file that specifies configuration settings for ObMimic. Refer to the accompanying “How To” guide How to set an ObMimic configuration property for details of how to this file and various other mechanisms can be used to set ObMimic configuration properties (and for details on how to use a different configuration file instead of this one).
This directory consists of a number of subdirectories containing ObMimic’s documentation and its various accompanying stylesheets, images and other resources.
Note that the ObMimic Javadoc is currently supplied in the Javadoc style generated by Java SE 7.
This directory contains the various CSS stylesheets that are used by the ObMimic documentation (for both the README.html and LICENCE.html files in the root of the directory structure and the main ObMimic documentation within the /docs/pages directory and its subdirectories).
This directory contains the various icons, logos and other images used within the ObMimic documentation (for both the README.html and LICENCE.html files in the root of the directory structure and the main ObMimic documentation within the /docs/pages directory and its subdirectories).
- A copy of the PIE.htc file from the open-source CSS3 PIE project, which is used to improve the appearance of the documentation’s pages when viewed in versions of Microsoft Internet Explorer® prior to MSIE 9.
- A copy of the IE7.js file and its accompanying blank.gif file from the open-source ie7-js project, which is used to improve the appearance of the documentation’s pages when viewed in versions of Microsoft Internet Explorer® prior to MSIE 7.
- A MimicStateSummary.js script which is used to support expanding/collapsing of various sections within the /docs/pages/MimicStateSummary.html page.
- A respond.min.js file from Scott Jehl’s Respond.js script, which is used to improve the appearance of the documentation’s pages when viewed in versions of Microsoft Internet Explorer® prior to MSIE 9.
Refer to the Legal Notices page for copyright and licensing details for the PIE.htc, IE7.js and respond.min.js files.
ObMimic’s main documentation, consisting of:
- index.html: Index page for the ObMimic documentation with links to the other documents.
- GettingStartedShort.html: A short (one page) summary of how to install and start using ObMimic, including some simple example code.
- GettingStartedDetailed.html: A guide to installing, configuring and starting to use ObMimic, including an overview of ObMimic and its key features, some example code, and notes regarding the design of ObMimic and its possible use. Note that this expands on the brief summary given in the shorter “GettingStartedShort.html” document.
- MimicStateSummary.html: A summary of the properties and methods each of ObMimic’s MimicState classes (which encapsulate the logical internal state of ObMimic’s implementations of the Servlet API classes). This provides a high-level guide to these classes as a supplement to the more detailed and extensive information given by each MimicState’s Javadoc.
- DesignPrinciples.html: A detailed explanation of some of the main principles and decisions that have shaped the analysis, design and implementation of ObMimic, in the context of its aims, overall approach and intended features.
- Changes.html: An index to the various separate pages within the /docs/pages/changes directory that document the changes between ObMimic releases.
- FAQ.html: ObMimic frequently-asked questions.
- Support.html: Details on how to obtain support and report bugs.
This directory contains an HTML page for each release of ObMimic that documents its changes from the preceding release (as indexed by the /docs/pages/Changes.html page).
A set of guides on how to tackle a variety of specific tasks when using ObMimic and how to use particular features of ObMimic, consisting of:
- An index.html page that lists the various “How To” guides grouped into a number of categories.
- An separate HTML page for each individual guide.
Miscellaneous files, consisting of:
- obmimic.policy: An example Java security policy file that documents the permissions that ObMimic’s own code may require when run with a security manager.
- obmimic.pom.xml: A Maven POM file that can be used to install the obmimic.jar library into a local Maven repository if desired.
- The obmimic.pom.xml file is provided to support optional
installation of the obmimic.jar library into a Maven
respository (with a groupId of “com.openbrace”
and an artifactId of “obmimic”). This can be
used, for example, to install the ObMimic library into the
user’s local Maven repository by means of the
following command (where “...path....” is the
path of the ObMimic installation, as typically specified
by an OBMIMIC_HOME environment variable):
mvn install:install-file -Dfile=...path.../lib/obmimic.jar -DpomFile=...path.../etc/obmimic.pom.xml
- For users of version 2.5 or higher of the Maven
“Install” plugin, the
“-DpomFile” argument can be omitted from the
install-filecommand shown above, as an equivalent pom.xml file is also included within the obmimic.jar itself at the appropriate location, and Maven can find and use this automatically when given the obmimic.jar archive to install.
ObMimic libraries, with contents:
- obmimic.jar: The java archive containing ObMimic’s classes and supporting files.
- The obmimic.jar archive contains both a set of com.openbrace.obmimic.* packages that provide the ObMimic-specific functionality, and a set of com.openbrace.obcommon.* packages that provide various supporting facilities and utility classes that are not ObMimic-specific and may potentially be of more general use.
- A Maven “pom” file is provided both within the obmimic.jar and separately in the /etc directory to support optional installation of the obmimic.jar library (as described above for the /etc/obmimic.pom.xml file).
This is the default location in which ObMimic looks for an ObMimic licence properties file to be used (failing which the “Community” edition is assumed).
Refer to the accompanying “How To” guide How to enable “Professional” and “Enterprise” edition features for details of how ObMimic locates the licence file and how to specify the use of a licence file in a different location.
6 Getting Started
Once ObMimic is installed, you can use it by adding its
/lib/obmimic.jar archive to your code’s
classpath (together with a suitable Servlet API library if not
already present). You can then write code to create mimic
instances for use in your tests as necessary, and can configure
and inspect the internal state of these mimic instances via their
For a short (one page) guide to installing and using ObMimic, see the Getting Started (Short Version) document.
For a more extensive guide, including additional details and explanations and an outline of ObMimic’s design and features, see the Getting Started (Detailed Version) document.
In addition, note that:
- For projects using Maven, ObMimic includes a Maven “pom” file that can be used to install its obmimic.jar library into your local Maven repository for use in your projects. For details, see the accompanying “How To” guide How to add ObMimic to a Maven-based project.
- ObMimic’s How To guides provide guidance on how to use ObMimic for specific commonly-encountered tasks.
- The Overview of MimicState Classes document summarizes the contents of each of ObMimic’s “MimicState” classes so as to help you find your way around the internal state of each mimic class when configuring and inspecting mimic instances.
- ObMimic’s Javadoc provides full details for all of ObMimic’s classes and methods.
7 Current Limitations
The following issues are known limitations and omissions in this release of ObMimic. It is hoped that many of these issues can be addressed in future releases.
If any of these issues are a particular problem for you, or are otherwise of specific interest to you, please let us know via the ObMimic feature requests forum at https://www.openbrace.com/forums/obmimic/features.html.
7.1 ObMimic is not designed for use within servlet containers
ObMimic is intended solely to enable “out-of-container” testing, and is neither designed nor intended for use within a servlet container. In particular it is neither designed nor intended for use within “live” systems.
Any use of ObMimic code within a servlet container is likely to encounter thread-safety issues (as per 7.3 below); is unlikely to interact correctly with the internal operation of the servlet container’s own Servlet API objects (which in general will interact with each other using implementation-specific mechanisms); could potentially be used to bypass or interfere with the servlet container’s own mechanisms; could potentially introduce security risks; and may be subject to other arbitrary issues and limitations.
Any attempt to use ObMimic code within a servlet container or “live” system is entirely at your own risk.
7.2 JSP pages are not yet supported
ObMimic does not currently provide any explicit support for
JSP. For example, its
servlet definitions allow a
servlet-class to be
specified but not a
jsp-file, and any
“.jsp” resources are treated as normal text
resources with no special processing.
Mimic classes or other support for JSPs (for example, facilities for configuring the use of an external JSP translator/processor) may be introduced in future versions.
In the meantime, any “forward”s or other such routing
to URLs that would normally invoke JSP pages can be configured
to invoke a suitable servlet instead (for example, a simple
HttpServletMimic instance). Refer to the
How to cater for JSP pages
document for further details and examples.
7.3 Mimics and their MimicStates are not thread-safe
ObMimic is intended for single-threaded testing of the functionality of code that uses the Servlet API, and in general it is not specifically intended to be thread-safe.
Some particular Mimic classes are designed to be thread-safe if
used appropriately (as explained in their Javadoc), on the basis
that they simulate Servlet API interfaces and classes that are
required to be thread-safe. This applies to the Mimic classes for
javax.servlet.http.HttpServlet, and the various
Servlet API “listener” interfaces.
- Some of the supporting classes and methods within the ObMimic library happen to be thread-safe, or are thread-safe when used in an appropriate manner, as defined in their Javadoc.
- ObMimic’s built-in in-memory JNDI simulation treats each thread as having an associated ServletContext so that it can maintain separate sets of JNDI bindings for each ServletContext and use the appropriate set of bindings when a thread issues a JNDI look-up, and all of the operations involved in providing this behaviour are thread-safe.
However, in general the thread-safety of ObMimic classes is largely undefined and is not currently guaranteed, and ObMimic should be treated as not being thread-safe.
Note that whilst this prevents the use of ObMimic for testing the thread-safety of application code, it should not otherwise be an issue for normal use of ObMimic. At worst, if tests really must be run concurrently by multiple threads for any reason, each test or each thread can use its own set of Mimics and other objects so as to ensure that they are not subject to concurrent calls from multiple threads, or alternatively the tests can provide their own synchronization to control access to the relevant objects.
Future versions of ObMimic may provide more fully-specified multi-threaded behaviour. Potentially this might even include mechanisms to provide some degree of checking that application code is using the Servlet API in a thread-safe manner.
7.4 Application-wide error handling is not yet supported
Although ObMimic’s support for the
deployment descriptor element does include an
exception-type sub-element, ObMimic as a whole does
not currently support the automatic trapping of exceptions within
a web-application and the corresponding use of such
error-page elements when handling such an
Support for more complete handling of exceptions and
error-page definitions with
exception-type elements may be added in future
7.5 Welcome pages and directory indexes are not supported
ObMimic’s support for mapping URLs to target resources does not currently cater for “welcome” pages, nor for the generation of directory indexes for URLs that map to directory names within a web-application’s static resources.
Support for such facilities may be added in future releases.
7.6 Deployment-descriptor limitations
ObMimic’s support for web.xml deployment descriptors and their constituent elements is currently subject to a number of general limitations:
- ObMimic does not currently provide any mechanism for
populating a ServletContextMimic’s
deployment-descriptor settings from a web.xml file. Current
intention is to introduce a suitable mechanism for this in a
future release. In the meantime, all required
deployment-descriptor settings must instead be explicitly
configured on the relevant ServletContextMimic’s
mimicState and its sub-components (primarily its
- In general, ObMimic does not currently provide any support
for deployment descriptor elements that do not affect the
current ObMimic facilities (for example, there is no support
security-role-refelements of a
7.7 Built-in JNDI simulation supports only basic JNDI facilities
ObMimic’s built-in JNDI simulation does not currently support JNDI federation, composite names, “references” or “links”. If you need to use such facilities within ObMimic tests, you will need to make use of some other JNDI implementation instead of (or in addition to) ObMimic’s built-in JNDI simulation.
7.8 Resource injection in Servlet 2.5 onwards is only partially supported
When simulating Servlet API 2.5 and higher, this version of
@PreDestroy annotations, and
annotations for fields and methods. However, it does not
currently process any class-level
annotations or any resource-injection annotations other than
In addition, the processing of
is subject to a somewhat arbitrary interpretation of how such
annotations should be processed on overridden and overriding
methods, as the documentation for the
annotation, “Common Annotations” in general, and Java
annotations in general are somewhat unclear and contradictory on
this. For further details and explanation, refer to the Javadoc
Note that explicit “manual” injection of the necessary resources should usually be possible even if the built-in processing of resource-injection annotations proves to be inadequate for any particular scenario.
More comprehensive handling of resource-injection annotations may be provided in future releases.
7.9 Temporary directories are not automatically provided
This version of ObMimic does not automatically provide each
servlet context with a
context attribute pointing to a “temporary”
directory. Any tests of code that requires such an attribute and
temporary directory must explicitly configure this
7.10 Mimics are not Serializable
ObMimic’s Mimic classes are not serializable even where the
interface or abstract class that they implement is
Serializable. This is because the MimicState classes used within
the Mimic classes are not themselves Serializable (and in some
cases contain objects that are not easily serializable, such as
In this release of of ObMimic this only affects the GenericServletMimic and HttpServletMimic classes, as these are the only Mimic classes for Serializable classes. This is not expected to present any problems during normal use of ObMimic.
An up-to-date official list of currently-known ObMimic bugs can be found at https://openbrace.16bugs.com/projects/3203/bugs.
To report a suspected bug or discuss an existing bug report, please use the “ObMimic Bugs” discussion forum at https://www.openbrace.com/forums/obmimic/bugs.html. OpenBrace will investigate and respond as appropriate, and raise or update a formal bug report where necessary.
For technical queries, feature requests and other such support, please use the relevant ObMimic discussion forum at https://www.openbrace.com/forums/list.html. We monitor and participate in these forums, and they are normally the fastest and most effective way to contact us (and they also include “Private Messaging” facilities if you wish to contact us without posting a message in public).
Additional support and downloads are available for “Enterprise Edition” customers. Please see http://www.openbrace.com/main/pages/support/enterprise-support.html for details.
Further contact details can be found on our website’s “Contact Us” page at http://www.openbrace.com/main/pages/company/contact.html.
To uninstall ObMimic:
- Remove the OBMIMIC_HOME environment variable that you set up during installation (if any).
- Delete the directory into which you installed ObMimic.
11 Further Information
For further information, please refer to:
- The ObMimic documentation index.
- The ObMimic FAQ.
- The ObMimic Getting Started (Short Version) and Getting Started (Detailed Version) guides.
- ObMimic’s How To guides.
- The accompanying Overview of MimicState Classes.
- The ObMimic Javadoc.
- The OpenBrace Limited website at www.openbrace.com.
- The ObMimic discussion forums at https://www.openbrace.com/forums/list.html.