jbosscache-core-2.2.2.GA/ 0000755 0001750 0001750 00000000000 11376174036 015003 5 ustar twerner twerner jbosscache-core-2.2.2.GA/README-i18n.txt 0000644 0001750 0001750 00000002234 10676513755 017266 0 ustar twerner twerner Internationalising documentation
--------------------------------
Documentation for JBoss Cache is written using docbook XML. There is a lot of reference material on docbook XML if
you are unfamiliar with it, but JBoss Cache's usage of docbook is pretty basic and most of it can be picked up by looking
through the existing documentation sources, which are in src/main/docbook.
For each document, the 'en' version is treated as the reference source for all translations.
Starting a new translation
--------------------------
** NB: This section needs updating since moving to subversion.
Each time a new translation is started, the docs directory should be updated and tagged as I18N_<2-letter iso lang code>_<2-letter iso country code> (optional)
such as I18N_IT or I18N_PT_BR (note all in upper case)
Updating translations
---------------------
Each time a new release is made, translations should be updated by:
1) Doing a diff of the 'en' docs, comparing the latest against the translation tag (e.g., I18N_IT)
2) Updating the translation (e.g., the 'it' docs)
3) Moving the translation tag on the 'en' files (e.g., I18N_IT) to the current snapshot.
- Manik Surtani
jbosscache-core-2.2.2.GA/pom.xml 0000644 0001750 0001750 00000043104 11147506161 016314 0 ustar twerner twerner
4.0.02.2.2.GAunitinstallorg.jboss.cachejbosscache-common-parent1.4org.jboss.cachejbosscache-core${jbosscache-core-version}JBoss Cache - Core EditionJBoss Cache - Core Editionhttp://www.jbosscache.orgjarjgroupsjgroups2.6.5.GAjavax.transactionjta1.1commons-loggingcommons-logging1.0.4org.jbossjboss-common-core2.2.8.GAapache-slidewebdavlibapache-xercesxml-apisapache-httpclientcommons-httpclientjdbmjdbm1.0truec3p0c3p00.9.1.1truesleepycatje1.7.0truenet.jcipjcip-annotations1.0truenet.noderunneramazon-s31.0.0.0trueorg.easymockeasymock2.3testjboss.jbosstsjbossjta4.3.0.GAtestbeanshellbsh2.0b4testnet.noderunnerhttp1.0testjavax.servletservlet-api2.3testmaven-assembly-plugin2.2-beta-1assembleinstallattachedassembly/bin.xmlassembly/doc.xmlassembly/all.xml${artifactId}-${jbosscache-core-version}target/distributiontarget/assembly/workorg.apache.maven.pluginsmaven-jar-plugintruetrueorg.jboss.cache.Versionbuild-test-jartest-jartruetruerepository.jboss.orghttp://repository.jboss.org/maven2snapshots.jboss.orghttp://snapshots.jboss.org/maven2e-xml.sourceforge.nethttp://e-xml.sourceforge.net/maven2/repositoryDocsfalsepackageorg.jboss.maven.pluginsmaven-jdocbook-plugin2.0.0trueorg.jbossjbossorg-docbook-xslt1.1.0org.jbossjbossorg-jdocbook-style1.1.0jdocbook-styleuserguide_enpackageresourcesgeneratemaster.xml${basedir}/src/main/docbook/userguide/en${basedir}/src/main/docbook/images${basedir}/src/main/docbook/css${basedir}/target/docbook/userguide_enpdfclasspath:/xslt/org/jboss/pdf.xsluserguide_en.pdfhtmlclasspath:/xslt/org/jboss/xhtml.xslindex.htmlhtml_singleclasspath:/xslt/org/jboss/xhtml-single.xslindex.htmlfalsetutorial_enpackageresourcesgeneratemaster.xml${basedir}/src/main/docbook/tutorial/en${basedir}/src/main/docbook/images${basedir}/src/main/docbook/css${basedir}/target/docbook/tutorial_enpdfclasspath:/xslt/org/jboss/pdf.xsltutorial_en.pdfhtmlclasspath:/xslt/org/jboss/xhtml.xslindex.htmlhtml_singleclasspath:/xslt/org/jboss/xhtml-single.xslindex.htmlfalsefaq_enpackageresourcesgeneratemaster.xml${basedir}/src/main/docbook/faq/en${basedir}/src/main/docbook/images${basedir}/src/main/docbook/css${basedir}/target/docbook/faq_enpdfclasspath:/xslt/org/jboss/pdf.xslfaq_en.pdfhtmlclasspath:/xslt/org/jboss/xhtml.xslindex.htmlhtml_singleclasspath:/xslt/org/jboss/xhtml-single.xslindex.htmlfalsetest-hudsonfunctional,unittest-functionalfunctionaltest-unitunittest-jgroupsjgroupstest-transactiontransactiontest-integrationintegrationJBossASfalse2.2.1-SNAPSHOT-JBossASfunctional,unitjgroupsjgroups2.6.5.GAorg.jboss.javaeejboss-javaee5.0.0.CR2org.jbossjboss-common-core2.2.8.GAcommons-loggingcommons-logging1.1.0.jbossjboss.jbosstsjbossjta4.4.0.GAtest
jbosscache-core-2.2.2.GA/README-Maven.txt 0000644 0001750 0001750 00000021711 11021255727 017541 0 ustar twerner twerner
1. WORKING WITH MAVEN
=====================
Requirements:
* Java 5.0 and above
* Maven 2.0.8 and above
1.1. Quickstart: Typical lifecycle phases
-----------------------------------------
Maven will create a target/ directory under the root for the creation of
output at every stage.
* mvn clean: Cleans out any old builds and binaries
* mvn compile: Compiles java source code.
* mvn test: Runs the TestNG unit test suite on the compiled code. Will also compile the tests. See the testing section
below for more information on running different test groups. The default test group run is the "unit" group.
* mvn package: Packages the module as a JAR file, the resulting JAR file will be in target/
* mvn package -Dmaven.test.skip=true: Creates a JAR file without running tests.
* mvn package -P Docs: Packages the module as a JAR file, and builds the javadocs and user documentation from docbook sources.
* mvn install: will install the artifacts in your local repo for use by other projects (such as JBoss Cache POJO edition
which depends on JBoss Cache Core). Will also use Maven's assembly plugin to build ZIP files for download
(in target/distribution)
* mvn deploy: will build and deploy the project to the JBoss snapshots repository. Note that you should have your WebDAV
username and password set up. (Deploys snapshots to http://snapshots.jboss.org/maven2/org/jboss/cache/). If you have
a non-SNAPSHOT version number in your pom.xml, it will be deployed to the live releases repository (see below)
* mvn clean site -Ptest-functional,codeCoverage: will run all tests in the test-functional profile and generate code
coverage reports using EMMA.
1.2. Setting up your WebDAV username and password to deploy project snapshots
-----------------------------------------------------------------------------
You will also have to configure maven to use your username and password to access this repository. For this, you will
have to modify the servers section of maven settings file ($MAVEN_HOME/conf/settings.xml, or ~/.m2/settings.xml).
Something similar to the following should be added:
...
...
snapshots.jboss.orgwebdav-userwebdav-pass
...
...
1.3. Deploying a release to a live repository
---------------------------------------------
Very simple. Make sure you have the version number in your pom.xml set to a non-SNAPSHOT version. Maven will pick up
on this and deploy to your release repository rather than the snapshot repository.
JBoss release repository cannot be accessed via WebDAV, as the snapshot repository can. So what you need to do is:
1) Check out the release repository from Subversion (svn co https://svn.jboss.org/repos/repository.jboss.org/maven2)
2) Add a property in ~/.m2/settings.xml to point to this 'local' copy of the repo. (See maven settings below)
3) Update your project's pom.xml to reflect a non-SNAPSHOT version number
4) Deploy your project (mvn clean deploy)
5) Check in your 'local' copy of the repo checked out in (1), adding any new directories/files created by (4).
1.4. Maven settings.xml
-----------------------
Working with the JBoss Cache source tree, I have configured my ~/.m2/settings.xml to look like:
snapshots.jboss.orgMY_JBOSS_ORG_USERNAMEWONT_TELL_YOUjboss/Users/manik/Code/maven2jboss
2. TESTING
==========
Tests are written against the TestNG testing framework. Each test should belong to one or more group. The group acts as
a filter, and is used to select which tests are ran as part of the maven test lifecycle. There are 3 groups that are
currently in use, but there is not formal, you can make up any group name if you like.
2.1. Current Groups
-------------------
* unit - Unit tests using stubs to isolate and test each major class in JBoss Cache. This is the default group run if no test group is specified.
* functional - Tests which test the general functionality of JBoss Cache
* jgroups - Tests which need to send data on a JGroups Channel
* transaction - Tests which use a transaction manager
* profiling - Tests used for manual profiling, not meant for automated test runs
* manual - Other tests that are run manually
* integration - Integration tests emulating usage patterns for specific products such as JBoss AS Clustering and Hibernate clustering
It should be noted that every test (except those not intended to be run by Hudson) should at least be in the functional
group, since this is the default test group that is executed by maven, and the one that is required to prepare a release.
2.2. Executing the default test run
-----------------------------------
The default run executes all tests in the functional group. To just run the tests with txt and xml output the command is:
$ mvn test
Alternatively, you can execute the tests AND generate a report with:
$ mvn surefire-report:report
If you already have ran a test cycle, and you want to generate a report off the current reports, then you use the
report-only goal, ike so:
$ mvn surefire-report:report-only
2.3. Executing different groups
-------------------------------
A group can be executed (using the default configuration) by simply using the appropriate profile, like so:
$ mvn -P test-jgroups test
2.4. Executing a single test
----------------------------
A single test can be executed using the test property. The value is the short name (not the fully qualified package name)
of the test.
$ mvn -P test-XXX -Dtest=FqnTest test
Alternatively, if there is more than one test with a given classname in your test suite, you could provide the path to
the test.
$ mvn -P test-XXX -Dtest=org/jboss/cache/multiplexer/SyncReplTxTest test
2.5. Executing all tests in a given package
--------------------------------------------
This can be achieved by passing in the package name with a wildcard to the test parameter.
$ mvn -P test-XXX -Dtest=org/jboss/cache/multiplexer/* test
2.6. Skipping the test run
--------------------------
It is sometimes desirable to install the jboss cache package in your local repository without performing a full test run.
To do this, simply use the maven.test.skip.exec property:
$ mvn -Dmaven.test.skip.exec=true install
Again, this is just a shortcut for local use. It SHOULD NEVER BE USED when releasing. Also, make sure "exec" is included
in the property, if not the tests will not be built, which will prevent a test jar being produced (POJO Cache needs the
Core Cache test jar).
2.7. Permutations
-----------------
We use the term permutation to describe a group execution against a particular config. This allows us to test a variety
of environments and configurations without rewriting the same basic test over and over again. For example, the jgroups-tcp
permutation executes the jgroups group using the TCP config. Each permutation requires a maven profile which defines the
various options, environmental variables, etc. The command to run the jgroups-tcp permutatin is:
$ mvn -Pjgroups-tcp surefire-report:report
Each permutation uses its own report directory, and its own html output file name. This allows you to execute multiple
permutations without wiping the results from the previous run. Note that due to the way maven operates, only one
permutation can be executed per mvn command. So automating multiple runs requires shell scripting, or some other execution
framework to make multiple called to maven.
2.8. Running permutations manually or in an IDE
-----------------------------------------------
Sometimes you want to run a test using settings other than the defaults (such as UDP for "jgroups" group tests or the
DummyTransactionManager for "transaction" group tests). This can be achieved by referring to the Maven POM file
to figure out which system properties are passed in to the test when doing something different.
E.g., to run a "jgroups" group test in your IDE using TCP instead of the default UDP, set the following:
-Djgroups.stack=tcp
Or, to use JBoss JTA (Arjuna TM) instead of the DummyTransactionManager in a "transaction" group test, set:
-Dorg.jboss.cache.test.tm=jboss-jta
Please refer to the POM file for more properties and permutations.
2.9. Integration with CruiseControl / Hudson
--------------------------------------------
CruiseControl should do the following:
* Run "mvn clean site" - will clean and run tests, and then prepare reports. In addition to unit tests, this project is
set up to run FindBugs, PMD, jxr, and a bunch of other code analysis tools and provide a report in
target/site/project-reports.html - which should be linked from the CruiseControl summary page.
jbosscache-core-2.2.2.GA/assembly/ 0000755 0001750 0001750 00000000000 11376173731 016623 5 ustar twerner twerner jbosscache-core-2.2.2.GA/assembly/bin.xml 0000644 0001750 0001750 00000002614 10757176162 020123 0 ustar twerner twerner binziptruetarget*.jar*test*.jarsrc/main/etcetcsrc/main/release**/*.txtlib${artifactId}.${extension}falseruntimeapache-xerces:xml-apisapache-httpclient:commons-httpclientapache-slide:webdavlib
jbosscache-core-2.2.2.GA/assembly/doc.xml 0000644 0001750 0001750 00000001345 10660525510 020104 0 ustar twerner twerner docziptruesrc/main/release*.txt**lib**license/*target/site/apidocsdoc/apidocstarget/docbookdoc/
jbosscache-core-2.2.2.GA/assembly/all.xml 0000644 0001750 0001750 00000004253 10757176162 020124 0 ustar twerner twerner allziptruetarget*.jar*test*.jarsrc/main/etcetcsrc/main/javasrcsrc/test/javatestsrc/test/resourcestestsrc/main/release**/*.txt**/*.xmltarget/site/apidocsdoc/apidocstarget/docbookdoc/lib${scope}/${artifactId}.${extension}falsetestapache-xerces:xml-apisapache-httpclient:commons-httpclientapache-slide:webdavlib
jbosscache-core-2.2.2.GA/src/ 0000755 0001750 0001750 00000000000 11376173772 015600 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/ 0000755 0001750 0001750 00000000000 11376173770 016555 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/ 0000755 0001750 0001750 00000000000 11376173731 017473 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/org/ 0000755 0001750 0001750 00000000000 11376173731 020262 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/org/jboss/ 0000755 0001750 0001750 00000000000 11376173731 021402 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/ 0000755 0001750 0001750 00000000000 11376173770 022450 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/jmx/ 0000755 0001750 0001750 00000000000 11376173752 023246 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/jmx/CacheJmxWrapperTestBase.java 0000644 0001750 0001750 00000012335 10736672510 030566 0 ustar twerner twerner package org.jboss.cache.jmx;
import org.jboss.cache.Cache;
import org.jboss.cache.CacheFactory;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.config.Configuration;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.MBeanServerInvocationHandler;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
/**
* Tests the JMX wrapper class around the cache.
*
* @author Manik Surtani
* @author Brian Stansberry
*/
@Test(groups = "functional")
public abstract class CacheJmxWrapperTestBase
{
public static final String CLUSTER_NAME = "CacheMBeanTest";
protected Cache cache;
protected CacheJmxWrapperMBean jmxWrapper;
protected MBeanServer mBeanServer;
protected ObjectName mBeanName;
protected String mBeanNameStr;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
mBeanServer = MBeanServerFactory.createMBeanServer("CacheMBeanTest");
mBeanNameStr = JmxUtil.PREFIX + CLUSTER_NAME;
mBeanName = new ObjectName(mBeanNameStr);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
try
{
cleanup();
}
finally
{
if (mBeanServer != null)
{
MBeanServerFactory.releaseMBeanServer(mBeanServer);
mBeanServer = null;
}
}
}
protected CacheJmxWrapperMBean registerWrapper() throws Exception
{
if (cache == null)
cache = createCache(createConfiguration());
return registerWrapper(cache);
}
protected CacheJmxWrapperMBean registerWrapper(Cache toWrap) throws Exception
{
CacheJmxWrapper wrapper = new CacheJmxWrapper(toWrap);
return registerWrapper(wrapper);
}
protected CacheJmxWrapperMBean registerWrapper(Configuration config) throws Exception
{
CacheJmxWrapper wrapper = new CacheJmxWrapper();
wrapper.setConfiguration(config);
return registerWrapper(wrapper);
}
@SuppressWarnings("unchecked")
protected CacheJmxWrapperMBean registerWrapper(CacheJmxWrapperMBean wrapper) throws Exception
{
JmxUtil.registerCacheMBean(mBeanServer, wrapper, mBeanNameStr);
jmxWrapper = (CacheJmxWrapperMBean) MBeanServerInvocationHandler.newProxyInstance(mBeanServer, mBeanName, CacheJmxWrapperMBean.class, false);
return jmxWrapper;
}
protected void unregisterWrapper() throws Exception
{
mBeanServer.unregisterMBean(mBeanName);
}
protected CacheJmxWrapper createWrapper(Configuration config)
{
CacheJmxWrapper wrapper = new CacheJmxWrapper();
wrapper.setConfiguration(config);
return wrapper;
}
protected Cache createCache(Configuration config)
{
CacheFactory factory = new DefaultCacheFactory();
cache = factory.createCache(config, false);
return cache;
}
protected Configuration createConfiguration()
{
Configuration c = new Configuration();
c.setClusterName(CLUSTER_NAME);
c.setExposeManagementStatistics(true);
c.setCacheMode(Configuration.CacheMode.LOCAL);
return c;
}
private void cleanup() throws Exception
{
if (cache != null)
{
try
{
cache.stop();
}
catch (Exception ignored)
{
}
cache = null;
}
if (jmxWrapper != null)
{
try
{
jmxWrapper.stop();
jmxWrapper.destroy();
}
catch (Exception ignored)
{
}
jmxWrapper = null;
}
if (mBeanServer != null && mBeanName != null && mBeanServer.isRegistered(mBeanName))
mBeanServer.unregisterMBean(mBeanName);
}
protected void interceptorRegistrationTest(boolean expectMbeans) throws MalformedObjectNameException, NullPointerException
{
interceptorRegistrationTest(mBeanNameStr, expectMbeans);
}
protected void interceptorRegistrationTest(String baseName, boolean expectMbeans) throws MalformedObjectNameException, NullPointerException
{
// should be 3 interceptor MBeans loaded:
ObjectName[] interceptorMBeanNames = {
new ObjectName(baseName + JmxUtil.INTERCEPTOR_KEY + "TxInterceptor"),
new ObjectName(baseName + JmxUtil.INTERCEPTOR_KEY + "CacheMgmtInterceptor"),
new ObjectName(baseName + JmxUtil.INTERCEPTOR_KEY + "InvocationContextInterceptor")
};
for (ObjectName n : interceptorMBeanNames)
{
if (expectMbeans)
assertTrue(n + " should be registered", mBeanServer.isRegistered(n));
else
assertFalse(n + " should not be registered", mBeanServer.isRegistered(n));
}
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/jmx/LegacyConfigurationTest.java 0000644 0001750 0001750 00000054620 10712333755 030706 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source.
* Copyright 2006, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.cache.jmx;
import org.jboss.cache.Version;
import org.jboss.cache.config.*;
import org.jboss.cache.config.BuddyReplicationConfig.BuddyLocatorConfig;
import org.jboss.cache.config.CacheLoaderConfig.IndividualCacheLoaderConfig;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.config.Configuration.NodeLockingScheme;
import org.jboss.cache.eviction.*;
import org.jboss.cache.loader.FileCacheLoader;
import org.jboss.cache.loader.SingletonStoreCacheLoader;
import org.jboss.cache.loader.jdbm.JdbmCacheLoader;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.multiplexer.MultiplexerTestHelper;
import org.jboss.cache.transaction.BatchModeTransactionManagerLookup;
import org.jboss.cache.xml.XmlHelper;
import org.jgroups.ChannelFactory;
import org.jgroups.JChannelFactory;
import org.jgroups.jmx.JChannelFactoryMBean;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.Test;
import org.w3c.dom.Element;
import javax.management.MBeanServerInvocationHandler;
import javax.management.ObjectName;
import javax.transaction.TransactionManager;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;
import java.util.Properties;
/**
* Test of the CacheLegacyJmxWrapper.
*
* @author Brian Stansberry
* @version $Revision: 4719 $
*/
public class LegacyConfigurationTest extends CacheJmxWrapperTestBase
{
@SuppressWarnings({"deprecation", "unchecked"})
public void testLocalCache() throws Exception
{
CacheJmxWrapperMBean wrapper = new CacheJmxWrapper();
registerWrapper(wrapper);
wrapper = (CacheJmxWrapperMBean) MBeanServerInvocationHandler.newProxyInstance(mBeanServer, mBeanName, CacheJmxWrapperMBean.class, false);
wrapper.setBuddyReplicationConfig(getBuddyReplicationConfig());
wrapper.setCacheLoaderConfig(getCacheLoaderConfig());
wrapper.setCacheMode("REPL_SYNC");
wrapper.setClusterName("LocalTest");
wrapper.setClusterConfig(getClusterConfig());
wrapper.setEvictionPolicyConfig(getEvictionPolicyConfig());
wrapper.setFetchInMemoryState(false);
wrapper.setInitialStateRetrievalTimeout(100);
wrapper.setInactiveOnStartup(true);
wrapper.setNodeLockingScheme("OPTIMISTIC");
wrapper.setIsolationLevel("READ_UNCOMMITTED");
wrapper.setLockAcquisitionTimeout(200);
wrapper.setReplicationVersion("1.0.1");
wrapper.setReplQueueInterval(15);
wrapper.setReplQueueMaxElements(50);
wrapper.setSyncReplTimeout(300);
wrapper.setSyncCommitPhase(true);
wrapper.setSyncRollbackPhase(true);
wrapper.setTransactionManagerLookupClass(BatchModeTransactionManagerLookup.class.getName());
wrapper.setExposeManagementStatistics(false);
wrapper.setUseRegionBasedMarshalling(true);
wrapper.setUseReplQueue(true);
Configuration c = wrapper.getConfiguration();
assertEquals("CacheMode", "REPL_SYNC", wrapper.getCacheMode());
assertEquals("CacheMode", CacheMode.REPL_SYNC, c.getCacheMode());
assertEquals("ClusterName", "LocalTest", wrapper.getClusterName());
assertEquals("ClusterName", "LocalTest", c.getClusterName());
assertEquals("FetchInMemoryState", false, wrapper.getFetchInMemoryState());
assertEquals("FetchInMemoryState", false, c.isFetchInMemoryState());
assertEquals("InitialStateRetrievalTimeout", 100, wrapper.getInitialStateRetrievalTimeout());
assertEquals("InitialStateRetrievalTimeout", 100, c.getStateRetrievalTimeout());
assertEquals("InactiveOnStartup", true, wrapper.isInactiveOnStartup());
assertEquals("InactiveOnStartup", true, c.isInactiveOnStartup());
assertEquals("NodeLockingScheme", "OPTIMISTIC", wrapper.getNodeLockingScheme());
assertEquals("NodeLockingScheme", NodeLockingScheme.OPTIMISTIC, c.getNodeLockingScheme());
assertEquals("IsolationLevel", "READ_UNCOMMITTED", wrapper.getIsolationLevel());
assertEquals("IsolationLevel", IsolationLevel.READ_UNCOMMITTED, c.getIsolationLevel());
assertEquals("LockAcquisitionTimeout", 200, wrapper.getLockAcquisitionTimeout());
assertEquals("LockAcquisitionTimeout", 200, c.getLockAcquisitionTimeout());
assertEquals("ReplicationVersion", "1.0.1", wrapper.getReplicationVersion());
assertEquals("ReplicationVersion", Version.getVersionShort("1.0.1"), c.getReplicationVersion());
assertEquals("ReplQueueInterval", 15, wrapper.getReplQueueInterval());
assertEquals("ReplQueueInterval", 15, c.getReplQueueInterval());
assertEquals("ReplQueueMaxElements", 50, wrapper.getReplQueueMaxElements());
assertEquals("ReplQueueMaxElements", 50, c.getReplQueueMaxElements());
assertEquals("SyncReplTimeout", 300, wrapper.getSyncReplTimeout());
assertEquals("SyncReplTimeout", 300, c.getSyncReplTimeout());
assertEquals("SyncCommitPhase", true, wrapper.getSyncCommitPhase());
assertEquals("SyncCommitPhase", true, c.isSyncCommitPhase());
assertEquals("SyncRollbackPhase", true, wrapper.getSyncRollbackPhase());
assertEquals("SyncRollbackPhase", true, c.isSyncRollbackPhase());
assertEquals("TransactionManagerLookupClass", BatchModeTransactionManagerLookup.class.getName(), wrapper.getTransactionManagerLookupClass());
assertEquals("TransactionManagerLookupClass", BatchModeTransactionManagerLookup.class.getName(), c.getTransactionManagerLookupClass());
assertEquals("ExposeManagementStatistics", false, wrapper.getExposeManagementStatistics());
assertEquals("ExposeManagementStatistics", false, c.getExposeManagementStatistics());
assertEquals("UseRegionBasedMarshalling", true, wrapper.getUseRegionBasedMarshalling());
assertEquals("UseRegionBasedMarshalling", true, c.isUseRegionBasedMarshalling());
assertEquals("UseReplQueue", true, wrapper.getUseReplQueue());
assertEquals("UseReplQueue", true, c.isUseReplQueue());
assertEquals("ClusterConfig", getClusterConfig().toString(), wrapper.getClusterConfig().toString());
assertEquals("BuddyReplicationConfig", getBuddyReplicationConfig().toString(), wrapper.getBuddyReplicationConfig().toString());
BuddyReplicationConfig brc = c.getBuddyReplicationConfig();
assertEquals("BR enabled", true, brc.isEnabled());
assertEquals("BR auto grav", false, brc.isAutoDataGravitation());
assertEquals("BR remove find", false, brc.isDataGravitationRemoveOnFind());
assertEquals("BR search backup", false, brc.isDataGravitationSearchBackupTrees());
assertEquals("BR comm timeout", 600000, brc.getBuddyCommunicationTimeout());
assertEquals("BR poolname", "testpool", brc.getBuddyPoolName());
BuddyLocatorConfig blc = brc.getBuddyLocatorConfig();
assertEquals("BR locator", "org.jboss.cache.buddyreplication.TestBuddyLocator", blc.getBuddyLocatorClass());
Properties props = blc.getBuddyLocatorProperties();
assertEquals("BR props", "2", props.get("numBuddies"));
assertEquals("CacheLoaderConfig", getCacheLoaderConfig().toString(), wrapper.getCacheLoaderConfig().toString());
CacheLoaderConfig clc = c.getCacheLoaderConfig();
assertEquals("CL passivation", false, clc.isPassivation());
assertEquals("CL passivation", true, clc.isShared());
assertEquals("CL preload", "/foo", clc.getPreload());
List iclcs = clc.getIndividualCacheLoaderConfigs();
IndividualCacheLoaderConfig iclc = iclcs.get(0);
assertEquals("CL0 class", FileCacheLoader.class.getName(), iclc.getClassName());
assertEquals("CL0 async", false, iclc.isAsync());
assertEquals("CL0 fetch", true, iclc.isFetchPersistentState());
assertEquals("CL0 ignore", true, iclc.isIgnoreModifications());
assertEquals("CL0 purge", true, iclc.isPurgeOnStartup());
assertEquals("CL0 singleton", true, iclc.getSingletonStoreConfig().isSingletonStoreEnabled());
assertEquals("CL0 singleton class", SingletonStoreCacheLoader.class.getName(), iclc.getSingletonStoreConfig().getSingletonStoreClass());
iclc = iclcs.get(1);
assertEquals("CL1 class", JdbmCacheLoader.class.getName(), iclc.getClassName());
assertEquals("CL1 async", true, iclc.isAsync());
assertEquals("CL1 fetch", false, iclc.isFetchPersistentState());
assertEquals("CL1 ignore", false, iclc.isIgnoreModifications());
assertEquals("CL1 purge", false, iclc.isPurgeOnStartup());
assertEquals("CL1 singleton", false, iclc.getSingletonStoreConfig().isSingletonStoreEnabled());
assertEquals("CL1 singleton class", SingletonStoreCacheLoader.class.getName(), iclc.getSingletonStoreConfig().getSingletonStoreClass());
assertEquals("EvictionPolicyConfig", getEvictionPolicyConfig().toString(), wrapper.getEvictionPolicyConfig().toString());
EvictionConfig ec = c.getEvictionConfig();
assertEquals("EC queue size", 20000, ec.getDefaultEventQueueSize());
assertEquals("EC wakeup", 5, ec.getWakeupIntervalSeconds());
assertEquals("EC default pol", LRUPolicy.class.getName(), ec.getDefaultEvictionPolicyClass());
List ercs = ec.getEvictionRegionConfigs();
EvictionRegionConfig erc = ercs.get(0);
assertEquals("ERC0 name", "/_default_", erc.getRegionName());
assertEquals("ERC0 queue size", 1000, erc.getEventQueueSize());
LRUConfiguration lru = (LRUConfiguration) erc.getEvictionPolicyConfig();
assertEquals("EPC0 pol", LRUPolicy.class.getName(), lru.getEvictionPolicyClass());
assertEquals("EPC0 maxnodes", 5000, lru.getMaxNodes());
assertEquals("EPC0 ttl", 1000, lru.getTimeToLiveSeconds());
erc = ercs.get(1);
assertEquals("ERC1 name", "/org/jboss/data", erc.getRegionName());
assertEquals("ERC1 queue size", 20000, erc.getEventQueueSize());
FIFOConfiguration fifo = (FIFOConfiguration) erc.getEvictionPolicyConfig();
assertEquals("EPC1 pol", FIFOPolicy.class.getName(), fifo.getEvictionPolicyClass());
assertEquals("EPC1 maxnodes", 5000, fifo.getMaxNodes());
erc = ercs.get(2);
assertEquals("ERC2 name", "/test", erc.getRegionName());
assertEquals("ERC2 queue size", 20000, erc.getEventQueueSize());
MRUConfiguration mru = (MRUConfiguration) erc.getEvictionPolicyConfig();
assertEquals("EPC2 pol", MRUPolicy.class.getName(), mru.getEvictionPolicyClass());
assertEquals("EPC2 maxnodes", 10000, mru.getMaxNodes());
erc = ercs.get(3);
assertEquals("ERC3 name", "/maxAgeTest", erc.getRegionName());
assertEquals("ERC3 queue size", 20000, erc.getEventQueueSize());
lru = (LRUConfiguration) erc.getEvictionPolicyConfig();
assertEquals("EPC3 pol", LRUPolicy.class.getName(), lru.getEvictionPolicyClass());
assertEquals("EPC3 maxnodes", 10000, lru.getMaxNodes());
assertEquals("EPC3 maxage", 10, lru.getMaxAgeSeconds());
assertEquals("EPC3 ttl", 8, lru.getTimeToLiveSeconds());
}
@SuppressWarnings("unchecked")
public void testRuntimeConfig() throws Exception
{
CacheJmxWrapperMBean wrapper = new CacheJmxWrapper();
registerWrapper(wrapper);
wrapper = (CacheJmxWrapperMBean) MBeanServerInvocationHandler.newProxyInstance(mBeanServer, mBeanName, CacheJmxWrapperMBean.class, false);
// Fake a TM by making a bogus proxy
TransactionManager tm = (TransactionManager) Proxy.newProxyInstance(getClass().getClassLoader(),
new Class[]{TransactionManager.class}, new MockInvocationHandler());
wrapper.setTransactionManager(tm);
ChannelFactory cf = new JChannelFactory();
wrapper.setMuxChannelFactory(cf);
RuntimeConfig rc = wrapper.getConfiguration().getRuntimeConfig();
assertSame("Same TM", tm, wrapper.getTransactionManager());
assertSame("Same TM", tm, rc.getTransactionManager());
assertSame("Same ChannelFactory", cf, wrapper.getMuxChannelFactory());
assertSame("Same ChannelFactory", cf, rc.getMuxChannelFactory());
}
@SuppressWarnings("unchecked")
public void testLegacyMuxChannelCreation() throws Exception
{
CacheJmxWrapperMBean wrapper = new CacheJmxWrapper();
registerWrapper(wrapper);
wrapper = (CacheJmxWrapperMBean) MBeanServerInvocationHandler.newProxyInstance(mBeanServer, mBeanName, CacheJmxWrapperMBean.class, false);
wrapper.setMultiplexerStack(MultiplexerTestHelper.MUX_STACK);
JChannelFactory factory = new JChannelFactory();
factory.setDomain("jbc.mux.test");
factory.setExposeChannels(false);
factory.setMultiplexerConfig(MultiplexerTestHelper.getClusterConfigElement(getDefaultProperties()));
ObjectName on = new ObjectName("jgroups:service=Mux");
mBeanServer.registerMBean(new org.jgroups.jmx.JChannelFactory(factory), on);
wrapper.setMultiplexerService((JChannelFactoryMBean) MBeanServerInvocationHandler.newProxyInstance(mBeanServer, on, JChannelFactoryMBean.class, false));
wrapper.start();
RuntimeConfig rc = wrapper.getConfiguration().getRuntimeConfig();
assertNotNull("Channel created", rc.getChannel());
}
protected static Element getBuddyReplicationConfig() throws Exception
{
String xmlString = "true\n" +
" 600000\n" +
" org.jboss.cache.buddyreplication.TestBuddyLocator\n" +
" numBuddies = 2\n" +
" testpool" +
" false\n" +
" false\n" +
" false" +
"";
return XmlHelper.stringToElement(xmlString);
}
protected static Element getCacheLoaderConfig() throws Exception
{
String xml = "\n" +
"false\n" +
"/foo\n" +
"true\n" +
"\n" +
"org.jboss.cache.loader.FileCacheLoader\n" +
"" +
" location=/tmp\n" +
"\n" +
"false\n" +
"true\n" +
"true\n" +
"true\n" +
"" +
"true" +
"" +
"\n" +
"\n" +
"org.jboss.cache.loader.jdbm.JdbmCacheLoader\n" +
"" +
" location=/home/bstansberry\n" +
"\n" +
"true\n" +
"false\n" +
"false\n" +
"false\n" +
"" +
"false" +
"" +
"\n" +
"";
return XmlHelper.stringToElement(xml);
}
protected static Element getEvictionPolicyConfig() throws Exception
{
String xml = "\n" +
"5\n" +
"20000\n" +
"org.jboss.cache.eviction.LRUPolicy\n" +
"\n" +
" 5000\n" +
" 1000\n" +
"\n" +
"\n" +
" 5000\n" +
"\n" +
"\n" +
" 10000\n" +
"\n" +
"\n" +
" 10000\n" +
" 8\n" +
" 10\n" +
"\n" +
" \n";
return XmlHelper.stringToElement(xml);
}
protected static Element getClusterConfig() throws Exception
{
String xml =
"\n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
" \n" +
"";
return XmlHelper.stringToElement(xml);
}
protected String getDefaultProperties()
{
return "UDP(mcast_addr=224.0.0.36;mcast_port=55566;ip_ttl=32;" +
"mcast_send_buf_size=150000;mcast_recv_buf_size=80000):" +
"PING(timeout=1000;num_initial_members=2):" +
"MERGE2(min_interval=5000;max_interval=10000):" +
"FD_SOCK:" +
"VERIFY_SUSPECT(timeout=1500):" +
"pbcast.NAKACK(gc_lag=50;max_xmit_size=8192;retransmit_timeout=600,1200,2400,4800):" +
"UNICAST(timeout=600,1200,2400,4800):" +
"pbcast.STABLE(desired_avg_gossip=20000):" +
"FRAG(frag_size=8192;down_thread=false;up_thread=false):" +
"pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;" +
"shun=false;print_local_addr=true):" +
"pbcast.STATE_TRANSFER";
}
class MockInvocationHandler implements InvocationHandler
{
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
return null;
}
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/jmx/LifecycleNotificationTest.java 0000644 0001750 0001750 00000010161 10665031725 031207 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source.
* Copyright 2006, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.cache.jmx;
import static org.testng.AssertJUnit.assertEquals;
import java.util.LinkedList;
import java.util.List;
import javax.management.AttributeChangeNotification;
import javax.management.Notification;
import javax.management.NotificationListener;
/**
* A LifecycleNotificationTest.
*
* @author Brian Stansberry
* @version $Revision: 4444 $
*/
public class LifecycleNotificationTest extends CacheJmxWrapperTestBase
{
@SuppressWarnings("unchecked")
public void testGetStateAndStateNotification() throws Exception
{
CacheJmxWrapper wrapper = createWrapper(createConfiguration());
StateNotificationListener listener = new StateNotificationListener();
wrapper.addNotificationListener(listener, null, null);
assertEquals("Correct state after instanitation",
CacheJmxWrapperMBean.UNREGISTERED, wrapper.getState());
registerWrapper(wrapper);
assertEquals("Correct state after registration",
CacheJmxWrapperMBean.REGISTERED, wrapper.getState());
wrapper.create();
assertEquals("Correct state after create",
CacheJmxWrapperMBean.CREATED, wrapper.getState());
wrapper.start();
assertEquals("Correct state after start",
CacheJmxWrapperMBean.STARTED, wrapper.getState());
wrapper.stop();
assertEquals("Correct state after stop",
CacheJmxWrapperMBean.STOPPED, wrapper.getState());
wrapper.destroy();
assertEquals("Correct state after destroy",
CacheJmxWrapperMBean.DESTROYED, wrapper.getState());
unregisterWrapper();
assertEquals("Correct state after unregistration",
CacheJmxWrapperMBean.UNREGISTERED, wrapper.getState());
System.out.println(listener.notifications);
assertEquals("Correct number of notifications received", 4, listener.notifications.size());
assertEquals("Correct first notification", new Integer(CacheJmxWrapperMBean.STARTING), listener.notifications.get(0));
assertEquals("Correct second notification", new Integer(CacheJmxWrapperMBean.STARTED), listener.notifications.get(1));
assertEquals("Correct third notification", new Integer(CacheJmxWrapperMBean.STOPPING), listener.notifications.get(2));
assertEquals("Correct fourth notification", new Integer(CacheJmxWrapperMBean.STOPPED), listener.notifications.get(3));
}
private static class StateNotificationListener
implements NotificationListener
{
private List notifications = new LinkedList();
public void handleNotification(Notification msg, Object handback)
{
if (msg instanceof AttributeChangeNotification)
{
AttributeChangeNotification change = (AttributeChangeNotification) msg;
String attrName = change.getAttributeName();
Object newValue = change.getNewValue();
if ("State".equals(attrName) && newValue != null && newValue instanceof Integer)
{
notifications.add((Integer) newValue);
return;
}
}
}
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/jmx/CacheJmxWrapperTest.java 0000644 0001750 0001750 00000034316 11017455042 027766 0 ustar twerner twerner package org.jboss.cache.jmx;
import org.jboss.cache.Cache;
import org.jboss.cache.CacheException;
import org.jboss.cache.CacheStatus;
import org.jboss.cache.Fqn;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.notifications.annotation.CacheListener;
import org.jboss.cache.notifications.annotation.CacheStarted;
import org.jboss.cache.notifications.annotation.CacheStopped;
import org.jboss.cache.notifications.event.Event;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jgroups.Address;
import org.jgroups.stack.IpAddress;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.Test;
import javax.management.ObjectName;
import javax.transaction.TransactionManager;
import java.util.List;
/**
* Tests the JMX wrapper class around the cache.
*
* @author Manik Surtani
* @author Brian Stansberry
*/
@Test(groups = "functional")
public class CacheJmxWrapperTest extends CacheJmxWrapperTestBase
{
public void testCacheMBeanBinding() throws Exception
{
registerWrapper();
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
}
public void testSetCacheObjectName() throws Exception
{
ObjectName on = new ObjectName("jboss.cache:test=SetCacheObjectName");
boolean registered = false;
try
{
CacheJmxWrapper wrapper = createWrapper(createConfiguration());
wrapper.setCacheObjectName(on.getCanonicalName());
// Register under the standard name
registerWrapper(wrapper);
// Should be registered under 'on'
registered = mBeanServer.isRegistered(on);
assertTrue("Registered with configured name", registered);
assertEquals("Configured name retained", on.getCanonicalName(), wrapper.getCacheObjectName());
wrapper.create();
wrapper.start();
interceptorRegistrationTest(on.getCanonicalName(), true);
wrapper.stop();
wrapper.destroy();
interceptorRegistrationTest(false);
}
finally
{
if (registered)
mBeanServer.unregisterMBean(on);
}
}
public void testGetCacheObjectName() throws Exception
{
ObjectName on = new ObjectName("jboss.cache:test=SetCacheObjectName");
String str = on.getCanonicalName();
CacheJmxWrapper wrapper = createWrapper(createConfiguration());
wrapper.setCacheObjectName(str);
assertEquals("Setter and getter match", str, wrapper.getCacheObjectName());
// Go back to the default
wrapper.setCacheObjectName(null);
assertEquals("Got default ObjectName", JmxUtil.PREFIX + CLUSTER_NAME, wrapper.getCacheObjectName());
registerWrapper(wrapper);
assertEquals("Returns standard name", mBeanName, new ObjectName(wrapper.getCacheObjectName()));
}
public void testGetConfiguration1() throws Exception
{
CacheJmxWrapperMBean wrapper = registerWrapper();
Configuration cfgFromJmx = wrapper.getConfiguration();
assertNotNull("Got a configuration", cfgFromJmx);
assertSame(cache.getConfiguration(), cfgFromJmx);
}
public void testGetConfiguration2() throws Exception
{
Configuration cfg = createConfiguration();
CacheJmxWrapperMBean wrapper = registerWrapper(cfg);
Configuration cfgFromJmx = wrapper.getConfiguration();
assertNotNull("Got a configuration", cfgFromJmx);
assertSame(cfg, cfgFromJmx);
}
/**
* Note that this is a bit of a 'white box' test as it assumes that the
* returned String equals Configuration.toString(). That could change and
* break this test; if it does, and there's nothing wrong with the
* change, just modify the test.
*
* @throws Exception
*/
public void testPrintConfigurationAsString1() throws Exception
{
CacheJmxWrapperMBean wrapper = registerWrapper();
String cfgFromJmx = wrapper.printConfigurationAsString();
assertEquals(cache.getConfiguration().toString(), cfgFromJmx);
}
/**
* Note that this is a bit of a 'white box' test as it assumes that the
* returned String equals Configuration.toString(). That could change and
* break this test; if it does, and there's nothing wrong with the
* change, just modify the test.
*
* @throws Exception
*/
public void testPrintConfigurationAsString2() throws Exception
{
Configuration cfg = createConfiguration();
CacheJmxWrapperMBean wrapper = registerWrapper(cfg);
wrapper.create();
wrapper.start();
String cfgFromJmx = wrapper.printConfigurationAsString();
assertEquals(wrapper.getCache().getConfiguration().toString(), cfgFromJmx);
}
/**
* Note that this is a bit of a 'white box' test as it checks
* the currently coded HTML format and assumes that the HTML content is
* derived from Configuration.toString(). That could change and break
* this test; if it does, and there's nothing wrong with the
* change, just modify the test.
*
* @throws Exception
*/
public void testPrintConfigurationAsHtml1() throws Exception
{
CacheJmxWrapperMBean wrapper = registerWrapper();
String cfgFromJmx = wrapper.printConfigurationAsHtmlString();
assertEquals(CacheJmxWrapper.formatHtml(cache.getConfiguration().toString()), cfgFromJmx);
checkHtml(cfgFromJmx, false);
}
/**
* Note that this is a bit of a 'white box' test as it checks
* the currently coded HTML format and assumes that the HTML content is
* derived from Configuration.toString(). That could change and break
* this test; if it does, and there's nothing wrong with the
* change, just modify the test.
*
* @throws Exception
*/
public void testPrintConfigurationAsHtml2() throws Exception
{
Configuration cfg = createConfiguration();
CacheJmxWrapperMBean wrapper = registerWrapper(cfg);
wrapper.create();
wrapper.start();
String cfgFromJmx = wrapper.printConfigurationAsHtmlString();
assertEquals(CacheJmxWrapper.formatHtml(wrapper.getCache().getConfiguration().toString()), cfgFromJmx);
checkHtml(cfgFromJmx, false);
}
@SuppressWarnings("unchecked")
public void testGetCache() throws Exception
{
registerWrapper();
// have to start the cache before we'll have a root
cache.start();
Cache cacheJmx = (Cache) mBeanServer.getAttribute(mBeanName, "Cache");
cacheJmx.getRoot().put("key", "value");
assertEquals("value", cache.getRoot().get("key"));
Fqn fqn = Fqn.fromString("/testing/jmx");
cache.put(fqn, "key", "value");
assertEquals("value", cacheJmx.get(fqn, "key"));
}
public void testPrintCacheDetails() throws Exception
{
printCacheDetailsTest(false);
}
/**
* Note that this is a bit of a 'white box' test as it checks
* the currently coded HTML format. That could change and break
* this test; if it does, and there's nothing wrong with the
* change, just modify the test.
*
* @throws Exception
*/
public void testPrintCacheDetailsAsHtml() throws Exception
{
String html = printCacheDetailsTest(true);
checkHtml(html, true);
}
public void testPrintLockInfo() throws Exception
{
printLockInfoTest(false);
}
/**
* Note that this is a bit of a 'white box' test as it checks
* the currently coded HTML format. That could change and break
* this test; if it does, and there's nothing wrong with the
* change, just modify the test.
*
* @throws Exception
*/
public void testPrintLockInfoAsHtml() throws Exception
{
printLockInfoTest(true);
}
public void testGetLocalAddress() throws Exception
{
Configuration c = createConfiguration();
c.setCacheMode(CacheMode.REPL_ASYNC);
CacheJmxWrapperMBean wrapper = registerWrapper(c);
wrapper.start();
assertTrue("Got an IpAddress", wrapper.getLocalAddress() instanceof IpAddress);
}
public void testGetMembers() throws Exception
{
Configuration c = createConfiguration();
c.setCacheMode(CacheMode.REPL_ASYNC);
CacheJmxWrapperMBean wrapper = registerWrapper(c);
wrapper.start();
c = createConfiguration();
c.setCacheMode(CacheMode.REPL_ASYNC);
Cache cache2 = null;
try
{
cache2 = createCache(c);
cache2.start();
Cache[] caches = new Cache[]{wrapper.getCache(), cache2};
TestingUtil.blockUntilViewsReceived(caches, 5000);
Address addr = wrapper.getLocalAddress();
assertNotNull("Got an Address", addr);
List members = wrapper.getMembers();
assertNotNull("Got members", addr);
assertEquals("Got correct number of members", 2, members.size());
assertTrue("I am a member", members.contains(addr));
}
finally
{
if (cache2 != null)
{
cache2.destroy();
}
}
}
public void testDuplicateInvocation() throws Exception
{
CacheJmxWrapperMBean cache = registerWrapper();
cache.create();
cache.start();
cache.create();
cache.start();
cache.getCache().put(Fqn.fromString("/a/b/c"), null);
assertTrue(cache.getNumberOfNodes() > 0);
assertEquals(0, cache.getNumberOfAttributes());
System.out.println("cache locks before restart:\n" + cache.printLockInfo());
cache.destroy();
cache.start();
System.out.println("cache locks after restart:\n" + cache.printLockInfo());
assertEquals(0, cache.getNumberOfNodes());
assertEquals(0, cache.getNumberOfAttributes());
cache.stop();
cache.destroy();
cache.stop();
cache.destroy();
}
public void testFailedStart() throws Exception
{
CacheJmxWrapper wrapper = new CacheJmxWrapper(createCache(createConfiguration()));
registerWrapper(wrapper);
assertEquals("Correct state", CacheStatus.INSTANTIATED, wrapper.getCacheStatus());
wrapper.create();
DisruptLifecycleListener listener = new DisruptLifecycleListener();
listener.setDisrupt(true);
wrapper.getCache().addCacheListener(listener);
assertEquals("Correct state", CacheStatus.CREATED, wrapper.getCacheStatus());
try
{
wrapper.start();
fail("Listener did not prevent start");
}
catch (CacheException good)
{
}
assertEquals("Correct state", CacheStatus.FAILED, wrapper.getCacheStatus());
listener.setDisrupt(false);
wrapper.start();
assertEquals("Correct state", CacheStatus.STARTED, wrapper.getCacheStatus());
wrapper.getCache().put(Fqn.fromString("/a/b/c"), null);
assertTrue(wrapper.getNumberOfNodes() > 0);
assertEquals(0, wrapper.getNumberOfAttributes());
listener.setDisrupt(true);
// need to re-add the listener since the failed start would have nullified the notifier.
cache.addCacheListener(listener);
try
{
wrapper.stop();
fail("Listener did not prevent stop");
}
catch (CacheException good)
{
}
assertEquals("Correct state", CacheStatus.FAILED, wrapper.getCacheStatus());
listener.setDisrupt(false);
wrapper.stop();
assertEquals("Correct state", CacheStatus.STOPPED, wrapper.getCacheStatus());
wrapper.destroy();
assertEquals("Correct state", CacheStatus.DESTROYED, wrapper.getCacheStatus());
}
private String printCacheDetailsTest(boolean html) throws Exception
{
CacheJmxWrapperMBean wrapper = registerWrapper();
// have to start the cache before we'll have a root
cache.start();
Fqn fqn = Fqn.fromString("/testing/jmx");
cache.put(fqn, "foobar", "barfoo");
assertEquals("barfoo", cache.get(fqn, "foobar"));
String details = html ? wrapper.printCacheDetailsAsHtml() : wrapper.printCacheDetails();
assertTrue("Details include testing", details.contains("testing"));
assertTrue("Details include jmx", details.contains("jmx"));
assertTrue("Details include foobar", details.contains("foobar"));
assertTrue("Details include barfoo", details.contains("barfoo"));
return details;
}
private String printLockInfoTest(boolean html) throws Exception
{
Configuration config = createConfiguration();
config.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
Cache c = createCache(config);
CacheJmxWrapperMBean wrapper = registerWrapper(c);
// wrapper.setManageCacheLifecycle(true);
wrapper.create();
wrapper.start();
TransactionManager tm = config.getRuntimeConfig().getTransactionManager();
tm.begin();
try
{
Fqn fqn = Fqn.fromString("/testing/jmx");
cache.put(fqn, "foobar", "barfoo");
String locks = html ? wrapper.printLockInfoAsHtml() : wrapper.printLockInfo();
assertTrue("Details include testing", locks.contains("testing"));
assertTrue("Details include jmx", locks.contains("jmx"));
return locks;
}
catch (Exception e)
{
tm.setRollbackOnly();
throw e;
}
finally
{
tm.commit();
}
}
private void checkHtml(String html, boolean checkBR)
{
if (checkBR)
assertTrue("Has Brian Stansberry
* @version $Revision: 4941 $
*/
@Test(groups = "functional")
public class InterceptorRegistrationTest extends CacheJmxWrapperTestBase
{
/**
* Confirms interceptor mbeans are registered if the following events
* occur:
*
* cache.start();
* wrapper creation and registration.
*
* @throws Exception
*/
public void testInterceptorMBeans1() throws Exception
{
// have to start the cache to have any interceptors
createCache(createConfiguration());
cache.start();
CacheJmxWrapperMBean wrapper = registerWrapper(cache);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
interceptorRegistrationTest(true);
// These should be ignored because we
// never did wrapper.create()/start()
wrapper.stop();
wrapper.destroy();
// Should still be registered
interceptorRegistrationTest(true);
unregisterWrapper();
interceptorRegistrationTest(false);
}
/**
* Confirms interceptor mbeans are registered if the following events
* occur:
*
* cache.start();
* wrapper creation and and start
* wrapper registration.
*
* @throws Exception
*/
public void testInterceptorMBeans2() throws Exception
{
// have to start the cache to have any interceptors
createCache(createConfiguration());
cache.start();
CacheJmxWrapperMBean wrapper = new CacheJmxWrapper(cache);
wrapper.start();
wrapper = registerWrapper(wrapper);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
interceptorRegistrationTest(true);
wrapper.stop();
wrapper.destroy();
// Should still no longer be registered
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
/**
* Confirms interceptor mbeans are registered if the following events
* occur:
*
* Cache not injected
* wrapper registered;
* wrapper created and started.
*
* @throws Exception
*/
public void testInterceptorMBeans3() throws Exception
{
CacheJmxWrapperMBean wrapper = registerWrapper(createConfiguration());
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
// have to start the cache to have any interceptors
wrapper.create();
wrapper.start();
interceptorRegistrationTest(true);
wrapper.stop();
wrapper.destroy();
// Destroy should unregister if we are managing
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
/**
* Confirms interceptor mbeans are registered if the following events
* occur:
*
* Cache not injected
* wrapper created and started.
* wrapper registered
*
* @throws Exception
*/
public void testInterceptorMBeans4() throws Exception
{
CacheJmxWrapper wrapper = createWrapper(createConfiguration());
// have to start the cache to have any interceptors
wrapper.create();
wrapper.start();
registerWrapper(wrapper);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
interceptorRegistrationTest(true);
wrapper.stop();
wrapper.destroy();
// Destroy should unregister if we are managing
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
/**
* Confirms interceptor mbeans are registered if the following events
* occur:
*
* cache constructed;
* wrapper constructed and registered with manageCacheLifecycle=true
* wrapper created and started
*
* @throws Exception
*/
public void testInterceptorMBeans5() throws Exception
{
CacheJmxWrapperMBean wrapper = registerWrapper();
// wrapper.setManageCacheLifecycle(true);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
// have to start the cache to have any interceptors
wrapper.create();
wrapper.start();
interceptorRegistrationTest(true);
wrapper.stop();
wrapper.destroy();
// Destroy should unregister if we are managing
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
/**
* Confirms interceptor mbeans are registered if the following events
* occur:
*
* cache constructed;
* wrapper constructed and registered
* wrapper created and started
*
* @throws Exception
*/
public void testInterceptorMBeans6() throws Exception
{
CacheJmxWrapperMBean wrapper = registerWrapper();
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
// have to start the cache to have any interceptors
wrapper.create();
wrapper.start();
interceptorRegistrationTest(true);
wrapper.stop();
wrapper.destroy();
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
/**
* Confirms interceptor mbeans are registered if the following events
* occur:
*
* cache constructed;
* wrapper created and started
* wrapper registered
*
* @throws Exception
*/
public void testInterceptorMBeans7() throws Exception
{
CacheJmxWrapperMBean wrapper = new CacheJmxWrapper(createCache(createConfiguration()));
// have to start the cache to have any interceptors
wrapper.create();
wrapper.start();
wrapper = registerWrapper(wrapper);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
interceptorRegistrationTest(true);
wrapper.stop();
wrapper.destroy();
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
/**
* Tests that setting registerInterceptors=false disables interceptor
* registration when the wrapper is registered before create/start
* are called.
*
* @throws Exception
*/
public void testRegisterInterceptors1() throws Exception
{
CacheJmxWrapper wrapper = createWrapper(createConfiguration());
wrapper.setRegisterInterceptors(false);
registerWrapper(wrapper);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
wrapper.create();
wrapper.start();
interceptorRegistrationTest(false);
wrapper.stop();
wrapper.destroy();
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
/**
* Tests that setting registerInterceptors=false disables interceptor
* registration when the wrapper is registered after create/start
* are called.
*
* @throws Exception
*/
public void testRegisterInterceptors2() throws Exception
{
CacheJmxWrapper wrapper = createWrapper(createConfiguration());
wrapper.setRegisterInterceptors(false);
wrapper.create();
wrapper.start();
registerWrapper(wrapper);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
interceptorRegistrationTest(false);
wrapper.stop();
wrapper.destroy();
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
public void testExposeManagementStatistics1() throws Exception
{
Configuration cfg = createConfiguration();
cfg.setExposeManagementStatistics(false);
CacheJmxWrapper wrapper = createWrapper(cfg);
registerWrapper(cfg);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
wrapper.create();
wrapper.start();
interceptorRegistrationTest(false);
wrapper.stop();
wrapper.destroy();
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
public void testExposeManagementStatistics2() throws Exception
{
Configuration cfg = createConfiguration();
cfg.setExposeManagementStatistics(false);
CacheJmxWrapper wrapper = createWrapper(cfg);
wrapper.create();
wrapper.start();
registerWrapper(wrapper);
assertTrue("Should be registered", mBeanServer.isRegistered(mBeanName));
interceptorRegistrationTest(false);
wrapper.stop();
wrapper.destroy();
interceptorRegistrationTest(false);
unregisterWrapper();
interceptorRegistrationTest(false);
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/jmx/OptimisticNotificationTest.java 0000644 0001750 0001750 00000000604 10620514330 031422 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.jmx;
/**
* @author Manik Surtani (manik@jboss.org)
*/
public class OptimisticNotificationTest extends NotificationTest
{
public OptimisticNotificationTest()
{
optimistic = true;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/jmx/NotificationTest.java 0000644 0001750 0001750 00000040355 10732752176 027404 0 ustar twerner twerner package org.jboss.cache.jmx;
import org.jboss.cache.CacheFactory;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import org.jboss.cache.factories.XmlConfigurationParser;
import org.jboss.cache.loader.CacheLoader;
import org.jboss.cache.xml.XmlHelper;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import org.w3c.dom.Element;
import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.Notification;
import javax.management.NotificationListener;
import javax.management.ObjectName;
import java.util.EnumSet;
import java.util.HashMap;
/**
* Functional tests for CacheJmxWrapper broadcast of cache event notifications
*
* @author Jerry Gauthier
* @version $Id: NotificationTest.java 4912 2007-12-21 14:58:06Z manik.surtani@jboss.com $
*/
@Test(groups = {"functional"})
public class NotificationTest
{
protected static final String CLUSTER_NAME = "NotificationTestCluster";
protected static final String CAPITAL = "capital";
protected static final String CURRENCY = "currency";
protected static final String POPULATION = "population";
protected static final String EUROPE_NODE = "Europe";
public enum Type
{
STARTED, STOPPED, PRECREATE, POSTCREATE, PREEVICT, POSTEVICT,
PRELOAD, POSTLOAD, PREREMOVE, POSTREMOVE, PREVISIT, POSTVISIT,
PREMODIFY, POSTMODIFY, PREACTIVATE, POSTACTIVATE, PREPASSIVATE,
POSTPASSIVATE, VIEWCHANGE
}
protected MBeanServer m_server;
protected EnumSet events = EnumSet.noneOf(Type.class);
protected CacheSPI cache = null;
protected boolean optimistic = false;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
m_server = MBeanServerFactory.createMBeanServer();
Object cacheMBean = createCacheAndJmxWrapper();
// bind manually for now.
ObjectName mgmt = getWrapperObjectName();
m_server.registerMBean(cacheMBean, mgmt);
}
protected Object createCacheAndJmxWrapper() throws Exception
{
cache = createCache(CLUSTER_NAME);
return new CacheJmxWrapper(cache);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
try
{
cleanup();
}
finally
{
// make sure we stop the mbean server
if (m_server != null)
MBeanServerFactory.releaseMBeanServer(m_server);
}
}
protected void cleanup() throws Exception
{
events.clear();
destroyCache();
if (m_server != null)
{
ObjectName mgmt = getWrapperObjectName();
if (m_server.isRegistered(mgmt))
m_server.unregisterMBean(mgmt);
}
}
protected void destroyCache()
{
if (cache != null)
{
// stop the cache before the listener is unregistered
//cache1.stop();
cache.destroy();
cache = null;
}
}
protected ObjectName getWrapperObjectName() throws Exception
{
return new ObjectName(JmxUtil.PREFIX + CLUSTER_NAME);
}
public void testNotifications() throws Exception
{
assertNotNull("MBeanServer is null.", m_server);
assertNotNull("Cache is null.", cache);
ObjectName mgmt = getWrapperObjectName();
MyListener listener = new MyListener(mgmt);
m_server.addNotificationListener(mgmt, listener, null, null);
// start the cache after registering listener - this will trigger CacheStarted
// since cache is defined with cluster, thiswill also trigger ViewChange
cache.start();
// add a node - this will trigger NodeCreated, NodeModify(pre/post) and NodeModified
HashMap albania = new HashMap(4);
albania.put(CAPITAL, "Tirana");
albania.put(CURRENCY, "Lek");
cache.put("Europe/Albania", albania);
// modify a node - this will trigger NodeModified and NodeModify(pre/post)
cache.put("Europe/Albania", POPULATION, 3563112);
// retrieve an attribute - this will trigger NodeVisited
Fqn key = Fqn.fromString("Europe/Albania");
assertNotNull("Retrieval error: expected to retrieve " + CURRENCY + " for " + key, cache.get(key, CURRENCY));
// evict the node - this will trigger NodePassivate, NodeEvicted and NodeEvict(pre/post)
cache.evict(key);
// retrieve the attribute again - this will trigger NodeVisited and NodeActivate
assertNotNull("Retrieval error: expected to retrieve " + CURRENCY + " for " + key, cache.get(key, CURRENCY));
// remove the node - this will trigger NodeRemoved and NodeRemove(pre/post)
cache.removeNode(key);
// clean up before stopping the cache
CacheLoader cl = cache.getCacheLoaderManager().getCacheLoader();
cl.remove(Fqn.fromString(EUROPE_NODE));
// stop the cache
cache.stop();
m_server.removeNotificationListener(mgmt, listener);
// run the tests
assertTrue("Expected CacheStarted notification", events.contains(Type.STARTED));
assertTrue("Expected CacheStopped notification", events.contains(Type.STOPPED));
assertTrue("Expected NodeCreated notification", events.contains(Type.PRECREATE));
assertTrue("Expected NodeCreated notification", events.contains(Type.POSTCREATE));
assertTrue("Expected NodeEvicted notification", events.contains(Type.PREEVICT));
assertTrue("Expected NodeEvicted notification", events.contains(Type.POSTEVICT));
assertTrue("Expected NodeLoaded notification", events.contains(Type.PRELOAD));
assertTrue("Expected NodeLoaded notification", events.contains(Type.POSTLOAD));
assertTrue("Expected NodeVisited notification", events.contains(Type.PREVISIT));
assertTrue("Expected NodeVisited notification", events.contains(Type.POSTVISIT));
assertTrue("Expected NodeActivated notification", events.contains(Type.PREACTIVATE));
assertTrue("Expected NodeActivated notification", events.contains(Type.POSTACTIVATE));
assertTrue("Expected NodeModified notification", events.contains(Type.PREMODIFY));
assertTrue("Expected NodeModified notification", events.contains(Type.POSTMODIFY));
assertTrue("Expected NodePassivated notification", events.contains(Type.PREPASSIVATE));
assertTrue("Expected NodePassivated notification", events.contains(Type.POSTPASSIVATE));
assertTrue("Expected NodeRemoved notification", events.contains(Type.PREREMOVE));
assertTrue("Expected NodeRemoved notification", events.contains(Type.POSTREMOVE));
assertTrue("Expected ViewChange notification", events.contains(Type.VIEWCHANGE));
validateHealthyListener(listener);
}
public void testEarlyRegistration() throws Exception
{
// undo setup
cleanup();
CacheJmxWrapper wrapper = new CacheJmxWrapper();
ObjectName mgmt = getWrapperObjectName();
m_server.registerMBean(wrapper, mgmt);
MyListener listener = new MyListener(mgmt);
m_server.addNotificationListener(mgmt, listener, null, null);
cache = createCache(CLUSTER_NAME);
wrapper.setCache(cache);
cache.start();
try
{
assertTrue("Expected CacheStarted notification", events.contains(Type.STARTED));
validateHealthyListener(listener);
}
finally
{
cache.stop();
}
}
public void testLateRegistration() throws Exception
{
assertNotNull("MBeanServer is null.", m_server);
assertNotNull("Cache is null.", cache);
// start the cache before registering listener
cache.start();
try
{
ObjectName mgmt = getWrapperObjectName();
MyListener listener = new MyListener(mgmt);
m_server.addNotificationListener(mgmt, listener, null, null);
// add a node - this will trigger NodeCreated, NodeModify(pre/post) and NodeModified
HashMap albania = new HashMap(4);
albania.put(CAPITAL, "Tirana");
albania.put(CURRENCY, "Lek");
cache.put("Europe/Albania", albania);
// run the tests
assertTrue("Expected NodeModified notification", events.contains(Type.PREMODIFY));
assertTrue("Expected NodeModified notification", events.contains(Type.POSTMODIFY));
validateHealthyListener(listener);
}
finally
{
cache.stop();
}
}
public void testListenerRemoval() throws Exception
{
assertNotNull("MBeanServer is null.", m_server);
assertNotNull("Cache is null.", cache);
ObjectName mgmt = getWrapperObjectName();
MyListener listener = new MyListener(mgmt);
m_server.addNotificationListener(mgmt, listener, null, null);
// start the cache after registering listener - this will trigger CacheStarted
// since cache is defined with cluster, thiswill also trigger ViewChange
cache.start();
boolean ok = false;
try
{
assertTrue("Expected CacheStarted notification", events.contains(Type.STARTED));
m_server.removeNotificationListener(mgmt, listener);
ok = true;
}
finally
{
cache.stop();
if (ok)
{
assertFalse("Expected no CacheStopped notification", events.contains(Type.STOPPED));
validateHealthyListener(listener);
}
}
}
private CacheSPI createCache(String clusterName) throws Exception
{
Configuration config = createConfiguration(clusterName);
CacheFactory factory = new DefaultCacheFactory();
CacheSPI cache = (CacheSPI) factory.createCache(config, false);
cache.create();
// start the cache after the listener has been registered
//cache.start();
return cache;
}
protected Configuration createConfiguration(String clusterName) throws Exception
{
Configuration config = UnitTestCacheConfigurationFactory.createConfiguration(CacheMode.REPL_SYNC);
config.setCacheMode(Configuration.CacheMode.REPL_SYNC);
config.setCacheLoaderConfig(getCacheLoaderConfig("location=" + getTempDir()));
config.setExposeManagementStatistics(true);
config.setClusterName(clusterName);
if (optimistic)
{
config.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
config.setNodeLockingScheme("OPTIMISTIC");
}
return config;
}
private static String getTempDir()
{
return System.getProperty("java.io.tempdir", "/tmp");
}
private static boolean getPre(Object data)
{
assertNotNull("User data is null, should be Object[]", data);
assertTrue("User data is " + data.getClass().getName() + ", should be Object[]", data instanceof Object[]);
Object[] parms = (Object[]) data;
assertTrue("Parameter is " + parms[1].getClass().getName() + ", should be Boolean", parms[1] instanceof Boolean);
return (Boolean) parms[1];
}
protected static CacheLoaderConfig getCacheLoaderConfig(String properties) throws Exception
{
String xml = "\n" +
"true\n" +
"\n" +
"true\n" +
"\n" +
"org.jboss.cache.loader.FileCacheLoader\n" +
"" + properties + "\n" +
"false\n" +
"false\n" +
"false\n" +
"\n" +
"";
Element element = XmlHelper.stringToElement(xml);
return XmlConfigurationParser.parseCacheLoaderConfig(element);
}
private static void validateHealthyListener(MyListener listener)
{
if (listener.failure != null)
throw listener.failure;
if (listener.exception != null)
throw listener.exception;
}
private class MyListener implements NotificationListener
{
private RuntimeException exception;
private AssertionError failure;
private final String emitterObjectName;
MyListener(ObjectName emitter)
{
this.emitterObjectName = emitter.getCanonicalName();
}
public void handleNotification(Notification notification, Object handback)
{
try
{
String type = notification.getType();
Object userData = notification.getUserData();
if (type.equals(CacheNotificationBroadcaster.NOTIF_CACHE_STARTED))
{
events.add(Type.STARTED);
assertEquals("Correct object name in start notification", emitterObjectName, userData);
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_CACHE_STOPPED))
{
events.add(Type.STOPPED);
assertEquals("Correct object name in stop notification", emitterObjectName, userData);
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_NODE_CREATED))
{
if (getPre(userData))
{
events.add(Type.PRECREATE);
}
else
{
events.add(Type.POSTCREATE);
}
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_NODE_EVICTED))
{
if (getPre(userData))
{
events.add(Type.PREEVICT);
}
else
{
events.add(Type.POSTEVICT);
}
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_NODE_LOADED))
{
if (getPre(userData))
{
events.add(Type.PRELOAD);
}
else
{
events.add(Type.POSTLOAD);
}
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_NODE_REMOVED))
{
if (getPre(userData))
{
events.add(Type.PREREMOVE);
}
else
{
events.add(Type.POSTREMOVE);
}
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_NODE_VISITED))
{
if (getPre(userData))
{
events.add(Type.PREVISIT);
}
else
{
events.add(Type.POSTVISIT);
}
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_VIEW_CHANGED))
{
events.add(Type.VIEWCHANGE);
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_NODE_ACTIVATED))
{
if (getPre(userData))
{
events.add(Type.PREACTIVATE);
}
else
{
events.add(Type.POSTACTIVATE);
}
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_NODE_MODIFIED))
{
if (getPre(userData))
{
events.add(Type.PREMODIFY);
}
else
{
events.add(Type.POSTMODIFY);
}
}
else if (type.equals(CacheNotificationBroadcaster.NOTIF_NODE_PASSIVATED))
{
if (getPre(userData))
{
events.add(Type.PREPASSIVATE);
}
else
{
events.add(Type.POSTPASSIVATE);
}
}
}
catch (RuntimeException e)
{
// Store so the test can rethrow
exception = e;
}
catch (AssertionError e)
{
// Store so the test can rethrow
failure = e;
}
}
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/replicated/ 0000755 0001750 0001750 00000000000 11376173766 024571 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/replicated/SyncReplTest.java 0000644 0001750 0001750 00000011676 11017455042 030024 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.replicated;
import org.jboss.cache.Cache;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.InvocationContext;
import org.jboss.cache.Node;
import org.jboss.cache.NodeSPI;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.config.Option;
import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import org.jboss.cache.invocation.CacheInvocationDelegate;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* @author Manik Surtani (manik@jboss.org)
*/
@Test(groups = {"functional", "jgroups"})
public class SyncReplTest
{
private Cache[] caches;
@BeforeMethod(alwaysRun = true)
public void setUp()
{
System.out.println("*** In setUp()");
caches = new Cache[2];
caches[0] = new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(CacheMode.REPL_SYNC));
caches[1] = new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(CacheMode.REPL_SYNC));
TestingUtil.blockUntilViewsReceived(caches, 5000);
System.out.println("*** Finished setUp()");
}
@AfterMethod(alwaysRun = true)
public void tearDown()
{
if (caches != null) TestingUtil.killCaches(caches);
}
@SuppressWarnings("unchecked")
public void testBasicOperation()
{
assertClusterSize("Should only be 2 caches in the cluster!!!", 2);
assertInvocationContextInitState();
Fqn f = Fqn.fromString("/test/data");
String k = "key", v = "value";
assertNull("Should be null", caches[0].getRoot().getChild(f));
assertNull("Should be null", caches[1].getRoot().getChild(f));
Node node = caches[0].getRoot().addChild(f);
assert ((NodeSPI) node).getCache() instanceof CacheInvocationDelegate;
assertNotNull("Should not be null", node);
node.put(k, v);
assertEquals(v, node.get(k));
assertEquals(v, caches[0].get(f, k));
assertEquals("Should have replicated", v, caches[1].get(f, k));
}
@SuppressWarnings("unchecked")
public void testSyncRepl()
{
assertClusterSize("Should only be 2 caches in the cluster!!!", 2);
assertInvocationContextInitState();
Fqn fqn = Fqn.fromString("/JSESSIONID/1010.10.5:3000/1234567890/1");
caches[0].getConfiguration().setSyncCommitPhase(true);
caches[1].getConfiguration().setSyncCommitPhase(true);
caches[0].put(fqn, "age", 38);
assertEquals("Value should be set", 38, caches[0].get(fqn, "age"));
assertEquals("Value should have replicated", 38, caches[1].get(fqn, "age"));
}
/**
* Checks for expected propagation of removeNode calls.
*/
@SuppressWarnings("unchecked")
public void testNodeConvenienceNodeRemoval()
{
// this fqn is relative, but since it is from the root it may as well be absolute
Fqn fqn = Fqn.fromString("/test/fqn");
caches[0].getRoot().addChild(fqn);
assertTrue(caches[0].getRoot().hasChild(fqn));
assertTrue(caches[1].getRoot().hasChild(fqn));
assertEquals(true, caches[0].removeNode(fqn));
assertFalse(caches[0].getRoot().hasChild(fqn));
assertFalse(caches[1].getRoot().hasChild(fqn));
assertEquals(false, caches[0].removeNode(fqn));
// Confirm it works as expected if the removed node has a child
Fqn child = Fqn.fromString("/test/fqn/child");
caches[0].getRoot().addChild(child);
assertTrue(caches[0].getRoot().hasChild(child));
assertTrue(caches[1].getRoot().hasChild(child));
assertEquals(true, caches[0].removeNode(fqn));
assertFalse(caches[0].getRoot().hasChild(fqn));
assertFalse(caches[1].getRoot().hasChild(fqn));
assertEquals(false, caches[0].removeNode(fqn));
}
private void assertClusterSize(String message, int size)
{
for (Cache c : caches)
{
assertClusterSize(message, size, c);
}
}
private void assertClusterSize(String message, int size, Cache c)
{
assertEquals(message, size, c.getMembers().size());
}
private void assertInvocationContextInitState()
{
for (Cache c : caches)
{
assertInvocationContextInitState(c);
}
}
private void assertInvocationContextInitState(Cache c)
{
InvocationContext ctx = c.getInvocationContext();
InvocationContext control = null;
try
{
control = ctx.clone();
}
catch (CloneNotSupportedException e)
{
throw new RuntimeException(e);
}
control.reset();
control.setOptionOverrides(new Option());
assertEquals("Should be equal", control, ctx);
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/replicated/SyncReplTxTest.java 0000644 0001750 0001750 00000125751 11017455042 030340 0 ustar twerner twerner /*
*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.replicated;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.Cache;
import org.jboss.cache.CacheException;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.lock.TimeoutException;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.notifications.annotation.CacheListener;
import org.jboss.cache.notifications.annotation.NodeModified;
import org.jboss.cache.notifications.event.NodeEvent;
import org.jboss.cache.transaction.TransactionSetup;
import org.jboss.cache.util.CachePrinter;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.transaction.NotSupportedException;
import javax.transaction.RollbackException;
import javax.transaction.Status;
import javax.transaction.Synchronization;
import javax.transaction.SystemException;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
/**
* Replicated unit test for sync transactional CacheImpl
* Note: we use DummyTransactionManager for Tx purpose instead of relying on
* jta.
*
* @version $Revision: 5906 $
*/
@Test(groups = {"functional", "jgroups", "transaction"})
public class SyncReplTxTest
{
private static Log log = LogFactory.getLog(SyncReplTxTest.class);
private CacheSPI cache1;
private CacheSPI cache2;
Semaphore lock;
private Throwable t1_ex;
private Throwable t2_ex;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
t1_ex = t2_ex = null;
lock = new Semaphore(1);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TransactionSetup.cleanup();
destroyCaches();
}
private TransactionManager beginTransaction() throws SystemException, NotSupportedException
{
return beginTransaction(cache1);
}
private TransactionManager beginTransaction(CacheSPI c) throws SystemException, NotSupportedException
{
TransactionManager mgr = c.getConfiguration().getRuntimeConfig().getTransactionManager();
mgr.begin();
return mgr;
}
private void initCaches(Configuration.CacheMode caching_mode) throws Exception
{
cache1 = (CacheSPI) new DefaultCacheFactory().createCache(false);
cache2 = (CacheSPI) new DefaultCacheFactory().createCache(false);
cache1.getConfiguration().setCacheMode(caching_mode);
cache2.getConfiguration().setCacheMode(caching_mode);
cache1.getConfiguration().setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache2.getConfiguration().setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache1.getConfiguration().setTransactionManagerLookupClass(TransactionSetup.getManagerLookup());
cache2.getConfiguration().setTransactionManagerLookupClass(TransactionSetup.getManagerLookup());
cache1.getConfiguration().setLockAcquisitionTimeout(5000);
cache2.getConfiguration().setLockAcquisitionTimeout(5000);
configureMultiplexer(cache1);
configureMultiplexer(cache2);
cache1.start();
cache2.start();
validateMultiplexer(cache1);
validateMultiplexer(cache2);
}
/**
* Provides a hook for multiplexer integration. This default implementation
* is a no-op; subclasses that test mux integration would override
* to integrate the given cache with a multiplexer.
*
* param cache a cache that has been configured but not yet created.
*
* @param cache cache
* @throws Exception exception
*/
protected void configureMultiplexer(Cache cache) throws Exception
{
// default does nothing
}
/**
* Provides a hook to check that the cache's channel came from the
* multiplexer, or not, as expected. This default impl asserts that
* the channel did not come from the multiplexer.
*
* @param cache a cache that has already been started
*/
protected void validateMultiplexer(Cache cache)
{
assertFalse("Cache is not using multiplexer", cache.getConfiguration().isUsingMultiplexer());
}
private void destroyCaches()
{
if (cache1 != null)
{
cache1.stop();
}
if (cache2 != null)
{
cache2.stop();
}
cache1 = null;
cache2 = null;
}
public void testLockRemoval() throws Exception
{
initCaches(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setSyncCommitPhase(true);
TestingUtil.extractLockManager(cache1).unlockAll(cache1.getRoot());
TransactionManager tm = beginTransaction();
cache1.put("/bela/ban", "name", "Bela Ban");
assertEquals(3, cache1.getNumberOfLocksHeld());
assertEquals(0, cache2.getNumberOfLocksHeld());
tm.commit();
assertEquals(0, cache1.getNumberOfLocksHeld());
assertEquals(0, cache2.getNumberOfLocksHeld());
}
public void testSyncRepl() throws Exception
{
Integer age;
Transaction tx;
initCaches(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setSyncCommitPhase(true);
cache2.getConfiguration().setSyncCommitPhase(true);
TransactionManager mgr = beginTransaction();
cache1.put("/a/b/c", "age", 38);
tx = mgr.suspend();
assertNull("age on cache2 must be null as the TX has not yet been committed", cache2.get("/a/b/c", "age"));
log.debug("cache1: locks held before commit: " + CachePrinter.printCacheLockingInfo(cache1));
log.debug("cache2: locks held before commit: " + CachePrinter.printCacheLockingInfo(cache2));
mgr.resume(tx);
mgr.commit();
log.debug("cache1: locks held after commit: " + CachePrinter.printCacheLockingInfo(cache1));
log.debug("cache2: locks held after commit: " + CachePrinter.printCacheLockingInfo(cache2));
// value on cache2 must be 38
age = (Integer) cache2.get("/a/b/c", "age");
assertNotNull("\"age\" obtained from cache2 must be non-null ", age);
assertTrue("\"age\" must be 38", age == 38);
}
public void testSimplePut() throws Exception
{
initCaches(Configuration.CacheMode.REPL_SYNC);
cache1.put("/JSESSION/localhost/192.168.1.10:32882/Courses/0", "Instructor", "Ben Wang");
cache1.put("/JSESSION/localhost/192.168.1.10:32882/1", "Number", 10);
}
public void testSimpleTxPut() throws Exception
{
TransactionManager tm;
final Fqn NODE1 = Fqn.fromString("/one/two/three");
initCaches(Configuration.CacheMode.REPL_SYNC);
tm = beginTransaction();
cache1.put(NODE1, "age", 38);
System.out.println("TransactionTable for cache1 after cache1.put():\n" + cache1.getTransactionTable().toString(true));
tm.commit();
/*
tx=beginTransaction();
cache1.put(NODE1, "age", new Integer(38));
cache1.put(NODE2, "name", "Ben of The Far East");
cache1.put(NODE3, "key", "UnknowKey");
System.out.println("TransactionTable for cache1 after cache1.put():\n" + cache1.getTransactionTable().toString(true));
tx.commit();
*/
/*
tx=beginTransaction();
cache1.put(NODE1, "age", new Integer(38));
cache1.put(NODE1, "AOPInstance", new AOPInstance());
cache1.put(NODE2, "AOPInstance", new AOPInstance());
cache1.put(NODE1, "AOPInstance", new AOPInstance());
tx.commit();
System.out.println("TransactionTable for cache1 after cache1.put():\n" + cache1.getTransactionTable().toString(true));
*/
}
public void testSyncReplWithModficationsOnBothCaches() throws Exception
{
TransactionManager tm;
final Fqn NODE1 = Fqn.fromString("/one/two/three");
final Fqn NODE2 = Fqn.fromString("/eins/zwei/drei");
initCaches(Configuration.CacheMode.REPL_SYNC);
// create roots first
cache1.put("/one/two", null);
cache2.put("/eins/zwei", null);
cache1.getConfiguration().setSyncCommitPhase(true);
cache2.getConfiguration().setSyncCommitPhase(true);
tm = beginTransaction();
cache1.put(NODE1, "age", 38);
System.out.println("TransactionTable for cache1 after cache1.put():\n" + cache1.getTransactionTable().toString(true));
cache2.put(NODE2, "age", 39);
System.out.println("TransactionTable for cache2 after cache2.put():\n" + cache2.getTransactionTable().toString(true));
System.out.println("cache1 before commit:\n" + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("cache2 before commit:\n" + CachePrinter.printCacheLockingInfo(cache2));
try
{
tm.commit();
fail("Should not succeed with SERIALIZABLE semantics");
}
catch (Exception e)
{
//should be a classic deadlock here.
}
System.out.println("cache1 after commit:\n" + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("cache2 after commit:\n" + CachePrinter.printCacheLockingInfo(cache2));
/*
assertTrue(cache1.exists(NODE1));
assertTrue(cache1.exists(NODE2));
assertTrue(cache1.exists(NODE1));
assertTrue(cache2.exists(NODE2));
age = (Integer) cache1.get(NODE1, "age");
assertNotNull("\"age\" obtained from cache1 for " + NODE1 + " must be non-null ", age);
assertTrue("\"age\" must be 38", age == 38);
age = (Integer) cache2.get(NODE1, "age");
assertNotNull("\"age\" obtained from cache2 for " + NODE1 + " must be non-null ", age);
assertTrue("\"age\" must be 38", age == 38);
age = (Integer) cache1.get(NODE2, "age");
assertNotNull("\"age\" obtained from cache1 for " + NODE2 + " must be non-null ", age);
assertTrue("\"age\" must be 39", age == 39);
age = (Integer) cache2.get(NODE2, "age");
assertNotNull("\"age\" obtained from cache2 for " + NODE2 + " must be non-null ", age);
assertTrue("\"age\" must be 39", age == 39);
*/
assertEquals(0, cache1.getNumberOfLocksHeld());
assertEquals(0, cache2.getNumberOfLocksHeld());
System.out.println("TransactionTable for cache1:\n" + cache1.getTransactionTable().toString(true));
System.out.println("TransactionTable for cache2:\n" + cache2.getTransactionTable().toString(true));
}
public void testSyncReplWithModficationsOnBothCachesSameData() throws Exception
{
TransactionManager tm;
final Fqn NODE = Fqn.fromString("/one/two/three");
initCaches(Configuration.CacheMode.REPL_SYNC);
tm = beginTransaction();
cache1.put(NODE, "age", 38);
System.out.println("TransactionTable for cache1 after cache1.put():\n" + cache1.getTransactionTable().toString(true));
cache2.put(NODE, "age", 39);
System.out.println("TransactionTable for cache2 after cache2.put():\n" + cache2.getTransactionTable().toString(true));
System.out.println("cache1 before commit:\n" + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("cache2 before commit:\n" + CachePrinter.printCacheLockingInfo(cache2));
try
{
tm.commit();
fail("commit should throw a RollbackException, we should not get here");
}
catch (RollbackException rollback)
{
System.out.println("Transaction was rolled back, this is correct");
}
System.out.println("cache1 after commit:\n" + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("cache2 after commit:\n" + CachePrinter.printCacheLockingInfo(cache2));
assertEquals(0, cache1.getNumberOfLocksHeld());
assertEquals(0, cache2.getNumberOfLocksHeld());
assertEquals(0, cache1.getNumberOfNodes());
assertEquals(0, cache2.getNumberOfNodes());
}
public void testSyncReplWithModficationsOnBothCachesWithRollback() throws Exception
{
TransactionManager tm;
final Fqn fqn1 = Fqn.fromString("/one/two/three");
final Fqn fqn2 = Fqn.fromString("/eins/zwei/drei");
initCaches(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setSyncRollbackPhase(true);
cache2.getConfiguration().setSyncRollbackPhase(true);
tm = beginTransaction();
cache1.put(fqn1, "age", 38);
cache2.put(fqn2, "age", 39);
System.out.println("cache1 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("cache2 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache2));
// this will rollback the transaction
Transaction tx = tm.getTransaction();
tx.registerSynchronization(new TransactionAborter(tx));
try
{
tm.commit();
fail("commit should throw a RollbackException, we should not get here");
}
catch (RollbackException rollback)
{
System.out.println("Transaction was rolled back, this is correct");
}
System.out.println("cache1 (after rollback):\n" + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("cache2 (after rollback):\n" + CachePrinter.printCacheLockingInfo(cache2));
assertEquals(0, cache1.getNumberOfLocksHeld());
assertEquals(0, cache2.getNumberOfLocksHeld());
assertEquals(0, cache1.getNumberOfNodes());
assertEquals(0, cache2.getNumberOfNodes());
}
/**
* Test for JBCACHE-359 -- does a callback into cache from a listener
* interfere with transaction rollback.
*
* @throws Exception
*/
// Is this test still valid after JBCACHE-1022 ?
// public void testSyncReplWithRollbackAndListener() throws Exception
// {
// Transaction tx;
// final Fqn NODE1 = Fqn.fromString("/one/two/three");
//
// initCaches(Configuration.CacheMode.REPL_SYNC);
//
// cache1.getConfiguration().setSyncRollbackPhase(true);
// cache2.getConfiguration().setSyncRollbackPhase(true);
//
// // Test with a rollback on the sending side
//
// CallbackListener cbl1 = new CallbackListener(cache1, "age");
// CallbackListener cbl2 = new CallbackListener(cache2, "age");
//
// tx = beginTransaction();
// cache1.put(NODE1, "age", 38);
//
// System.out.println("cache1 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache1));
// System.out.println("cache2 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache2));
//
// // this will rollback the transaction
// tx.registerSynchronization(new TransactionAborter(tx));
//
// try
// {
// tx.commit();
// fail("commit should throw a RollbackException, we should not get here");
// }
// catch (RollbackException rollback)
// {
// rollback.printStackTrace();
// System.out.println("Transaction was rolled back, this is correct");
// }
//
// // Sleep, as the rollback call to cache2 is async
// TestingUtil.sleepThread(1000);
//
// System.out.println("cache1 (after rollback):\n" + CachePrinter.printCacheLockingInfo(cache1));
// System.out.println("cache2 (after rollback):\n" + CachePrinter.printCacheLockingInfo(cache2));
//
// assertNull(cbl1.getCallbackException());
// assertNull(cbl2.getCallbackException());
//
// assertEquals(0, cache1.getNumberOfLocksHeld());
// assertEquals(0, cache2.getNumberOfLocksHeld());
//
// assertEquals(0, cache1.getNumberOfNodes());
// assertEquals(0, cache2.getNumberOfNodes());
//
// // Test with a rollback on the receiving side
//
// cache2.getNotifier().removeCacheListener(cbl2);
// // listener aborts any active tx
// cbl2 = new TransactionAborterCallbackListener(cache2, "age");
//
// tx = beginTransaction();
// cache1.put(NODE1, "age", 38);
//
// System.out.println("cache1 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache1));
// System.out.println("cache2 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache2));
//
// tx.commit();
//
// // Sleep, as the commit call to cache2 is async
// TestingUtil.sleepThread(1000);
//
// System.out.println("cache1 (after rollback):\n" + CachePrinter.printCacheLockingInfo(cache1));
// System.out.println("cache2 (after rollback):\n" + CachePrinter.printCacheLockingInfo(cache2));
//
// assertNull(cbl1.getCallbackException());
// assertNull(cbl2.getCallbackException());
//
// assertEquals(0, cache1.getNumberOfLocksHeld());
// assertEquals(0, cache2.getNumberOfLocksHeld());
//
// // cache1 didn't fail, so should have 3 nodes
// assertEquals(3, cache1.getNumberOfNodes());
// assertEquals(0, cache2.getNumberOfNodes());
//
// }
/**
* Test for JBCACHE-361 -- does marking a tx on the remote side
* rollback-only cause a rollback on the originating side?
*/
public void testSyncReplWithRemoteRollback() throws Exception
{
TransactionManager tm;
final Fqn NODE1 = Fqn.fromString("/one/two/three");
initCaches(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setSyncRollbackPhase(true);
cache2.getConfiguration().setSyncRollbackPhase(true);
// Test with a rollback on the remote side
// listener aborts any active tx
//TransactionAborterListener tal = new TransactionAborterListener(cache2);
tm = beginTransaction();
cache1.put(NODE1, "age", 38);
System.out.println("cache1 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("cache2 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache2));
// instead of a listener lets just get a WL on ROOT on cache2. And hold on to it.
Transaction tx = tm.suspend();
tm.begin();
cache2.getRoot().put("x", "y");
Transaction tx2 = cache2.getTransactionManager().suspend();
System.out.println("cache2 (before commit):\n" + CachePrinter.printCacheLockingInfo(cache2));
tm.resume(tx);
try
{
tm.commit();
fail("commit should throw a RollbackException, we should not get here");
}
catch (RollbackException rollback)
{
System.out.println("Transaction was rolled back, this is correct");
}
finally
{
tm.resume(tx2);
tm.rollback();
}
// Sleep, as the commit call to cache2 is async
TestingUtil.sleepThread(1000);
System.out.println("cache1 (after rollback):\n" + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("cache2 (after rollback):\n" + CachePrinter.printCacheLockingInfo(cache2));
//assertNull(tal.getCallbackException());
assertEquals(0, cache1.getNumberOfLocksHeld());
assertEquals(0, cache2.getNumberOfLocksHeld());
assertEquals(0, cache1.getNumberOfNodes());
assertEquals(0, cache2.getNumberOfNodes());
}
public void testASyncRepl() throws Exception
{
Integer age;
TransactionManager tm;
initCaches(Configuration.CacheMode.REPL_ASYNC);
tm = beginTransaction();
cache1.put("/a/b/c", "age", 38);
Thread.sleep(1000);
assertNull("age on cache2 must be null as the TX has not yet been committed", cache2.get("/a/b/c", "age"));
tm.commit();
Thread.sleep(1000);
// value on cache2 must be 38
age = (Integer) cache2.get("/a/b/c", "age");
assertNotNull("\"age\" obtained from cache2 is null ", age);
assertTrue("\"age\" must be 38", age == 38);
}
/**
* Tests concurrent modifications: thread1 succeeds and thread2 is blocked until thread1 is done, and then succeeds
* too. However, this is flawed with the introduction of interceptors, here's why.
*
*
Thread1 acquires the lock for /bela/ban on cache1
*
Thread2 blocks on Thread1 to release the lock
*
Thread1 commits: this means the TransactionInterceptor and the ReplicationInterceptor are called in
* the sequence in which they registered. Unfortunately, the TransactionInterceptor registered first. In the
* PREPARE phase, the ReplicationInterceptor calls prepare() in cache2 synchronously. The TxInterceptor
* does nothing. The the COMMIT phase, the TxInterceptor commits the data by releasing the locks locally and
* then the ReplicationInterceptor sends an asynchronous COMMIT to cache2.
*
Because the TxInterceptor for Thread1 releases the locks locally before sending the async COMMIT,
* Thread2 is able to acquire the lock for /bela/ban in cache1 and then starts the PREPARE phase by sending a
* synchronous PREPARE to cache2. If this PREPARE arrives at cache2 before the COMMIT from Thread1,
* the PREPARE will block because it attempts to acquire a lock on /bela/ban on cache2 still held by Thread1
* (which would be released by Thread1's COMMIT). This results in deadlock, which is resolved by Thread2 running
* into a timeout with subsequent rollback and Thread1 succeeding.
*
* There are 3 solutions to this:
*
*
Do nothing. This is standard behavior for concurrent access to the same data. Same thing if the 2 threads
* operated on the same data in separate caches, e.g. Thread1 on /bela/ban in cache1 and Thread2 on
* /bela/ban in cache2. The semantics of Tx commit as handled by the interceptors is: after tx1.commit() returns
* the locks held by tx1 are release and a COMMIT message is on the way (if sent asynchronously).
*
Force an order over TxInterceptor and ReplicationInterceptor. This would require ReplicationInterceptor
* to always be fired first on TX commit. Downside: the interceptors have an implicit dependency, which is not
* nice.
*
Priority-order requests at the receiver; e.g. a COMMIT could release a blocked PREPARE. This is bad because
* it violates JGroups' FIFO ordering guarantees.
*
* I'm currently investigating solution #2, ie. creating an OrderedSynchronizationHandler, which allows other
* SynchronizationHandlers to register (atHead, atTail), and the OrderedSynchronizationHandler would call the
* SynchronizationHandler in the order in which they are defined.
*
* @throws Exception exception
*/
public void testConcurrentPuts() throws Exception
{
initCaches(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setSyncCommitPhase(true);
Thread t1 = new Thread("Thread1")
{
TransactionManager tm;
public void run()
{
try
{
tm = beginTransaction();
cache1.put("/bela/ban", "name", "Bela Ban");
TestingUtil.sleepThread(2000);// Thread2 will be blocked until we commit
tm.commit();
System.out.println("[Thread1] ** LOCK INFO cache1: " + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("[Thread1] ** LOCK INFO cache2: " + CachePrinter.printCacheLockingInfo(cache2));
}
catch (Throwable ex)
{
ex.printStackTrace();
t1_ex = ex;
}
}
};
Thread t2 = new Thread("Thread2")
{
TransactionManager tm;
public void run()
{
try
{
TestingUtil.sleepThread(1000);// give Thread1 time to acquire the lock
tm = beginTransaction();
System.out.println("[Thread2] ** LOCK INFO cache1: " + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("[Thread2] ** LOCK INFO cache2: " + CachePrinter.printCacheLockingInfo(cache2));
cache1.put("/bela/ban", "name", "Michelle Ban");
System.out.println("[Thread2] ** LOCK INFO cache1: " + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("[Thread2] ** LOCK INFO cache2: " + CachePrinter.printCacheLockingInfo(cache2));
tm.commit();
System.out.println("[Thread2] ** LOCK INFO cache1: " + CachePrinter.printCacheLockingInfo(cache1));
System.out.println("[Thread2] ** LOCK INFO cache2: " + CachePrinter.printCacheLockingInfo(cache2));
}
catch (Throwable ex)
{
ex.printStackTrace();
t2_ex = ex;
}
}
};
// Let the game start
t1.start();
t2.start();
// Wait for threads to die
t1.join();
t2.join();
if (t1_ex != null)
{
fail("Thread1 failed: " + t1_ex);
}
if (t2_ex != null)
{
fail("Thread2 failed: " + t2_ex);
}
assertEquals("Michelle Ban", cache1.get("/bela/ban", "name"));
}
/**
* Should reproduce JBCACHE-32 problem (http://jira.jboss.com/jira/browse/JBCACHE-32)
*/
public void testConcurrentCommitsWith1Thread() throws Exception
{
_testConcurrentCommits(1);
}
/**
* Should reproduce JBCACHE-32 problem (http://jira.jboss.com/jira/browse/JBCACHE-32)
*/
public void testConcurrentCommitsWith5Threads() throws Exception
{
_testConcurrentCommits(5);
}
/**
* Should reproduce JBCACHE-32 problem (http://jira.jboss.com/jira/browse/JBCACHE-32)
*/
private void _testConcurrentCommits(int num_threads)
{
Object myMutex = new Object();
final CacheSPI c1 = (CacheSPI) new DefaultCacheFactory().createCache(false);
final CacheSPI c2 = (CacheSPI) new DefaultCacheFactory().createCache(false);
c1.getConfiguration().setClusterName("TempCluster");
c2.getConfiguration().setClusterName("TempCluster");
c1.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
c2.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
c1.getConfiguration().setSyncCommitPhase(true);
c2.getConfiguration().setSyncCommitPhase(true);
c1.getConfiguration().setSyncRollbackPhase(true);
c2.getConfiguration().setSyncRollbackPhase(true);
c1.getConfiguration().setIsolationLevel(IsolationLevel.REPEATABLE_READ);
c2.getConfiguration().setIsolationLevel(IsolationLevel.REPEATABLE_READ);
c1.getConfiguration().setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
c2.getConfiguration().setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
c1.getConfiguration().setLockAcquisitionTimeout(5000);
c2.getConfiguration().setLockAcquisitionTimeout(5000);
c1.start();
c2.start();
final List exceptions = new ArrayList();
class MyThread extends Thread
{
final Object mutex;
public MyThread(String name, Object mutex)
{
super(name);
this.mutex = mutex;
}
public void run()
{
TransactionManager tm = null;
try
{
tm = beginTransaction(c1);
c1.put("/thread/" + getName(), null);
System.out.println("Thread " + getName() + " after put(): " + c1.toString());
System.out.println("Thread " + getName() + " waiting on mutex");
synchronized (mutex)
{
mutex.wait();
}
System.out.println("Thread " + getName() + " committing");
tm.commit();
System.out.println("Thread " + getName() + " committed successfully");
}
catch (Exception e)
{
exceptions.add(e);
}
finally
{
try
{
if (tm != null)
tm.rollback();
}
catch (Exception e)
{
// do nothing
}
}
}
}
MyThread[] threads = new MyThread[num_threads];
for (int i = 0; i < threads.length; i++)
{
threads[i] = new MyThread("#" + i, myMutex);
}
for (int i = 0; i < threads.length; i++)
{
MyThread thread = threads[i];
System.out.println("starting thread #" + i);
thread.start();
}
TestingUtil.sleepThread(6000);
synchronized (myMutex)
{
System.out.println("cache is " + CachePrinter.printCacheLockingInfo(c1));
System.out.println("******************* SIGNALLING THREADS ********************");
myMutex.notifyAll();
}
for (MyThread thread : threads)
{
try
{
thread.join();
System.out.println("Joined thread " + thread.getName());
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
System.out.println("FINAL c1:\n" + CachePrinter.printCacheDetails(c1) + "\nlocks:\n" + CachePrinter.printCacheLockingInfo(c1));
assertEquals(0, c1.getNumberOfLocksHeld());
assertEquals(0, c2.getNumberOfLocksHeld());
c1.stop();
c2.stop();
// if(ex != null)
// {
// ex.printStackTrace();
// fail("Thread failed: " + ex);
// }
// we can only expect 1 thread to succeed. The others will fail. So, threads.length -1 exceptions.
// this is a timing issue - 2 threads still may succeed on a multi cpu system
// assertEquals(threads.length - 1, exceptions.size());
for (Exception exception : exceptions)
assertEquals(TimeoutException.class, exception.getClass());
}
/**
* Conncurrent put on 2 different instances.
*/
public void testConcurrentPutsOnTwoInstances() throws Exception
{
initCaches(Configuration.CacheMode.REPL_SYNC);
final CacheSPI c1 = this.cache1;
final CacheSPI c2 = this.cache2;
Thread t1 = new Thread()
{
TransactionManager tm;
public void run()
{
try
{
tm = beginTransaction();
c1.put("/ben/wang", "name", "Ben Wang");
TestingUtil.sleepThread(8000);
tm.commit();// This should go thru
}
catch (Throwable ex)
{
ex.printStackTrace();
t1_ex = ex;
}
}
};
Thread t2 = new Thread()
{
TransactionManager tm;
public void run()
{
try
{
TestingUtil.sleepThread(1000);// give Thread1 time to acquire the lock
tm = beginTransaction();
c2.put("/ben/wang", "name", "Ben Jr.");
tm.commit();// This will time out and rollback first because Thread1 has a tx going as well.
}
catch (RollbackException rollback_ex)
{
System.out.println("received rollback exception as expected");
}
catch (Throwable ex)
{
ex.printStackTrace();
t2_ex = ex;
}
}
};
// Let the game start
t1.start();
t2.start();
// Wait for thread to die but put an insurance of 5 seconds on it.
t1.join();
t2.join();
if (t1_ex != null)
{
fail("Thread1 failed: " + t1_ex);
}
if (t2_ex != null)
{
fail("Thread2 failed: " + t2_ex);
}
assertEquals("Ben Wang", c1.get("/ben/wang", "name"));
}
public void testPut() throws Exception
{
initCaches(Configuration.CacheMode.REPL_SYNC);
final CacheSPI c1 = this.cache1;
Thread t1 = new Thread()
{
public void run()
{
try
{
lock.acquire();
System.out.println("-- t1 has lock");
c1.put("/a/b/c", "age", 38);
System.out.println("[Thread1] set value to 38");
System.out.println("-- t1 releases lock");
lock.release();
TestingUtil.sleepThread(300);
Thread.yield();
lock.acquire();
System.out.println("-- t1 has lock");
c1.put("/a/b/c", "age", 39);
System.out.println("[Thread1] set value to 39");
System.out.println("-- t1 releases lock");
lock.release();
assertEquals(39, c1.get("/a/b/c", "age"));
}
catch (Throwable ex)
{
ex.printStackTrace();
t1_ex = ex;
}
finally
{
lock.release();
}
}
};
Thread t2 = new Thread()
{
public void run()
{
try
{
TestingUtil.sleepThread(100);
Thread.yield();
lock.acquire();
System.out.println("-- t2 has lock");
// Should replicate the value right away.
Integer val = (Integer) cache2.get("/a/b/c", "age");
System.out.println("[Thread2] value is " + val);
assertEquals(new Integer(38), val);
System.out.println("-- t2 releases lock");
lock.release();
TestingUtil.sleepThread(300);
Thread.yield();
TestingUtil.sleepThread(500);
lock.acquire();
System.out.println("-- t2 has lock");
val = (Integer) cache2.get("/a/b/c", "age");
System.out.println("-- t2 releases lock");
lock.release();
assertEquals(new Integer(39), val);
}
catch (Throwable ex)
{
ex.printStackTrace();
t2_ex = ex;
}
finally
{
lock.release();
}
}
};
// Let the game start
t1.start();
t2.start();
// Wait for thread to die but put an insurance of 5 seconds on it.
t1.join();
t2.join();
if (t1_ex != null)
{
fail("Thread1 failed: " + t1_ex);
}
if (t2_ex != null)
{
fail("Thread2 failed: " + t2_ex);
}
}
/**
* Test replicated cache with transaction. Idea is to have two threads running
* a local cache each that is replicating. Depending on whether cache1 commit/rollback or not,
* the cache2.get will get different values.
* Note that we have used sleep to interpose thread execution sequence.
* Although it's not fool proof, it is rather simple and intuitive.
*/
public void testPutTx() throws Exception
{
TransactionManager tm;
try
{
initCaches(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setSyncCommitPhase(true);
cache2.getConfiguration().setSyncCommitPhase(true);
tm = beginTransaction();
cache1.put("/a/b/c", "age", 38);
cache1.put("/a/b/c", "age", 39);
Object val = cache2.get("/a/b/c", "age");// must be null as not yet committed
assertNull(val);
tm.commit();
tm = beginTransaction();
assertEquals(39, cache2.get("/a/b/c", "age"));// must not be null
tm.commit();
}
catch (Throwable t)
{
t.printStackTrace();
t1_ex = t;
}
finally
{
lock.release();
}
}
/**
* Have both cache1 and cache2 do add and commit. cache1 commit should time out
* since it can't obtain the lock when trying to replicate cache2. On the other hand,
* cache2 commit will succeed since now that cache1 is rollbacked and lock is
* released.
*/
public void testPutTx1() throws Exception
{
initCaches(Configuration.CacheMode.REPL_SYNC);
final CacheSPI c1 = this.cache1;
Thread t1 = new Thread()
{
public void run()
{
TransactionManager tm;
try
{
lock.acquire();
tm = beginTransaction();
c1.put("/a/b/c", "age", 38);
c1.put("/a/b/c", "age", 39);
lock.release();
TestingUtil.sleepThread(300);
lock.acquire();
try
{
tm.commit();
}
catch (RollbackException ex)
{
System.out.println("[Thread1] received RollbackException, as expected. Rolling back changes");
}
finally
{
lock.release();
}
}
catch (Throwable ex)
{
ex.printStackTrace();
t1_ex = ex;
}
finally
{
lock.release();
}
}
};
Thread t2 = new Thread()
{
public void run()
{
TransactionManager tm;
try
{
sleep(200);
Thread.yield();
lock.acquire();
tm = beginTransaction();
assertNull(cache2.get("/a/b/c", "age"));// must be null as not yet committed
cache2.put("/a/b/c", "age", 40);
lock.release();
TestingUtil.sleepThread(300);
lock.acquire();
assertEquals(40, cache2.get("/a/b/c", "age"));// must not be null
tm.commit();
lock.release();
TestingUtil.sleepThread(1000);
tm = beginTransaction();
assertEquals("After cache2 commit", 40, cache2.get("/a/b/c", "age"));
tm.commit();
}
catch (Throwable ex)
{
ex.printStackTrace();
t2_ex = ex;
}
finally
{
lock.release();
}
}
};
// Let the game start
t1.start();
t2.start();
t1.join();
t2.join();
if (t1_ex != null)
{
fail("Thread1 failed: " + t1_ex);
}
if (t2_ex != null)
{
fail("Thread2 failed: " + t2_ex);
}
}
public void testPutTxWithRollback() throws Exception
{
initCaches(Configuration.CacheMode.REPL_SYNC);
final CacheSPI c2 = this.cache1;
Thread t1 = new Thread()
{
public void run()
{
TransactionManager tm;
try
{
lock.acquire();
tm = beginTransaction();
c2.put("/a/b/c", "age", 38);
c2.put("/a/b/c", "age", 39);
lock.release();
TestingUtil.sleepThread(100);
lock.acquire();
tm.rollback();
lock.release();
}
catch (Throwable ex)
{
ex.printStackTrace();
t1_ex = ex;
}
finally
{
lock.release();
}
}
};
Thread t2 = new Thread()
{
public void run()
{
TransactionManager tm;
try
{
sleep(200);
Thread.yield();
lock.acquire();
tm = beginTransaction();
assertNull(cache2.get("/a/b/c", "age"));// must be null as not yet committed
lock.release();
TestingUtil.sleepThread(100);
lock.acquire();
assertNull(cache2.get("/a/b/c", "age"));// must be null as rolledback
tm.commit();
lock.release();
}
catch (Throwable ex)
{
ex.printStackTrace();
t2_ex = ex;
}
finally
{
lock.release();
}
}
};
// Let the game start
t1.start();
t2.start();
// Wait for thread to die but put an insurance of 5 seconds on it.
t1.join();
t2.join();
if (t1_ex != null)
{
fail("Thread1 failed: " + t1_ex);
}
if (t2_ex != null)
{
fail("Thread2 failed: " + t2_ex);
}
}
static class TransactionAborter implements Synchronization
{
Transaction ltx = null;
public TransactionAborter(Transaction ltx)
{
this.ltx = ltx;
}
public void beforeCompletion()
{
try
{
ltx.setRollbackOnly();
}
catch (SystemException e)
{
// who cares
}
}
public void afterCompletion(int status)
{
}
}
@CacheListener
static class CallbackListener
{
CacheSPI callbackCache;
Object callbackKey;
Exception ex;
final Object mutex = new Object();
CallbackListener(CacheSPI cache, Object callbackKey)
{
this.callbackCache = cache;
this.callbackKey = callbackKey;
cache.getNotifier().addCacheListener(this);
}
@NodeModified
public void nodeModified(NodeEvent e)
{
if (!e.isPre())
{
// Lock on a mutex so test can't check for an exception
// until the get call completes
synchronized (mutex)
{
try
{
callbackCache.get(e.getFqn(), callbackKey);
}
catch (CacheException exc)
{
exc.printStackTrace();
ex = exc;
}
}
}
}
Exception getCallbackException()
{
synchronized (mutex)
{
return ex;
}
}
}
static class TransactionAborterCallbackListener extends CallbackListener
{
TransactionManager callbackTM;
TransactionAborterCallbackListener(CacheSPI cache, Object callbackKey)
{
super(cache, callbackKey);
callbackTM = callbackCache.getTransactionManager();
}
@NodeModified
public void nodeModified(NodeEvent ne)
{
if (!ne.isPre())
{
try
{
Transaction tx = callbackTM.getTransaction();
if (tx != null && tx.getStatus() == Status.STATUS_ACTIVE)
{
// this will rollback the transaction
tx.registerSynchronization(new TransactionAborter(tx));
}
else
{
super.nodeModified(ne);
}
}
catch (Exception e)
{
e.printStackTrace();
if (ex == null)
{
ex = e;
}
}
}
}
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/replicated/AsyncReplTest.java 0000755 0001750 0001750 00000015134 11017457124 030164 0 ustar twerner twerner /*
*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.replicated;
import org.jboss.cache.Cache;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.ReplicationListener;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.transaction.TransactionManager;
/**
* Unit test for replicated async CacheSPI. Use locking and multiple threads to test
* concurrent access to the tree.
*
* @version $Revision: 5908 $
*/
@Test(groups = {"functional", "jgroups"})
public class AsyncReplTest
{
private CacheSPI cache1, cache2;
private ReplicationListener replListener1, replListener2;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
log("creating cache1");
cache1 = createCache("CacheGroup");
replListener1 = new ReplicationListener(cache1);
log("creating cache2");
cache2 = createCache("CacheGroup");
replListener2 = new ReplicationListener(cache2);
}
private CacheSPI createCache(String name) throws Exception
{
CacheSPI cache = (CacheSPI) new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(CacheMode.REPL_ASYNC), false);
cache.getConfiguration().setClusterName(name);
// Call the hook that allows mux integration
configureMultiplexer(cache);
cache.create();
cache.start();
validateMultiplexer(cache);
return cache;
}
/**
* Provides a hook for multiplexer integration. This default implementation
* is a no-op; subclasses that test mux integration would override
* to integrate the given cache with a multiplexer.
*
* param cache a cache that has been configured but not yet created.
*/
protected void configureMultiplexer(Cache cache) throws Exception
{
// default does nothing
}
/**
* Provides a hook to check that the cache's channel came from the
* multiplexer, or not, as expected. This default impl asserts that
* the channel did not come from the multiplexer.
*
* @param cache a cache that has already been started
*/
protected void validateMultiplexer(Cache cache)
{
assertFalse("Cache is not using multiplexer", cache.getConfiguration().isUsingMultiplexer());
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache1, cache2);
}
public void testTxCompletion() throws Exception
{
// test a very simple replication.
Fqn fqn = Fqn.fromString("/a");
String key = "key";
replListener2.expectAny();
cache1.put(fqn, key, "value1");
// allow for replication
replListener2.waitForReplicationToOccur(500);
assertEquals("value1", cache1.get(fqn, key));
assertEquals("value1", cache2.get(fqn, key));
TransactionManager mgr = cache1.getTransactionManager();
mgr.begin();
replListener2.expectAny();
cache1.put(fqn, key, "value2");
assertEquals("value2", cache1.get(fqn, key));
assertEquals("value1", cache2.get(fqn, key));
mgr.commit();
replListener2.waitForReplicationToOccur(500);
assertEquals("value2", cache1.get(fqn, key));
assertEquals("value2", cache2.get(fqn, key));
mgr.begin();
cache1.put(fqn, key, "value3");
assertEquals("value3", cache1.get(fqn, key));
assertEquals("value2", cache2.get(fqn, key));
mgr.rollback();
assertEquals("value2", cache1.get(fqn, key));
assertEquals("value2", cache2.get(fqn, key));
}
public void testPutShouldNotReplicateToDifferentCluster()
{
CacheSPI cache3 = null, cache4 = null;
try
{
cache3 = createCache("DifferentGroup");
cache4 = createCache("DifferentGroup");
replListener2.expectAny();
cache1.put("/a/b/c", "age", 38);
// because we use async repl, modfication may not yet have been propagated to cache2, so
// we have to wait a little
replListener2.waitForReplicationToOccur(500);
assertNull("Should not have replicated", cache3.get("/a/b/c", "age"));
}
catch (Exception e)
{
fail(e.toString());
}
finally
{
if (cache3 != null)
{
cache3.stop();
}
if (cache4 != null)
{
cache4.stop();
}
}
}
public void testStateTransfer()
{
CacheSPI cache4 = null;
try
{
cache1.put("a/b/c", "age", 38);
cache4 = createCache("CacheGroup");
System.out.println("" + cache4.getMembers());
assertEquals(3, cache4.getMembers().size());// cache1, cache2 and cache4
assertEquals("\"age\" should be 38", 38, cache4.get("/a/b/c", "age"));
}
catch (Exception e)
{
fail(e.toString());
}
finally
{
if (cache4 != null)
{
System.out.println("cache4's view: " + cache4.getMembers());
cache4.stop();
}
}
}
public void testAsyncReplDelay()
{
Integer age;
try
{
cache1.put("/a/b/c", "age", 38);
// value on cache2 may be 38 or not yet replicated
age = (Integer) cache2.get("/a/b/c", "age");
log("attr \"age\" of \"/a/b/c\" on cache2=" + age);
assertTrue("should be either null or 38", age == null || age == 38);
}
catch (Exception e)
{
fail(e.toString());
}
}
public void testAsyncReplTxDelay()
{
Integer age;
try
{
TransactionManager tm = cache1.getTransactionManager();
tm.begin();
cache1.put("/a/b/c", "age", 38);
tm.commit();
// value on cache2 may be 38 or not yet replicated
age = (Integer) cache2.get("/a/b/c", "age");
log("attr \"age\" of \"/a/b/c\" on cache2=" + age);
assertTrue("should be either null or 38", age == null || age == 38);
}
catch (Exception e)
{
fail(e.toString());
}
}
private void log(String msg)
{
System.out.println("-- [" + Thread.currentThread() + "]: " + msg);
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/replicated/ReplicationExceptionTest.java 0000644 0001750 0001750 00000012335 10745367774 032433 0 ustar twerner twerner /*
*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.replicated;
import org.jboss.cache.CacheFactory;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.transaction.DummyTransactionManager;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.fail;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.naming.Context;
import javax.transaction.NotSupportedException;
import javax.transaction.RollbackException;
import javax.transaction.SystemException;
import javax.transaction.TransactionManager;
import java.io.NotSerializableException;
import java.io.Serializable;
/**
* Teting of replication exception for a Nonerislizable object
*
* @author Ben Wang
* @version $Revision: 5189 $
*/
@Test(groups = {"functional"})
public class ReplicationExceptionTest
{
private CacheSPI cache1, cache2;
String old_factory = null;
final String FACTORY = "org.jboss.cache.transaction.DummyContextFactory";
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
old_factory = System.getProperty(Context.INITIAL_CONTEXT_FACTORY);
System.setProperty(Context.INITIAL_CONTEXT_FACTORY, FACTORY);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
DummyTransactionManager.destroy();
destroyCaches();
if (old_factory != null)
{
System.setProperty(Context.INITIAL_CONTEXT_FACTORY, old_factory);
old_factory = null;
}
}
private TransactionManager beginTransaction() throws SystemException, NotSupportedException
{
TransactionManager mgr = cache1.getConfiguration().getRuntimeConfig().getTransactionManager();
mgr.begin();
return mgr;
}
private void initCaches(Configuration.CacheMode caching_mode)
{
CacheFactory instance = new DefaultCacheFactory();
cache1 = (CacheSPI) instance.createCache(false);
cache2 = (CacheSPI) instance.createCache(false);
cache1.getConfiguration().setCacheMode(caching_mode);
cache2.getConfiguration().setCacheMode(caching_mode);
cache1.getConfiguration().setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache2.getConfiguration().setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache1.getConfiguration().setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
cache2.getConfiguration().setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
/*
cache1.setTransactionManagerLookupClass("org.jboss.cache.transaction.GenericTransactionManagerLookup");
cache2.setTransactionManagerLookupClass("org.jboss.cache.transaction.GenericTransactionManagerLookup");
*/
cache1.getConfiguration().setLockAcquisitionTimeout(5000);
cache2.getConfiguration().setLockAcquisitionTimeout(5000);
cache1.start();
cache2.start();
}
void destroyCaches() throws Exception
{
if (cache1 != null)
{
cache1.stop();
}
if (cache2 != null)
{
cache2.stop();
}
cache1 = null;
cache2 = null;
}
public void testNonSerializableRepl() throws Exception
{
try
{
initCaches(Configuration.CacheMode.REPL_SYNC);
cache1.put("/a/b/c", "test", new ContainerData());
// We should not come here.
assertNotNull("NonSerializableData should not be null on cache2", cache2.get("/a/b/c", "test"));
}
catch (RuntimeException runtime)
{
Throwable t = runtime.getCause();
if (t instanceof NotSerializableException)
{
System.out.println("received NotSerializableException - as expected");
}
else
{
throw runtime;
}
}
}
public void testNonSerializableReplWithTx() throws Exception
{
TransactionManager tm;
try
{
initCaches(Configuration.CacheMode.REPL_SYNC);
tm = beginTransaction();
cache1.put("/a/b/c", "test", new ContainerData());
tm.commit();
// We should not come here.
assertNotNull("NonSerializableData should not be null on cache2", cache2.get("/a/b/c", "test"));
}
catch (RollbackException rollback)
{
System.out.println("received RollbackException - as expected");
}
catch (Exception e)
{
// We should also examine that it is indeed throwing a NonSerilaizable exception.
fail(e.toString());
}
}
static class NonSerializabeData
{
int i;
}
static class ContainerData implements Serializable
{
int i;
NonSerializabeData non_serializable_data;
private static final long serialVersionUID = -8322197791060897247L;
public ContainerData()
{
i = 99;
non_serializable_data = new NonSerializabeData();
}
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/replicated/ExceptionTest.java 0000644 0001750 0001750 00000006251 11017455042 030214 0 ustar twerner twerner package org.jboss.cache.replicated;
import org.jboss.cache.Cache;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import org.jboss.cache.lock.TimeoutException;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
/**
* Tests the type of exceptions thrown for Lock Acquisition Timeouts versus Sync Repl Timeouts
*
* @author Manik Surtani
* @since 2.1.0
*/
@Test(groups = {"functional"})
public class ExceptionTest
{
private Cache cache1;
private Cache cache2;
private Fqn fqn = Fqn.fromString("/a");
@BeforeMethod
public void setUp()
{
cache1 = new DefaultCacheFactory().createCache(false);
cache2 = new DefaultCacheFactory().createCache(false);
cache1.getConfiguration().setSyncCommitPhase(true);
cache1.getConfiguration().setSyncRollbackPhase(true);
cache1.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache2.getConfiguration().setSyncCommitPhase(true);
cache2.getConfiguration().setSyncRollbackPhase(true);
cache2.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
cache2.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
}
@AfterMethod
public void tearDown()
{
if (cache1 != null) cache1.stop();
if (cache2 != null) cache2.stop();
}
@Test(groups = {"functional"}, expectedExceptions = {TimeoutException.class})
public void testSyncReplTimeout()
{
cache1.getConfiguration().setSyncReplTimeout(1); // 1ms. this is *bound* to fail.
cache2.getConfiguration().setSyncReplTimeout(1);
String s = UnitTestCacheConfigurationFactory.getClusterConfigFromFile(cache1.getConfiguration().getDefaultClusterConfig());
String newCfg = UnitTestCacheConfigurationFactory.injectDelay(s, 100, 100);
cache1.getConfiguration().setClusterConfig(newCfg);
cache2.getConfiguration().setClusterConfig(newCfg);
cache1.start();
cache2.start();
TestingUtil.blockUntilViewsReceived(60000, cache1, cache2);
cache1.put(fqn, "k", "v");
}
@Test(groups = {"functional"}, expectedExceptions = {TimeoutException.class})
public void testLockAcquisitionTimeout() throws Exception
{
cache2.getConfiguration().setLockAcquisitionTimeout(1);
cache1.start();
cache2.start();
TestingUtil.blockUntilViewsReceived(10000, cache1, cache2);
// get a lock on cache 2 and hold on to it.
TransactionManager tm = cache2.getConfiguration().getRuntimeConfig().getTransactionManager();
tm.begin();
cache2.put(fqn, "block", "block");
Transaction t = tm.suspend();
cache1.put(fqn, "k", "v");
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/replicated/SyncCacheListenerTest.java 0000644 0001750 0001750 00000017711 11000260265 031620 0 ustar twerner twerner /*
*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.replicated;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.CacheException;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.notifications.annotation.CacheListener;
import org.jboss.cache.notifications.annotation.NodeModified;
import org.jboss.cache.notifications.annotation.NodeRemoved;
import org.jboss.cache.notifications.event.NodeEvent;
import org.jboss.cache.transaction.DummyTransactionManager;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.naming.Context;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Test out the TreeCacheListener
*
* @version $Revision: 5546 $
*/
@Test(groups = {"functional"})
public class SyncCacheListenerTest
{
private CacheSPI cache1, cache2;
private final static Log log_ = LogFactory.getLog(SyncCacheListenerTest.class);
private String old_factory = null;
private final static String FACTORY = "org.jboss.cache.transaction.DummyContextFactory";
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
System.out.println("*** starting setUp()");
old_factory = System.getProperty(Context.INITIAL_CONTEXT_FACTORY);
System.setProperty(Context.INITIAL_CONTEXT_FACTORY, FACTORY);
initCaches();
System.out.println("*** finished setUp()");
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
System.out.println("*** starting tearDown()");
DummyTransactionManager.destroy();
destroyCaches();
if (old_factory != null)
{
System.setProperty(Context.INITIAL_CONTEXT_FACTORY, old_factory);
old_factory = null;
}
System.out.println("*** finished tearDown()");
}
private void initCaches()
{
cache1 = (CacheSPI) new DefaultCacheFactory().createCache(false);
cache2 = (CacheSPI) new DefaultCacheFactory().createCache(false);
cache1.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
cache2.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache2.getConfiguration().setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache1.getConfiguration().setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
cache2.getConfiguration().setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
/*
cache1.setTransactionManagerLookupClass("org.jboss.cache.transaction.GenericTransactionManagerLookup");
cache2.setTransactionManagerLookupClass("org.jboss.cache.transaction.GenericTransactionManagerLookup");
*/
cache1.getConfiguration().setLockAcquisitionTimeout(5000);
cache2.getConfiguration().setLockAcquisitionTimeout(5000);
cache1.start();
cache2.start();
}
private void destroyCaches()
{
if (cache1 != null)
{
cache1.stop();
}
if (cache2 != null)
{
cache2.stop();
}
}
public void testSyncTxRepl() throws Exception
{
Integer age;
TransactionManager tm = cache1.getTransactionManager();
tm.begin();
Transaction tx = tm.getTransaction();
Listener lis = new Listener();
cache1.getNotifier().addCacheListener(lis);
lis.put("/a/b/c", "age", 38);
tm.suspend();
assertNull("age on cache2 must be null as the TX has not yet been committed", cache2.get("/a/b/c", "age"));
tm.resume(tx);
tm.commit();
// value on cache2 must be 38
age = (Integer) cache2.get("/a/b/c", "age");
assertNotNull("\"age\" obtained from cache2 must be non-null ", age);
assertTrue("\"age\" must be 38", age == 38);
}
public void testRemoteCacheListener() throws Exception
{
Integer age;
RemoteListener lis = new RemoteListener();
cache2.getNotifier().addCacheListener(lis);
cache1.put("/a/b/c", "age", 38);
// value on cache2 must be 38
age = (Integer) cache2.get("/a/b/c", "age");
assertNotNull("\"age\" obtained from cache2 must be non-null ", age);
assertTrue("\"age\" must be 38", age == 38);
cache1.remove("/a/b/c", "age");
}
public void testSyncRepl() throws Exception
{
Integer age;
Listener lis = new Listener();
cache1.addCacheListener(lis);
lis.put("/a/b/c", "age", 38);
// value on cache2 must be 38
age = (Integer) cache2.get("/a/b/c", "age");
assertNotNull("\"age\" obtained from cache2 must be non-null ", age);
assertTrue("\"age\" must be 38", age == 38);
}
public void testSyncTxReplMap() throws Exception
{
Integer age;
TransactionManager tm = cache1.getConfiguration().getRuntimeConfig().getTransactionManager();
tm.begin();
Transaction tx = tm.getTransaction();
Listener lis = new Listener();
cache1.getNotifier().addCacheListener(lis);
Map map = new HashMap();
map.put("age", 38);
map.put("name", "Ben");
lis.put("/a/b/c", map);
tm.suspend();
assertNull("age on cache2 must be null as the TX has not yet been committed", cache2.get("/a/b/c", "age"));
tm.resume(tx);
tm.commit();
// value on cache2 must be 38
age = (Integer) cache2.get("/a/b/c", "age");
assertNotNull("\"age\" obtained from cache2 must be non-null ", age);
assertTrue("\"age\" must be 38", age == 38);
}
public void testSyncReplMap() throws Exception
{
Integer age;
Listener lis = new Listener();
cache1.getNotifier().addCacheListener(lis);
Map map = new HashMap();
map.put("age", 38);
map.put("name", "Ben");
lis.put("/a/b/c", map);
// value on cache2 must be 38
age = (Integer) cache2.get("/a/b/c", "age");
assertNotNull("\"age\" obtained from cache2 must be non-null ", age);
assertTrue("\"age\" must be 38", age == 38);
}
@CacheListener
public class Listener
{
Object key_ = null;
public void put(String fqn, Object key, Object val)
{
key_ = key;
cache1.put(fqn, key, val);
}
public void put(String fqn, Map map)
{
if (map.size() == 0)
fail("put(): map size can't be 0");
Set set = map.keySet();
key_ = set.iterator().next();// take anyone
cache1.put(fqn, map);
}
@NodeModified
public void nodeModified(NodeEvent ne)
{
if (!ne.isPre())
{
log_.debug("nodeModified visited with fqn: " + ne.getFqn());
try
{
// test out if we can get the read lock since there is a write lock going as well.
cache1.get(ne.getFqn(), key_);
}
catch (CacheException e)
{
e.printStackTrace();//To change body of catch statement use File | Settings | File Templates.
fail("nodeModified: test failed with exception: " + e);
}
}
}
}
@CacheListener
public class RemoteListener
{
@NodeRemoved
@NodeModified
public void callback(NodeEvent e)
{
System.out.println("Callback got event " + e);
log_.debug("Callback got event " + e);
assertFalse("node was removed on remote cache so isLocal should be false", e.isOriginLocal());
}
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/ 0000755 0001750 0001750 00000000000 11376173757 024260 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/MarshalledValueTest.java 0000644 0001750 0001750 00000031613 11017455042 031016 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.CacheException;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.InvocationContext;
import org.jboss.cache.NodeSPI;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.commands.write.PutDataMapCommand;
import org.jboss.cache.commands.write.PutKeyValueCommand;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.ComponentRegistry;
import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import org.jboss.cache.interceptors.MarshalledValueInterceptor;
import org.jboss.cache.interceptors.base.CommandInterceptor;
import org.jboss.cache.invocation.CacheInvocationDelegate;
import org.jboss.cache.loader.DummyInMemoryCacheLoader;
import org.jboss.cache.notifications.annotation.CacheListener;
import org.jboss.cache.notifications.annotation.NodeModified;
import org.jboss.cache.notifications.event.NodeModifiedEvent;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.Map;
/**
* Tests implicit marshalled values
*
* @author Manik Surtani (manik@jboss.org)
* @since 2.1.0
*/
@Test(groups = "functional")
public class MarshalledValueTest
{
private CacheSPI cache1, cache2;
private MarshalledValueListenerInterceptor mvli;
@BeforeMethod
public void setUp() throws CloneNotSupportedException
{
cache1 = (CacheSPI) new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(Configuration.CacheMode.REPL_SYNC, false), false);
if (cache1.getConfiguration().getBuddyReplicationConfig() != null)
cache1.getConfiguration().setBuddyReplicationConfig(null);
cache1.getConfiguration().setUseLazyDeserialization(true);
cache2 = (CacheSPI) new DefaultCacheFactory().createCache(cache1.getConfiguration().clone(), false);
cache1.start();
cache2.start();
assert TestingUtil.findInterceptor(cache1, MarshalledValueInterceptor.class) != null : "Marshalled value interceptor not in chain!";
assert TestingUtil.findInterceptor(cache2, MarshalledValueInterceptor.class) != null : "Marshalled value interceptor not in chain!";
mvli = new MarshalledValueListenerInterceptor();
cache1.addInterceptor(mvli, MarshalledValueInterceptor.class);
}
@AfterMethod
public void tearDown()
{
TestingUtil.killCaches(cache1, cache2);
Pojo.serializationCount = 0;
Pojo.deserializationCount = 0;
}
private void assertOnlyOneRepresentationExists(MarshalledValue mv)
{
assert (mv.instance != null && mv.raw == null) || (mv.instance == null && mv.raw != null) : "Only instance or raw representations should exist in a MarshalledValue; never both";
}
private void assertSerialized(MarshalledValue mv)
{
assert mv.raw != null : "Should be serialized";
}
private void assertDeserialized(MarshalledValue mv)
{
assert mv.instance != null : "Should be deserialized";
}
private void assertSerializationCounts(int serializationCount, int deserializationCount)
{
assert Pojo.serializationCount == serializationCount : "Serialization count: expected " + serializationCount + " but was " + Pojo.serializationCount;
assert Pojo.deserializationCount == deserializationCount : "Deserialization count: expected " + deserializationCount + " but was " + Pojo.deserializationCount;
}
public void testNonSerializable()
{
try
{
cache1.put("/a", "Hello", new Object());
assert false : "Should have failed";
}
catch (CacheException expected)
{
}
assert mvli.invocationCount == 0 : "Call should not have gone beyond the MarshalledValueInterceptor";
try
{
cache1.put("/a", new Object(), "Hello");
assert false : "Should have failed";
}
catch (CacheException expected)
{
}
assert mvli.invocationCount == 0 : "Call should not have gone beyond the MarshalledValueInterceptor";
}
public void testNodeReleaseObjectValueReferences()
{
Pojo value = new Pojo();
cache1.put("/a", "key", value);
assertSerializationCounts(1, 0);
NodeSPI node = cache1.getNode("/a");
Object o = node.getDirect("key");
assert o instanceof MarshalledValue;
MarshalledValue mv = (MarshalledValue) o;
assertDeserialized(mv);
assert node.get("key").equals(value);
assertDeserialized(mv);
assertSerializationCounts(1, 0);
node.releaseObjectReferences(false);
assertSerializationCounts(2, 0);
assertOnlyOneRepresentationExists(mv);
assertSerialized(mv);
// now on cache 2
node = cache2.getNode("/a");
o = node.getDirect("key");
assert o instanceof MarshalledValue;
mv = (MarshalledValue) o;
assertSerialized(mv); // this proves that unmarshalling on the recipient cache instance is lazy
assert node.get("key").equals(value);
assertDeserialized(mv);
assertSerializationCounts(2, 1);
node.releaseObjectReferences(false);
assertSerializationCounts(2, 1);
assertOnlyOneRepresentationExists(mv);
assertSerialized(mv);
}
public void testNodeReleaseObjectKeyReferences() throws IOException, ClassNotFoundException
{
Pojo key = new Pojo();
cache1.put("/a", key, "value");
assertSerializationCounts(1, 0);
NodeSPI node = cache1.getNode("/a");
Object o = node.getKeysDirect().iterator().next();
assert o instanceof MarshalledValue;
MarshalledValue mv = (MarshalledValue) o;
assertDeserialized(mv);
assert node.get(key).equals("value");
assertDeserialized(mv);
assertSerializationCounts(1, 0);
node.releaseObjectReferences(false);
assertSerializationCounts(2, 0);
assertOnlyOneRepresentationExists(mv);
assertSerialized(mv);
// now on cache 2
node = cache2.getNode("/a");
o = node.getKeysDirect().iterator().next();
assert o instanceof MarshalledValue;
mv = (MarshalledValue) o;
assertSerialized(mv);
assert node.get(key).equals("value");
assertSerializationCounts(2, 1);
assertDeserialized(mv);
node.releaseObjectReferences(false);
assertOnlyOneRepresentationExists(mv);
assertSerialized(mv);
assertSerializationCounts(2, 1);
}
public void testEqualsAndHashCode() throws Exception
{
Pojo pojo = new Pojo();
MarshalledValue mv = new MarshalledValue(pojo);
assertDeserialized(mv);
int oldHashCode = mv.hashCode();
mv.serialize();
assertSerialized(mv);
assert oldHashCode == mv.hashCode();
MarshalledValue mv2 = new MarshalledValue(pojo);
assertSerialized(mv);
assertDeserialized(mv2);
assert mv2.hashCode() == oldHashCode;
assert mv.equals(mv2);
}
public void assertUseOfMagicNumbers() throws Exception
{
Pojo pojo = new Pojo();
MarshalledValue mv = new MarshalledValue(pojo);
Configuration c = new Configuration();
ComponentRegistry cr = new ComponentRegistry(c, new CacheInvocationDelegate());
Marshaller marshaller = new CacheMarshaller210();
cr.registerComponent(marshaller, Marshaller.class);
// Wire the marshaller
cr.start();
// start the test
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
marshaller.objectToObjectStream(mv, out);
out.close();
bout.close();
// check that the rest just contains a byte stream which a MarshalledValue will be able to deserialize.
ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
ObjectInputStream in = new ObjectInputStream(bin);
assert in.read() == CacheMarshaller200.MAGICNUMBER_MARSHALLEDVALUE;
MarshalledValue recreated = new MarshalledValue();
recreated.readExternal(in);
// there should be nothing more
assert in.available() == 0;
in.close();
bin.close();
assertSerialized(recreated);
assert recreated.equals(mv);
// since both objects being compared are serialized, the equals() above should just compare byte arrays.
assertSerialized(recreated);
assertOnlyOneRepresentationExists(recreated);
}
public void testCacheLoaders() throws CloneNotSupportedException
{
tearDown();
cache1 = (CacheSPI) new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(Configuration.CacheMode.REPL_SYNC), false);
cache2 = (CacheSPI) new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(Configuration.CacheMode.REPL_SYNC), false);
CacheLoaderConfig clc = new CacheLoaderConfig();
CacheLoaderConfig.IndividualCacheLoaderConfig iclc = new CacheLoaderConfig.IndividualCacheLoaderConfig();
iclc.setClassName(DummyInMemoryCacheLoader.class.getName());
clc.addIndividualCacheLoaderConfig(iclc);
cache1.getConfiguration().setCacheLoaderConfig(clc);
cache2.getConfiguration().setCacheLoaderConfig(clc.clone());
cache1.getConfiguration().setUseLazyDeserialization(true);
cache2.getConfiguration().setUseLazyDeserialization(true);
cache1.start();
cache2.start();
TestingUtil.blockUntilViewsReceived(60000, cache1, cache2);
Pojo pojo = new Pojo();
cache1.put("/a", "key", pojo);
assertSerializationCounts(1, 0);
cache2.get("/a", "key");
assertSerializationCounts(1, 1);
}
public void testCallbackValues()
{
Listener l = new Listener();
cache1.addCacheListener(l);
Pojo pojo = new Pojo();
cache1.put("/a", "key", pojo);
assert l.modData.size() == 1;
assert l.modData.get("key") instanceof Pojo;
assertSerializationCounts(1, 0);
}
public void testRemoteCallbackValues()
{
Listener l = new Listener();
cache2.addCacheListener(l);
Pojo pojo = new Pojo();
cache1.put("/a", "key", pojo);
assert l.modData.size() == 1;
pojo = (Pojo) l.modData.get("key");
assert pojo != null;
assertSerializationCounts(1, 1);
}
@CacheListener
public static class Listener
{
Map modData;
@NodeModified
public void nodeModified(NodeModifiedEvent e)
{
if (!e.isPre()) modData = e.getData();
}
}
class MarshalledValueListenerInterceptor extends CommandInterceptor
{
int invocationCount = 0;
public Object visitPutDataMapCommand(InvocationContext ctx, PutDataMapCommand command) throws Throwable
{
invocationCount++;
Object retval = invokeNextInterceptor(ctx, command);
if (retval instanceof MarshalledValue) assertOnlyOneRepresentationExists((MarshalledValue) retval);
return retval;
}
public Object visitPutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand command) throws Throwable
{
invocationCount++;
if (command.getKey() instanceof MarshalledValue)
assertOnlyOneRepresentationExists((MarshalledValue) command.getKey());
if (command.getValue() instanceof MarshalledValue)
assertOnlyOneRepresentationExists((MarshalledValue) command.getValue());
Object retval = invokeNextInterceptor(ctx, command);
if (retval instanceof MarshalledValue) assertOnlyOneRepresentationExists((MarshalledValue) retval);
return retval;
}
}
public static class Pojo implements Externalizable
{
int i;
boolean b;
static int serializationCount, deserializationCount;
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pojo pojo = (Pojo) o;
if (b != pojo.b) return false;
if (i != pojo.i) return false;
return true;
}
public int hashCode()
{
int result;
result = i;
result = 31 * result + (b ? 1 : 0);
return result;
}
public void writeExternal(ObjectOutput out) throws IOException
{
out.writeInt(i);
out.writeBoolean(b);
serializationCount++;
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
i = in.readInt();
b = in.readBoolean();
deserializationCount++;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/AbstractVersionAwareMarshallerTest.java jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/AbstractVersionAwareMarshallerTest.j0000644 0001750 0001750 00000002102 11010626047 033346 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.CacheStatus;
import org.jboss.cache.RegionManager;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.ComponentRegistry;
/**
* @author Manik Surtani (manik@jboss.org)
* @since 2.1.0
*/
public abstract class AbstractVersionAwareMarshallerTest
{
protected ComponentRegistry cr;
protected VersionAwareMarshaller createVAMandRestartCache(String replVersion)
{
Configuration c = cr.getComponent(Configuration.class);
c.setReplVersionString(replVersion);
return createVAMandRestartCache(new RegionManager());
}
protected VersionAwareMarshaller createVAMandRestartCache(RegionManager rm)
{
if (cr.getState() == CacheStatus.STARTED) cr.stop();
cr.registerComponent(rm, RegionManager.class);
cr.create();
cr.rewire();
// force cache mode
VersionAwareMarshaller m = (VersionAwareMarshaller) cr.getComponent(Marshaller.class);
m.init();
m.initReplicationVersions();
return m;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/SyncReplTest.java 0000644 0001750 0001750 00000036330 11020007335 027475 0 ustar twerner twerner /*
*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import org.jboss.cache.marshall.data.Address;
import org.jboss.cache.marshall.data.Person;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.transaction.NotSupportedException;
import javax.transaction.SystemException;
import javax.transaction.TransactionManager;
import java.lang.reflect.Method;
import java.util.HashMap;
/**
* Test case for marshalling using Sync mode.
*
* @author Ben Wang
* @version $Revision: 5919 $
*/
@Test(groups = {"functional", "jgroups"})
public class SyncReplTest extends RegionBasedMarshallingTestBase
{
CacheSPI cache1, cache2;
String props = null;
Person ben_;
Address addr_;
Throwable ex_;
private Fqn aop = Fqn.fromString("/aop");
protected boolean useMarshalledValues = false;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
log("creating cache1");
cache1 = createCache("TestCache");
log("creating cache2");
cache2 = createCache("TestCache");
addr_ = new Address();
addr_.setCity("San Jose");
ben_ = new Person();
ben_.setName("Ben");
ben_.setAddress(addr_);
// Pause to give caches time to see each other
TestingUtil.blockUntilViewsReceived(new CacheSPI[]{cache1, cache2}, 60000);
}
private CacheSPI createCache(String name)
{
CacheSPI cache = (CacheSPI) new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(CacheMode.REPL_SYNC), false);
cache.getConfiguration().setClusterName(name);
// Use marshaller
cache.getConfiguration().setUseLazyDeserialization(useMarshalledValues);
cache.getConfiguration().setUseRegionBasedMarshalling(!useMarshalledValues);
cache.create();
cache.start();
return cache;
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
cache1.removeNode(Fqn.ROOT);
if (cache1 != null)
{
log("stopping cache1");
cache1.stop();
}
if (cache2 != null)
{
log("stopping cache2");
cache2.stop();
}
resetContextClassLoader();
}
public void testPlainPut() throws Exception
{
cache1.put(aop, "person", ben_);
Person ben2 = (Person) cache2.get(aop, "person");
assertNotNull("Person from 2nd cache should not be null ", ben2);
assertEquals(ben_.toString(), ben2.toString());
}
public void testCCE() throws Exception
{
ClassLoader c1 = getClassLoader();
ClassLoader c2 = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(c1);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(c2);
}
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(c1);
cache1.put(aop, "person", ben_);
if (useMarshalledValues) resetContextClassLoader();
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(getFailingClassLoader());
try
{
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(c2);
@SuppressWarnings("unused")
Person person = (Person) cache2.get(aop, "person");
}
catch (ClassCastException ex)
{
// That's ok.
return;
}
fail("Should have thrown an exception");
}
public void testPut() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
cache1.put(aop, "person", ben_);
Object ben2;
// Can't cast it to Person. CCE will result.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(aop, "person");
assertEquals(ben_.toString(), ben2.toString());
}
public void testCLSet() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
cache1.put(aop, "person", ben_);
Object ben2;
// Can't cast it to Person. CCE will result.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(aop, "person");
assertEquals(ben_.toString(), ben2.toString());
Class claz = clb.loadClass(ADDRESS_CLASSNAME);
Object add = claz.newInstance();
Method setValue = claz.getMethod("setCity", String.class);
setValue.invoke(add, "Sunnyvale");
Class clasz1 = clb.loadClass(PERSON_CLASSNAME);
setValue = clasz1.getMethod("setAddress", claz);
setValue.invoke(ben2, add);
}
/**
* Test replication with classloaders.
*
* @throws Exception
*/
public void testCLSet2() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
cache1.put(aop, "person", ben_);
Object ben2;
// Can't cast it to Person. CCE will result.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(aop, "person");
assertEquals(ben_.toString(), ben2.toString());
Class claz = clb.loadClass(ADDRESS_CLASSNAME);
Object add = claz.newInstance();
Method setValue = claz.getMethod("setCity", String.class);
setValue.invoke(add, "Sunnyvale");
Class clasz1 = clb.loadClass(PERSON_CLASSNAME);
setValue = clasz1.getMethod("setAddress", claz);
setValue.invoke(ben2, add);
// Set it back to the cache
// Can't cast it to Person. CCE will resutl.
cache2.put(aop, "person", ben2);
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
Object ben3 = cache1.get(aop, "person");
assertEquals(ben2.toString(), ben3.toString());
}
public void testPuts() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
// Create an empty Person loaded by this classloader
Object scopedBen1 = getPersonFromClassloader(cla);
// Create another empty Person loaded by this classloader
Object scopedBen2 = getPersonFromClassloader(clb);
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
cache1.put(Fqn.fromString("/aop/1"), "person", ben_);
cache1.put(Fqn.fromString("/aop/2"), "person", scopedBen1);
if (useMarshalledValues) resetContextClassLoader();
Object ben2;
// Can't cast it to Person. CCE will resutl.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(Fqn.fromString("/aop/1"), "person");
if (useMarshalledValues) resetContextClassLoader();
assertEquals(ben_.toString(), ben2.toString());
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(Fqn.fromString("/aop/2"), "person");
if (useMarshalledValues) resetContextClassLoader();
assertFalse("cache2 deserialized with scoped classloader", ben2 instanceof Person);
assertFalse("cache2 deserialized with cache2 classloader", scopedBen1.equals(ben2));
assertEquals("scopedBen deserialized properly", scopedBen2, ben2);
}
public void testMethodCall() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
cache1.put(Fqn.fromString("/aop/1"), "person", ben_);
cache1.remove(Fqn.fromString("/aop/1"), "person");
HashMap map = new HashMap();
map.put("1", "1");
map.put("2", "2");
cache1.put(Fqn.fromString("/aop/2"), map);
cache1.removeNode(Fqn.fromString("/aop/2"));
if (useMarshalledValues) resetContextClassLoader();
// TestingUtil.sleepThread(1000);
}
public void testTxMethodCall() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
TransactionManager tm = beginTransaction();
cache1.put(Fqn.fromString("/aop/1"), "person", ben_);
cache1.remove(Fqn.fromString("/aop/1"), "person");
HashMap map = new HashMap();
map.put("1", "1");
map.put("2", "2");
cache1.put(Fqn.fromString("/aop/2"), map);
cache1.removeNode(Fqn.fromString("/aop/2"));
tm.commit();
// TestingUtil.sleepThread(1000);
if (useMarshalledValues) resetContextClassLoader();
}
public void testTxCLSet2() throws Exception
{
ClassLoader cla = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
}
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
TransactionManager tm = beginTransaction();
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
cache1.put(aop, "person", ben_);
tm.commit();
if (useMarshalledValues) resetContextClassLoader();
Object ben2;
// Can't cast it to Person. CCE will resutl.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(aop, "person");
if (useMarshalledValues) resetContextClassLoader();
assertEquals(ben_.toString(), ben2.toString());
Class claz = clb.loadClass(ADDRESS_CLASSNAME);
Object add = claz.newInstance();
Method setValue = claz.getMethod("setCity", String.class);
setValue.invoke(add, "Sunnyvale");
Class clasz1 = clb.loadClass(PERSON_CLASSNAME);
setValue = clasz1.getMethod("setAddress", claz);
setValue.invoke(ben2, add);
// Set it back to the cache
// Can't cast it to Person. CCE will resutl.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
cache2.put(aop, "person", ben2);
if (useMarshalledValues) resetContextClassLoader();
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
Object ben3 = cache1.get(aop, "person");
if (useMarshalledValues) resetContextClassLoader();
assertEquals(ben2.toString(), ben3.toString());
}
public void testStateTransfer() throws Exception
{
// Need to test out if app is not registered with beforehand??
}
@SuppressWarnings("unchecked")
public void testCustomFqn() throws Exception
{
FooClassLoader cl1 = new FooClassLoader(Thread.currentThread().getContextClassLoader());
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cl1);
FooClassLoader cl2 = new FooClassLoader(Thread.currentThread().getContextClassLoader());
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(cl2);
Class clazz = cl1.loadFoo();
Object custom1 = clazz.newInstance();
clazz = cl2.loadFoo();
Object custom2 = clazz.newInstance();
cache1.put(Fqn.fromElements("aop", custom1), "key", "value");
try
{
Object val = cache2.get(Fqn.fromElements("aop", custom2), "key");
assertEquals("value", val);
}
catch (Exception ex)
{
fail("Test fails with exception " + ex);
}
}
private TransactionManager beginTransaction() throws SystemException, NotSupportedException
{
TransactionManager mgr = cache1.getConfiguration().getRuntimeConfig().getTransactionManager();
mgr.begin();
return mgr;
}
protected Object getPersonFromClassloader(ClassLoader cl) throws Exception
{
Class clazz = cl.loadClass(PERSON_CLASSNAME);
return clazz.newInstance();
}
private void log(String msg)
{
System.out.println("-- [" + Thread.currentThread() + "]: " + msg);
}
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/ReturnValueMarshallingMarshalledValuesTest.java jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/ReturnValueMarshallingMarshalledValu0000644 0001750 0001750 00000000634 10745240616 033455 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.testng.annotations.Test;
/**
* @author Manik Surtani (manik@jboss.org)
* @since 2.1.0
*/
@Test(groups = {"functional", "jgroups"})
public class ReturnValueMarshallingMarshalledValuesTest extends ReturnValueMarshallingTest
{
public ReturnValueMarshallingMarshalledValuesTest()
{
useMarshalledValues = true;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/data/ 0000755 0001750 0001750 00000000000 11376173757 025171 5 ustar twerner twerner jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/data/Debug.java 0000644 0001750 0001750 00000006217 11031017377 027047 0 ustar twerner twerner package org.jboss.cache.marshall.data;
import java.lang.reflect.Method;
import java.net.URL;
import java.security.CodeSource;
import java.security.ProtectionDomain;
/**
* Various debugging utility methods available for use in unit tests
*
* @author Scott.Stark@jboss.org
*/
public class Debug
{
/**
* Format a string buffer containing the Class, Interfaces, CodeSource,
* and ClassLoader information for the given object clazz.
*
* @param clazz the Class
* @param results the buffer to write the info to
*/
public static void displayClassInfo(Class clazz, StringBuilder results)
{
displayClassInfo(clazz, results, true);
}
@SuppressWarnings("null")
public static void displayClassInfo(Class clazz, StringBuilder results,
boolean showParentClassLoaders)
{
ClassLoader cl = clazz.getClassLoader();
results.append("\n" + clazz.getName() + "(" + Integer.toHexString(clazz.hashCode()) + ").ClassLoader=" + cl);
ClassLoader parent = cl;
while (parent != null)
{
results.append("\n.." + parent);
URL[] urls = getClassLoaderURLs(parent);
int length = urls != null ? urls.length : 0;
for (int u = 0; u < length; u++)
{
results.append("\n...." + urls[u]);
}
if (showParentClassLoaders == false)
{
break;
}
parent = parent.getParent();
}
CodeSource clazzCS = clazz.getProtectionDomain().getCodeSource();
if (clazzCS != null)
{
results.append("\n++++CodeSource: " + clazzCS);
}
else
{
results.append("\n++++Null CodeSource");
}
results.append("\nImplemented Interfaces:");
Class[] ifaces = clazz.getInterfaces();
for (int i = 0; i < ifaces.length; i++)
{
Class iface = ifaces[i];
results.append("\n++" + iface + "(" + Integer.toHexString(iface.hashCode()) + ")");
ClassLoader loader = ifaces[i].getClassLoader();
results.append("\n++++ClassLoader: " + loader);
ProtectionDomain pd = ifaces[i].getProtectionDomain();
CodeSource cs = pd.getCodeSource();
if (cs != null)
{
results.append("\n++++CodeSource: " + cs);
}
else
{
results.append("\n++++Null CodeSource");
}
}
}
/**
* Use reflection to access a URL[] getURLs or ULR[] getAllURLs method so
* that non-URLClassLoader class loaders, or class loaders that override
* getURLs to return null or empty, can provide the true classpath info.
*/
public static URL[] getClassLoaderURLs(ClassLoader cl)
{
URL[] urls = {};
try
{
Class returnType = urls.getClass();
Class[] parameterTypes = {};
Method getURLs = cl.getClass().getMethod("getURLs", parameterTypes);
if (returnType.isAssignableFrom(getURLs.getReturnType()))
{
Object[] args = {};
urls = (URL[]) getURLs.invoke(cl, args);
}
}
catch (Exception ignore)
{
}
return urls;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/data/Address.java 0000644 0001750 0001750 00000003340 10727545014 027405 0 ustar twerner twerner /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall.data;
import java.io.Serializable;
/**
*/
public class Address implements Serializable
{
private static final long serialVersionUID = 5943073369866339615L;
String street = null;
String city = "San Jose";
int zip = 0;
public String getStreet()
{
return street;
}
public void setStreet(String street)
{
this.street = street;
}
public String getCity()
{
// System.out.println("********* getting city of " +city);
return city;
}
public void setCity(String city)
{
// System.out.println("********* setting city of " +city);
this.city = city;
}
public int getZip()
{
return zip;
}
public void setZip(int zip)
{
this.zip = zip;
}
public String toString()
{
return "street=" + getStreet() + ", city=" + getCity() + ", zip=" + getZip();
}
// public Object writeReplace() {
// return this;
// }
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final Address address = (Address) o;
if (zip != address.zip) return false;
if (city != null ? !city.equals(address.city) : address.city != null) return false;
if (street != null ? !street.equals(address.street) : address.street != null) return false;
return true;
}
public int hashCode()
{
int result;
result = (street != null ? street.hashCode() : 0);
result = 29 * result + (city != null ? city.hashCode() : 0);
result = 29 * result + zip;
return result;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/data/Person.java 0000644 0001750 0001750 00000002731 11031017377 027264 0 ustar twerner twerner /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall.data;
import java.io.Serializable;
public class Person implements Serializable
{
private static final long serialVersionUID = -885384294556845285L;
String name = null;
Address address;
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public void setName(Object obj)
{
this.name = (String) obj;
}
public Address getAddress()
{
return address;
}
public void setAddress(Address address)
{
this.address = address;
}
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("name=").append(getName()).append(" Address= ").append(address);
return sb.toString();
}
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final Person person = (Person) o;
if (address != null ? !address.equals(person.address) : person.address != null) return false;
if (name != null ? !name.equals(person.name) : person.name != null) return false;
return true;
}
public int hashCode()
{
int result;
result = (name != null ? name.hashCode() : 0);
result = 29 * result + (address != null ? address.hashCode() : 0);
return result;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/Foo.notjava 0000644 0001750 0001750 00000001665 10535375655 026374 0 ustar twerner twerner package org.jboss.cache.marshall;
import java.io.Serializable;
import java.security.SecureRandom;
import java.util.Random;
/**
* This is the java code used to create the Foo.clazz file. File deliberately
* doesn't end in .java, as we don't want a Foo.class on the classpath,
* only the Foo.clazz file that FooClassLoader can load.
*
* @author Brian Stansberry
* @version $Revision: 3095 $
*/
public class Foo implements Serializable
{
/** The serialVersionUID */
private static final long serialVersionUID = 1L;
public boolean equals(Object obj)
{
return obj instanceof Foo;
}
public int hashCode()
{
return 1;
}
public String toString()
{
Random random = new SecureRandom();
StringBuffer sb=new StringBuffer("org.jboss.cache.marshall.Foo[random=");
sb.append(random.nextInt()).append("]");
return sb.toString();
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/RedeploymentEmulationTest.java 0000644 0001750 0001750 00000012105 10732232543 032267 0 ustar twerner twerner /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.Cache;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.config.Configuration;
import org.jgroups.Global;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
/**
* Unit test demonstrating usability of marshalling for application redeployment in application server.
*
* @author Galder Zamarreno
*/
@Test(groups = {"functional"}, enabled = false)
// this relies on an old project structure that no longer exists
public class RedeploymentEmulationTest
{
private Cache cache;
private static final String INSTANCE_LIBRARY = "jgroups-all.jar";
private static final String INSTANCE_CLASS_NAME = "org.jgroups.Global";
private static final String USER_DIR = ".";//System.getProperty("user.dir");
private static final String FILE_SEPARATOR = File.separator;//System.getProperty("file.separator");
private static final String LIB_DIR_NAME = "lib";
private static final String LIB_DIR = USER_DIR + FILE_SEPARATOR + LIB_DIR_NAME + FILE_SEPARATOR;
private static final String LIB_DIR_SP = System.getProperty("lib.dir");//"lib";
private static final Log log = LogFactory.getLog(RedeploymentEmulationTest.class);
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
cache = new DefaultCacheFactory().createCache(false);
cache.getConfiguration().setCacheMode(Configuration.CacheMode.LOCAL);
cache.getConfiguration().setUseRegionBasedMarshalling(true);
}
@AfterMethod(alwaysRun = true)
public void tearDown()
{
log.info("**** IN TEAR DOWN ***");
cache.stop();
}
public void testClassCastException() throws Exception
{
cache.start();
URLClassLoader ucl1 = createOrphanClassLoader();
Thread.currentThread().setContextClassLoader(ucl1);
Class clazz1 = ucl1.loadClass(INSTANCE_CLASS_NAME);
cache.put(fqn("/a"), "key", clazz1.newInstance());
Thread.currentThread().setContextClassLoader(ClassLoader.getSystemClassLoader());
try
{
@SuppressWarnings("unused")
Global object = (Global) cache.get(fqn("/a"), "key");
fail("Should have produced a ClassCastException");
}
catch (ClassCastException cce)
{
System.out.println("Expecting: " + INSTANCE_CLASS_NAME);
System.out.println("Got: " + cce.getMessage());
assertTrue(cce.getMessage().startsWith(INSTANCE_CLASS_NAME));
}
}
public void testRegisterUnregister() throws Exception
{
cache.start();
URLClassLoader ucl1 = createOrphanClassLoader();
Thread.currentThread().setContextClassLoader(ucl1);
Region region = cache.getRegion(fqn("/"), true);
region.registerContextClassLoader(Thread.currentThread().getContextClassLoader());
region.activate();
Class clazz1 = ucl1.loadClass(INSTANCE_CLASS_NAME);
cache.put(fqn("/a"), "key", clazz1.newInstance());
region.deactivate();
region.unregisterContextClassLoader();
Thread.currentThread().setContextClassLoader(ClassLoader.getSystemClassLoader());
region.registerContextClassLoader(Thread.currentThread().getContextClassLoader());
try
{
Global object = (Global) cache.get(fqn("/a"), "key");
assertNull(object);
}
catch (ClassCastException cce)
{
// cce.printStackTrace();
fail("Should not have produced a ClassCastException");
}
region.deactivate();
region.unregisterContextClassLoader();
}
@SuppressWarnings("deprecation")
private URLClassLoader createOrphanClassLoader() throws MalformedURLException
{
File f;
if (LIB_DIR_SP == null)
{
/* lib.dir system property is null, so we assume this test is being run
* inside an IDE, where the user dir is the root of JBossCache. We know
* JGroups lib is located in lib/jgroups.jar */
f = new File(USER_DIR + FILE_SEPARATOR + LIB_DIR + FILE_SEPARATOR);
}
else
{
/* lib.dir is set, so we assume that you are running from the build.xml
* which means that the user dir might be a completely different one. lib.dir
* system property allows us to know where the lib directory is independently
* of the user dir*/
f = new File(LIB_DIR_SP);
}
URL context = f.toURL();
URL jar = new URL(context, INSTANCE_LIBRARY);
URLClassLoader ucl1 = new URLClassLoader(new URL[]{jar}, null);
return ucl1;
}
private static Fqn fqn(String fqn)
{
return Fqn.fromString(fqn);
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/CacheMarshallerTestBase.java 0000644 0001750 0001750 00000017124 11015045001 031543 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall;
import org.jboss.cache.Fqn;
import org.jboss.cache.RegionManager;
import org.jboss.cache.commands.ReplicableCommand;
import org.jboss.cache.commands.remote.ReplicateCommand;
import org.jboss.cache.commands.write.PutKeyValueCommand;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.ComponentRegistry;
import org.jboss.cache.invocation.CacheInvocationDelegate;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.List;
@Test(groups = "functional")
public abstract class CacheMarshallerTestBase extends AbstractVersionAwareMarshallerTest
{
protected String currentVersion;
protected int currentVersionShort;
protected Class expectedMarshallerClass, latestMarshallerClass = CacheMarshaller210.class;
protected VersionAwareMarshaller marshaller;
protected RegionManager regionManager;
protected Configuration c;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
c = new Configuration();
c.setUseRegionBasedMarshalling(false);
c.setInactiveOnStartup(false);
c.setReplVersionString(currentVersion);
cr = new ComponentRegistry(c, new CacheInvocationDelegate());
marshaller = createVAMandRestartCache(new RegionManager());
regionManager = cr.getComponent(RegionManager.class);
}
@AfterMethod(alwaysRun = true)
public void tearDown()
{
marshaller = null;
}
protected void assertObjectArraysAreEqual(Object[] a1, Object[] a2)
{
assertEquals("Number of args should match", a1.length, a2.length);
for (int i = 0; i < a1.length; i++)
{
if (a1[i] instanceof List && a2[i] instanceof List)
{
Object[] a1Elements = ((List) a1[i]).toArray();
Object[] a2Elements = ((List) a2[i]).toArray();
assertObjectArraysAreEqual(a1Elements, a2Elements);
}
else
{
assertEquals("Argument # " + i + " should be equal", a1[i], a2[i]);
}
}
}
public void testGetMarshaller()
{
assertEquals("Only one marshaller should be in the map by this stage", 1, marshaller.marshallers.size());
assertEquals(expectedMarshallerClass, marshaller.getMarshaller(currentVersionShort).getClass());
// defaultMarshaller is used for outgoing streams
assert marshaller.defaultMarshaller.getClass().equals(expectedMarshallerClass);
assertEquals(latestMarshallerClass, marshaller.getMarshaller(15).getClass());
assertEquals(latestMarshallerClass, marshaller.getMarshaller(1).getClass());
assertEquals(latestMarshallerClass, marshaller.getMarshaller(-1).getClass());
assertEquals(latestMarshallerClass, marshaller.getMarshaller(0).getClass());
assertEquals(CacheMarshaller200.class, marshaller.getMarshaller(20).getClass());
assertEquals(CacheMarshaller210.class, marshaller.getMarshaller(21).getClass());
assert marshaller.marshallers.size() == 2 : "Should have 2 marshallers now";
}
public void testStringBasedFqn() throws Exception
{
Fqn fqn = Fqn.fromElements("JSESSIONID", "1010.10.5:3000", "1234567890", "1");
byte[] asBytes = marshaller.objectToByteBuffer(fqn);
System.out.println("Marshalled to " + asBytes.length + " bytes");
Object o2 = marshaller.objectFromByteBuffer(asBytes);
assertEquals(fqn, o2);
}
public void testNonStringBasedFqn() throws Exception
{
Fqn fqn = Fqn.fromElements(3, false);
byte[] asBytes = marshaller.objectToByteBuffer(fqn);
Object o2 = marshaller.objectFromByteBuffer(asBytes);
assertEquals(fqn, o2);
}
public void testMethodCall() throws Exception
{
Fqn fqn = Fqn.fromElements(3, false);
ReplicableCommand cmd = new PutKeyValueCommand(null, fqn, "key", "value");
byte[] asBytes = marshaller.objectToByteBuffer(cmd);
Object o2 = marshaller.objectFromByteBuffer(asBytes);
assertTrue("Unmarshalled object should be a method call", o2 instanceof ReplicableCommand);
ReplicableCommand cmd2 = (ReplicableCommand) o2;
assertEquals(cmd, cmd2);
}
public void testNestedMethodCall() throws Exception
{
Fqn fqn = Fqn.fromElements(3, false);
ReplicableCommand cmd = new PutKeyValueCommand(null, fqn, "key", "value");
ReplicableCommand replicateCmd = new ReplicateCommand(cmd);
byte[] asBytes = marshaller.objectToByteBuffer(replicateCmd);
Object o2 = marshaller.objectFromByteBuffer(asBytes);
assertTrue("Unmarshalled object should be a method call", o2 instanceof ReplicableCommand);
ReplicableCommand cmd2 = (ReplicableCommand) o2;
assertEquals(replicateCmd, cmd2);
}
public void testLargeString() throws Exception
{
doLargeStringTest(32767, false);
}
public void testLargerString() throws Exception
{
doLargeStringTest(32768, false);
}
public void test64KString() throws Exception
{
doLargeStringTest((2 << 15) - 10, false);
doLargeStringTest((2 << 15) + 10, false);
}
public void test128KString() throws Exception
{
doLargeStringTest((2 << 16) - 10, false);
doLargeStringTest((2 << 16) + 10, false);
}
public void testLargeStringMultiByte() throws Exception
{
doLargeStringTest(32767, true);
}
public void testLargerStringMultiByte() throws Exception
{
doLargeStringTest(32768, true);
}
public void test64KStringMultiByte() throws Exception
{
doLargeStringTest((2 << 15) - 10, true);
doLargeStringTest((2 << 15) + 10, true);
}
public void test128KStringMultiByte() throws Exception
{
doLargeStringTest((2 << 16) - 10, true);
doLargeStringTest((2 << 16) + 10, true);
}
protected void doLargeStringTest(int stringSize, boolean multiByteChars) throws Exception
{
StringBuilder sb = new StringBuilder();
int startingChar = multiByteChars ? 210 : 65;
for (int i = 0; i < stringSize; i++) sb.append((char) (startingChar + (i % 26)));
String largeString = sb.toString();
assertEquals(stringSize, largeString.length());
byte[] buf = marshaller.objectToByteBuffer(largeString);
assertEquals(largeString, marshaller.objectFromByteBuffer(buf));
}
public void testReplicationQueue() throws Exception
{
doReplicationQueueTest();
}
public void testReplicationQueueWithRegionBasedMarshalling() throws Exception
{
c.setUseRegionBasedMarshalling(true);
marshaller.init();
doReplicationQueueTest();
}
protected void doReplicationQueueTest() throws Exception
{
// replication queue takes a list of replicate() MethodCalls and wraps them in a single replicate call.
List calls = new ArrayList();
Fqn f = Fqn.fromElements("BlahBlah", 3, false);
String k = "key", v = "value";
ReplicableCommand cmd = new PutKeyValueCommand(null, f, k, v);
ReplicableCommand replCmd = new ReplicateCommand(cmd);
calls.add(replCmd);
cmd = new PutKeyValueCommand(null, f, k, v);
replCmd = new ReplicateCommand(cmd);
calls.add(replCmd);
ReplicableCommand replAllCmd = new ReplicateCommand(calls);
byte[] buf = marshaller.objectToByteBuffer(replAllCmd);
assertEquals(replAllCmd, marshaller.objectFromByteBuffer(buf));
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/RegionManagerTest.java 0000644 0001750 0001750 00000015257 11017455042 030471 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.RegionManager;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.config.Configuration;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
/**
* Test on ERegionManager class, from a marshalling perspective.
*/
@Test(groups = {"functional"})
public class RegionManagerTest
{
private final Fqn DEFAULT_REGION = Fqn.ROOT;
private RegionManager r;
private Configuration c;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
CacheSPI cache = (CacheSPI) new DefaultCacheFactory().createCache();
r = cache.getRegionManager();
c = cache.getConfiguration();
}
@AfterMethod(alwaysRun = false)
public void tearDown() throws Exception
{
TestingUtil.killCaches(r.getCache());
r = null;
}
public void testGetAllMarshallingRegions()
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b");
Fqn fqn3 = Fqn.fromString("/aop");
List expected = new ArrayList(4);
Region region = r.getRegion(DEFAULT_REGION, true);
region.registerContextClassLoader(getClass().getClassLoader());
assertEquals(DEFAULT_REGION, region.getFqn());
expected.add(region);
region = r.getRegion(fqn1, true);
region.registerContextClassLoader(getClass().getClassLoader());
assertEquals(fqn1, region.getFqn());
expected.add(region);
region = r.getRegion(fqn2, true);
region.registerContextClassLoader(getClass().getClassLoader());
assertEquals(fqn2, region.getFqn());
expected.add(region);
region = r.getRegion(fqn3, true);
region.registerContextClassLoader(getClass().getClassLoader());
assertEquals(fqn3, region.getFqn());
expected.add(region);
// should sort these now ...
Collections.sort(expected);
Iterator expectedRegions = expected.iterator();
for (Region reg : r.getAllRegions(Region.Type.MARSHALLING))
{
assertSame("Unexpected region " + reg, expectedRegions.next(), reg);
}
assertFalse("Should not be expecting any more regions", expectedRegions.hasNext());
}
public void testNoDefaultRegion()
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/");
r.getRegion(fqn1, true);
r.getRegion(fqn2, true);
Region region = null;
try
{
region = r.getRegion("/a", false);
}
catch (Exception e)
{
fail("If we don't set the default region, it still should be ok!");
}
assertNull("Default region is not null!", region);
}
public void testGetParentRegion()
{
String fqn1 = "/a/b/c";
String fqn2 = "/a/b";
String fqn3 = "/a";
r.getRegion(fqn1, true);
r.getRegion(fqn3, true);
Region region = r.getRegion(fqn2, false);
assertEquals("Should be the same region as in " + fqn3, r.getRegion(fqn3, false), region);
}
public void testRemoveRegion()
{
String fqn1 = "/a";
String fqn2 = "/a/b";
String fqn3 = "/a/b/c";
Region r1 = r.getRegion(fqn1, true);
Region r2 = r.getRegion(fqn2, true);
Region r3 = r.getRegion(fqn3, true);
assertEquals("Expecting 3 regions", 3, r.getAllRegions(Region.Type.ANY).size());
// test that removal doesn't affect parent traversal.
assertEquals(r3, r.getRegion(fqn3, false));
r.removeRegion(Fqn.fromString(fqn3));
assertEquals("Expecting 2 regions", 2, r.getAllRegions(Region.Type.ANY).size());
// test that removal doesn't affect parent traversal.
assertEquals("Should have retrieved parent region", r2, r.getRegion(fqn3, false));
r.removeRegion(Fqn.fromString(fqn2));
assertEquals("Expecting 1 region", 1, r.getAllRegions(Region.Type.ANY).size());
// test that removal doesn't affect parent traversal.
assertEquals("Should have retrieved parent region", r1, r.getRegion(fqn3, false));
r.removeRegion(Fqn.fromString(fqn1));
assertEquals("Expecting 0 regions", 0, r.getAllRegions(Region.Type.ANY).size());
}
public void testGetRegionsMethods()
{
String f1 = "/a", f2 = "/b", f3 = "/c", f4 = "/d";
r.setDefaultInactive(true);
@SuppressWarnings("unused")
Region r1 = r.getRegion(f1, true), r2 = r.getRegion(f2, true), r3 = r.getRegion(f3, true), r4 = r.getRegion(f4, true);
assertEquals("4 regions should exist", 4, r.getAllRegions(Region.Type.ANY).size());
assertEquals("None of the regions should marshalling or active", 0, r.getAllRegions(Region.Type.MARSHALLING).size());
r3.registerContextClassLoader(getClass().getClassLoader());
r3.activate();
assertEquals("r3 should be marshalling and active", 1, r.getAllRegions(Region.Type.MARSHALLING).size());
assertSame("r3 should be marshalling and active", r3, r.getAllRegions(Region.Type.MARSHALLING).get(0));
r4.activate();// but don't se a class loader
assertEquals("r3 should be marshalling and active", 1, r.getAllRegions(Region.Type.MARSHALLING).size());
assertSame("r3 should be marshalling and active", r3, r.getAllRegions(Region.Type.MARSHALLING).get(0));
r2.registerContextClassLoader(getClass().getClassLoader());// but don't activate
assertEquals("r3 should be marshalling and active", 1, r.getAllRegions(Region.Type.MARSHALLING).size());
assertSame("r3 should be marshalling and active", r3, r.getAllRegions(Region.Type.MARSHALLING).get(0));
r2.activate();
assertEquals("r2 + r3 should be marshalling and active", 2, r.getAllRegions(Region.Type.MARSHALLING).size());
assertSame("r2 should be marshalling and active", r2, r.getAllRegions(Region.Type.MARSHALLING).get(0));
assertSame("r3 should be marshalling and active", r3, r.getAllRegions(Region.Type.MARSHALLING).get(1));
r4.registerContextClassLoader(getClass().getClassLoader());
assertEquals("r2 + r3 + r4 should be marshalling and active", 3, r.getAllRegions(Region.Type.MARSHALLING).size());
assertSame("r2 should be marshalling and active", r2, r.getAllRegions(Region.Type.MARSHALLING).get(0));
assertSame("r3 should be marshalling and active", r3, r.getAllRegions(Region.Type.MARSHALLING).get(1));
assertSame("r4 should be marshalling and active", r4, r.getAllRegions(Region.Type.MARSHALLING).get(2));
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/AsyncReplMarshalledValuesTest.java 0000644 0001750 0001750 00000000712 10745367774 033043 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.testng.annotations.Test;
/**
* @author Manik Surtani (manik@jboss.org)
* @since 2.1.0
*/
@Test(groups = {"functional", "jgroups"})
public class AsyncReplMarshalledValuesTest extends AsyncReplTest
{
public AsyncReplMarshalledValuesTest()
{
useMarshalledValues = true;
}
@Override
public void testCustomFqn()
{
// don't test this case
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/CacheMarshaller210Test.java 0000644 0001750 0001750 00000007155 11015045001 031176 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.Fqn;
import org.jboss.cache.commands.remote.ReplicateCommand;
import org.jboss.cache.commands.write.PutKeyValueCommand;
import static org.testng.AssertJUnit.assertEquals;
import org.testng.annotations.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Map;
@Test(groups = {"functional"})
public class CacheMarshaller210Test extends CacheMarshaller200Test
{
public CacheMarshaller210Test()
{
currentVersion = "2.1.0.GA";
currentVersionShort = 21;
expectedMarshallerClass = CacheMarshaller210.class;
}
protected void doMapTest(int size) throws Exception
{
Map map = createMap(size);
Fqn fqn = Fqn.fromString("/my/stuff");
String key = "key";
PutKeyValueCommand putCommand = new PutKeyValueCommand(null, fqn, key, map);
ReplicateCommand replicateCommand = new ReplicateCommand(putCommand);
byte[] buf = marshaller.objectToByteBuffer(replicateCommand);
assertEquals(replicateCommand, marshaller.objectFromByteBuffer(buf));
}
protected Map createMap(int size)
{
Map map = new HashMap(size);
for (int i = 0; i < size; i++) map.put("key-" + i, "value-" + i);
return map;
}
public void testLargeNumberOfObjectReferences() throws Exception
{
doMapTest(500000);
}
public void testVInts() throws IOException
{
CacheMarshaller210 cm210 = (CacheMarshaller210) marshaller.defaultMarshaller;
CacheMarshaller200 cm200 = (CacheMarshaller200) marshaller.getMarshaller(20);
int[] ints = {2, 100, 500, 12000, 20000, 500000, 2000000, Integer.MAX_VALUE};
for (int i : ints)
{
System.out.println("CM200: Number of bytes (i=" + i + ") : " + getAndTestSize(cm200, i));
System.out.println("CM210: Number of bytes (i=" + i + ") : " + getAndTestSize(cm210, i));
}
}
public void testVLongs() throws IOException
{
CacheMarshaller210 cm210 = (CacheMarshaller210) marshaller.defaultMarshaller;
CacheMarshaller200 cm200 = (CacheMarshaller200) marshaller.getMarshaller(20);
long[] ints = {2, 100, 500, 12000, 20000, 500000, 2000000, Integer.MAX_VALUE, (long) Integer.MAX_VALUE + 500000L, Long.MAX_VALUE};
for (long i : ints)
{
System.out.println("CM200: Number of bytes (i=" + i + ") : " + getAndTestSize(cm200, i));
System.out.println("CM210: Number of bytes (i=" + i + ") : " + getAndTestSize(cm210, i));
}
}
private int getAndTestSize(CacheMarshaller200 m, int i) throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
m.writeUnsignedInt(oos, i);
oos.flush();
oos.close();
baos.flush();
baos.close();
byte[] bytes = baos.toByteArray();
int byteL = bytes.length;
assert i == m.readUnsignedInt(new ObjectInputStream(new ByteArrayInputStream(bytes)));
return byteL;
}
private int getAndTestSize(CacheMarshaller200 m, long i) throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
m.writeUnsignedLong(oos, i);
oos.flush();
oos.close();
baos.flush();
baos.close();
byte[] bytes = baos.toByteArray();
int byteL = bytes.length;
assert i == m.readUnsignedLong(new ObjectInputStream(new ByteArrayInputStream(bytes)));
return byteL;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/CacheLoaderMarshallingTest.java 0000644 0001750 0001750 00000012637 11034466673 032301 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.Cache;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Node;
import org.jboss.cache.Region;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.CacheLoaderConfig.IndividualCacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.eviction.LRUConfiguration;
import org.jboss.cache.eviction.LRUPolicy;
import org.jboss.cache.loader.FileCacheLoaderConfig;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Tests marshalling/unmarshalling during cache loader operations involving types
* not visible to the cache's default classloader.
*
* @author Brian Stansberry
* @author Galder Zamarreno
* @since 2.1.0
*/
@Test(groups = "functional")
public class CacheLoaderMarshallingTest extends RegionBasedMarshallingTestBase
{
private static final String tmpDir = System.getProperty("java.io.tmpdir") + File.separatorChar + "CacheLoaderMarshallingTest";
private Cache cache;
private Fqn fqn = Fqn.fromString("/a");
@BeforeMethod(alwaysRun = true)
protected void setUp() throws Exception
{
originalClassLoader = Thread.currentThread().getContextClassLoader();
}
@AfterMethod(alwaysRun = true)
protected void tearDown()
{
resetContextClassLoader();
TestingUtil.killCaches(cache);
File f = new File(tmpDir);
if (f.exists())
if (!f.delete())
f.deleteOnExit();
}
public void testCacheLoaderMarshalling() throws Exception
{
cacheLoaderMarshallingTest(false);
}
public void testCacheLoaderRegionBasedMarshalling() throws Exception
{
cacheLoaderMarshallingTest(true);
}
public void testLoadNodesAtRootOfRegion() throws Exception
{
String rootRegionName = "/myregion";
String hereFqn = rootRegionName + "/here";
cache = createCache(true);
cache.start();
Region r = cache.getRegion(Fqn.fromString(rootRegionName), true);
r.registerContextClassLoader(Thread.currentThread().getContextClassLoader());
r.activate();
cache.put(rootRegionName, "a key", "a value");
cache.put(hereFqn, "another key", "another value");
r.deactivate();
r.unregisterContextClassLoader();
cache.stop();
cache.start();
r = cache.getRegion(Fqn.fromString(rootRegionName), true);
r.registerContextClassLoader(Thread.currentThread().getContextClassLoader());
r.activate();
Node rootRegionNode = cache.getNode(rootRegionName);
Node hereNode = cache.getNode(hereFqn);
assertNotNull(rootRegionNode);
assertNotNull(hereNode);
assertEquals(hereNode.get("another key"), "another value");
assertEquals(rootRegionNode.get("a key"), "a value");
}
private void cacheLoaderMarshallingTest(boolean useRegionBased) throws Exception
{
cache = createCache(useRegionBased);
cache.start();
FooClassLoader loader = new FooClassLoader(originalClassLoader);
if (useRegionBased)
{
Region r = cache.getRegion(Fqn.ROOT, true);
r.registerContextClassLoader(loader);
r.activate();
}
Class clazz = loader.loadFoo();
Object obj = clazz.newInstance();
Thread.currentThread().setContextClassLoader(loader);
cache.put(fqn, "key", obj);
this.resetContextClassLoader();
cache.evict(fqn);
Thread.currentThread().setContextClassLoader(loader);
assertEquals(obj, cache.get(fqn, "key"));
}
private Cache createCache(boolean useRegionBased)
{
Cache cache = new DefaultCacheFactory().createCache(false);
Configuration config = cache.getConfiguration();
config.setUseRegionBasedMarshalling(useRegionBased);
config.setInactiveOnStartup(useRegionBased);
EvictionConfig ec = new EvictionConfig();
ec.setDefaultEvictionPolicyClass(LRUPolicy.class.getName());
ec.setWakeupIntervalSeconds(1000); // a long time; really disabled
EvictionRegionConfig erc = new EvictionRegionConfig();
erc.setRegionFqn(Fqn.ROOT);
erc.setRegionName("_default_");
LRUConfiguration epc = new LRUConfiguration();
epc.setMaxNodes(1000);
epc.setTimeToLiveSeconds(1000);
erc.setEvictionPolicyConfig(epc);
List ercs = new ArrayList();
ercs.add(erc);
ec.setEvictionRegionConfigs(ercs);
config.setEvictionConfig(ec);
CacheLoaderConfig clc = new CacheLoaderConfig();
clc.setPassivation(true);
clc.setShared(false);
FileCacheLoaderConfig fclc = new FileCacheLoaderConfig();
fclc.setLocation(tmpDir);
clc.setIndividualCacheLoaderConfigs(Collections.singletonList(fclc));
config.setCacheLoaderConfig(clc);
return cache;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/ActiveInactiveTest.java 0000644 0001750 0001750 00000013251 11017455042 030641 0 ustar twerner twerner /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.RegionManager;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.commands.ReplicableCommand;
import org.jboss.cache.commands.remote.ReplicateCommand;
import org.jboss.cache.commands.write.PutKeyValueCommand;
import org.jboss.cache.config.Configuration;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Tests the "activate/deactivate" functionality of LegacyTreeCacheMarshaller.
*
* @author Brian Stansberry
* @version $Revision$
*/
@Test(groups = "functional")
public class ActiveInactiveTest extends AbstractVersionAwareMarshallerTest
{
RegionManager rman;
CacheSPI cache;
Configuration c;
Fqn A = Fqn.fromString("/a");
Fqn I = Fqn.fromString("/i");
Fqn A_B = Fqn.fromRelativeElements(A, "b");
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
cache = (CacheSPI) new DefaultCacheFactory().createCache(false);
c = cache.getConfiguration();
c.setUseRegionBasedMarshalling(true);
c.setFetchInMemoryState(false);
cache.start();
cr = TestingUtil.extractComponentRegistry(cache);
rman = TestingUtil.extractComponentRegistry(cache).getComponent(RegionManager.class);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
}
public void testDefaultActive() throws Exception
{
rman.setDefaultInactive(false);
assertFalse("Root is not active", rman.isInactive(Fqn.ROOT));
rman.deactivate(A);
assertFalse("Root is not active after inactivating subtree",
rman.isInactive(Fqn.ROOT));
rman.activate(A);
assertFalse("Root is not active after activating subtree",
rman.isInactive(Fqn.ROOT));
rman.activate(A_B);
rman.deactivate(Fqn.ROOT);
assertTrue("Root is active", rman.isInactive(Fqn.ROOT));
}
public void testDefaultInactive() throws Exception
{
rman.setDefaultInactive(true);
assertTrue("Root is not inactive", rman.isInactive(Fqn.ROOT));
rman.activate(A);
assertTrue("Root is not inactive after activating subtree",
rman.isInactive(Fqn.ROOT));
rman.deactivate(A);
assertTrue("Root is not inactive after inactivating subtree",
rman.isInactive(Fqn.ROOT));
rman.deactivate(A_B);
rman.activate(Fqn.ROOT);
assertFalse("Root is not active", rman.isInactive(Fqn.ROOT));
}
public void testActivate() throws Exception
{
rman.setDefaultInactive(false);
rman.activate(A);
assertFalse("/a is not active after activating",
rman.isInactive(A));
rman.deactivate(A);
rman.activate(A);
assertFalse("/a is not active after reactivating",
rman.isInactive(A));
rman.reset();
rman.setDefaultInactive(true);
rman.activate(I);
assertFalse("/i is not active after activating",
rman.isInactive(I));
assertFalse("/i/k is not active after activating /i",
rman.isInactive(Fqn.fromString("/i/k")));
rman.deactivate(I);
rman.activate(I);
assertFalse("/i is not active after reactivating",
rman.isInactive(I));
}
public void testInactivate() throws Exception
{
rman.setDefaultInactive(true);
rman.deactivate(I);
assertTrue("/i is not inactive after inactivating",
rman.isInactive(I));
rman.activate(I);
rman.deactivate(I);
assertTrue("/i is not inactive after re-inactivating",
rman.isInactive(I));
rman.reset();
rman.setDefaultInactive(false);
rman.deactivate(A);
assertTrue("/a is not inactive after inactivating",
rman.isInactive(A));
assertTrue("/a/b is not inactive after inactivating /a",
rman.isInactive(A_B));
rman.activate(A);
rman.deactivate(A);
assertTrue("/a is not inactive after re-inactivating",
rman.isInactive(A));
}
public void testObjectFromByteBuffer() throws Exception
{
PutKeyValueCommand put = new PutKeyValueCommand(null, A_B, "name", "Joe");
ReplicateCommand replicate = new ReplicateCommand(put);
rman.setDefaultInactive(true);
// register A as an inactive marshalling region
Region region_A = rman.getRegion(A, true);
region_A.registerContextClassLoader(this.getClass().getClassLoader());
assertFalse("New regions created should be inactive by default", region_A.isActive());
cache.stop();
c.setUseRegionBasedMarshalling(true);
c.setInactiveOnStartup(true);
VersionAwareMarshaller testee = createVAMandRestartCache(rman);
byte[] callBytes = testee.objectToByteBuffer(replicate);
try
{
testee.objectFromByteBuffer(callBytes);
fail("Expected to fail since region is inactive");
}
catch (Exception e)
{
// expected to fail since region is inactive
}
rman.activate(A);
assertTrue(rman.hasRegion(A, Region.Type.MARSHALLING));
ReplicableCommand result = (ReplicableCommand) testee.objectFromByteBuffer(callBytes);
assertEquals("Did not get replicate method when passing" +
" call for active node", ReplicateCommand.class, result.getClass());
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/ReplicateToInactiveRegionTest.java 0000644 0001750 0001750 00000005450 11017455042 033007 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
@Test(groups = {"functional", "jgroups"})
public class ReplicateToInactiveRegionTest
{
CacheSPI[] caches;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
caches = new CacheSPI[]{createCache(), createCache()};
TestingUtil.blockUntilViewsReceived(caches, 10000);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
destroyCache(caches[0]);
destroyCache(caches[1]);
caches = null;
}
private void destroyCache(CacheSPI c)
{
c.stop();
}
private CacheSPI createCache()
{
CacheSPI c = (CacheSPI) new DefaultCacheFactory().createCache(false);
c.getConfiguration().setCacheMode("REPL_SYNC");
c.getConfiguration().setUseRegionBasedMarshalling(true);
c.start();
return c;
}
@SuppressWarnings("unchecked")
public void testTransferToInactiveRegion()
{
Fqn f = Fqn.fromString("/a/b");
caches[0].put(f, "k", "v");
assertEquals("v", caches[0].get(f, "k"));
assertEquals("v", caches[1].get(f, "k"));
// create the region on cache 0, make sure it is marked as a MARSHALLING region by attaching a class loader to it.
Region region0 = caches[0].getRegionManager().getRegion(f, true);
region0.registerContextClassLoader(this.getClass().getClassLoader()); // just to make sure this is recognised as a marshalling region.
assertTrue("Should be active by default", region0.isActive());
// make sure this newly created region is "recognised" as a marshalling region.
assertTrue(caches[0].getRegionManager().getAllRegions(Region.Type.MARSHALLING).contains(region0));
// now create a region on cache 1, as above.
Region region1 = caches[1].getRegionManager().getRegion(f, true);
region1.registerContextClassLoader(this.getClass().getClassLoader()); // just to make sure this is recognised as a marshalling region.
assertTrue("Should be active by default", region1.isActive());
// make sure this newly created region is "recognised" as a marshalling region.
assertTrue(caches[1].getRegionManager().getAllRegions(Region.Type.MARSHALLING).contains(region1));
// now deactivate the region on cache 1.
region1.deactivate();
assertFalse("Should be have deactivated", region1.isActive());
caches[0].put(f, "k", "v2");
assertEquals("v2", caches[0].get(f, "k"));
assertNull(caches[1].get(f, "k"));
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/CustomCollectionTest.java 0000644 0001750 0001750 00000022470 10745240616 031242 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.Cache;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.lock.IsolationLevel;
import static org.jboss.cache.marshall.CustomCollectionTest.MarshallingMode.*;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Unit test to cover replication and marshalling of custom collections
*
* @author Galder Zamarreno
* @author Manik Surtani (manik@jboss.org)
*/
@Test(groups = {"functional"})
public class CustomCollectionTest extends RegionBasedMarshallingTestBase implements Serializable
{
private transient Cache cache1 = null;
private transient Cache cache2 = null;
private String myListClass = MyList.class.getName();
private String mySetClass = MySet.class.getName();
private String myMapClass = MyMap.class.getName();
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
cache1 = createCache();
cache2 = createCache();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
cache1.stop();
cache2.stop();
}
public void testMap() throws Exception
{
doMapTest(DEFAULT_WITHOUT_MARSHALLED_VALUES);
}
public void testMapWithRegions() throws Exception
{
doMapTest(CUSTOM_CLASSLOADER_WITH_REGIONS);
}
public void testMapWithMarshalledValues() throws Exception
{
doMapTest(CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES);
}
public void testMapWithMarshalledValuesDefaultClassloader() throws Exception
{
doMapTest(DEFAULT_WITH_MARSHALLED_VALUES);
}
public void testSet() throws Exception
{
doSetTest(DEFAULT_WITHOUT_MARSHALLED_VALUES);
}
public void testSetWithRegions() throws Exception
{
doSetTest(CUSTOM_CLASSLOADER_WITH_REGIONS);
}
public void testSetWithMarshalledValues() throws Exception
{
doSetTest(CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES);
}
public void testSetWithMarshalledValuesDefaultClassloader() throws Exception
{
doSetTest(DEFAULT_WITH_MARSHALLED_VALUES);
}
public void testList() throws Exception
{
doListTest(DEFAULT_WITHOUT_MARSHALLED_VALUES);
}
public void testListWithRegions() throws Exception
{
doListTest(CUSTOM_CLASSLOADER_WITH_REGIONS);
}
public void testListWithMarshalledValues() throws Exception
{
doListTest(CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES);
}
public void testListWithMarshalledValuesDefaultClassloader() throws Exception
{
doListTest(DEFAULT_WITH_MARSHALLED_VALUES);
}
enum MarshallingMode
{
DEFAULT_WITH_MARSHALLED_VALUES, DEFAULT_WITHOUT_MARSHALLED_VALUES, CUSTOM_CLASSLOADER_WITH_REGIONS, CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES;
boolean isUsingCustomClassLoader()
{
return this == CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES || this == CUSTOM_CLASSLOADER_WITH_REGIONS;
}
}
@SuppressWarnings("unchecked")
private void doMapTest(MarshallingMode marshallingMode) throws Exception
{
ClassLoader customClassLoader = getCollectionsClassLoader();
Class mapClass = customClassLoader.loadClass(myMapClass);
Map map = (Map) (marshallingMode.isUsingCustomClassLoader() ? mapClass.newInstance() : new MyMap());
map.put("k", "v");
configureCaches(customClassLoader, marshallingMode);
cache1.start();
cache2.start();
if (marshallingMode == CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES)
Thread.currentThread().setContextClassLoader(customClassLoader);
cache1.put(fqn("/a"), "key", map);
Object o = cache2.get(fqn("/a"), "key");
if (marshallingMode == CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES) resetContextClassLoader();
assertTrue(o instanceof Map);
if (marshallingMode.isUsingCustomClassLoader())
{
assertNotSame(MyMap.class, o.getClass());
assertSame(mapClass, o.getClass());
}
else
{
assertSame(MyMap.class, o.getClass());
assertNotSame(mapClass, o.getClass());
}
assertEquals("v", ((Map) o).get("k"));
}
@SuppressWarnings("unchecked")
private void doSetTest(MarshallingMode marshallingMode) throws Exception
{
ClassLoader customClassLoader = getCollectionsClassLoader();
Class setClass = customClassLoader.loadClass(mySetClass);
Set set = (Set) (marshallingMode.isUsingCustomClassLoader() ? setClass.newInstance() : new MySet());
set.add("k");
configureCaches(customClassLoader, marshallingMode);
cache1.start();
cache2.start();
if (marshallingMode == CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES)
Thread.currentThread().setContextClassLoader(customClassLoader);
cache1.put(fqn("/a"), "key", set);
Object o = cache2.get(fqn("/a"), "key");
if (marshallingMode == CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES) resetContextClassLoader();
assertTrue(o instanceof Set);
if (marshallingMode.isUsingCustomClassLoader())
{
assertNotSame(MySet.class, o.getClass());
assertSame(setClass, o.getClass());
}
else
{
assertSame(MySet.class, o.getClass());
assertNotSame(setClass, o.getClass());
}
assertTrue(((Set) o).contains("k"));
}
@SuppressWarnings("unchecked")
private void doListTest(MarshallingMode marshallingMode) throws Exception
{
ClassLoader customClassLoader = getCollectionsClassLoader();
Class listClass = customClassLoader.loadClass(myListClass);
List list = (List) (marshallingMode.isUsingCustomClassLoader() ? listClass.newInstance() : new MyList());
list.add("k");
configureCaches(customClassLoader, marshallingMode);
cache1.start();
cache2.start();
if (marshallingMode == CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES)
Thread.currentThread().setContextClassLoader(customClassLoader);
cache1.put(fqn("/a"), "key", list);
Object o = cache2.get(fqn("/a"), "key");
if (marshallingMode == CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES) resetContextClassLoader();
assertTrue(o instanceof List);
if (marshallingMode.isUsingCustomClassLoader())
{
assertSame(listClass, o.getClass());
assertNotSame(MyList.class, o.getClass());
}
else
{
assertSame(MyList.class, o.getClass());
assertNotSame(listClass, o.getClass());
}
assertTrue(((List) o).contains("k"));
}
public void testHarnessClassLoader() throws Exception
{
Class myListFromCustomLoader = getCollectionsClassLoader().loadClass(myListClass);
assertNotNull(myListFromCustomLoader);
assertFalse(MyList.class.equals(myListFromCustomLoader));
Object customLoaderMyList = myListFromCustomLoader.newInstance();
try
{
@SuppressWarnings("unused")
MyList m = (MyList) customLoaderMyList;
fail("Should have barfed");
}
catch (ClassCastException cce)
{
// expected
}
}
private void configureCaches(ClassLoader customClassLoader, MarshallingMode marshallingMode)
{
switch (marshallingMode)
{
case CUSTOM_CLASSLOADER_WITH_REGIONS:
cache1.getConfiguration().setUseRegionBasedMarshalling(true);
Region region1 = cache1.getRegion(fqn("/a"), true);
region1.registerContextClassLoader(customClassLoader);
cache2.getConfiguration().setUseRegionBasedMarshalling(true);
Region region2 = cache2.getRegion(fqn("/a"), true);
region2.registerContextClassLoader(customClassLoader);
// and carry on to the same setting as DEFAULT_WITHOUT_MARSHALLED_VALUES
case DEFAULT_WITHOUT_MARSHALLED_VALUES:
cache1.getConfiguration().setUseLazyDeserialization(false);
cache2.getConfiguration().setUseLazyDeserialization(false);
break;
case DEFAULT_WITH_MARSHALLED_VALUES:
case CUSTOM_CLASSLOADER_WITH_MARSHALLEDVALUES:
cache1.getConfiguration().setUseLazyDeserialization(true);
cache2.getConfiguration().setUseLazyDeserialization(true);
break;
}
}
private ClassLoader getCollectionsClassLoader()
{
String[] includesClasses = {myListClass, mySetClass, myMapClass};
String[] excludesClasses = {};
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return new SelectedClassnameClassLoader(includesClasses, excludesClasses, cl);
}
private Cache createCache()
{
Cache cache = new DefaultCacheFactory().createCache(false);
cache.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
cache.getConfiguration().setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
cache.getConfiguration().setIsolationLevel(IsolationLevel.REPEATABLE_READ);
return cache;
}
private static Fqn fqn(String fqn)
{
return Fqn.fromString(fqn);
}
} jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/SyncReplMarshalledValuesTest.java 0000644 0001750 0001750 00000000733 10745240616 032666 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.testng.annotations.Test;
/**
* @author Manik Surtani (manik@jboss.org)
* @since 2.1.0
*/
@Test(groups = {"functional", "jgroups"})
public class SyncReplMarshalledValuesTest extends SyncReplTest
{
public SyncReplMarshalledValuesTest()
{
useMarshalledValues = true;
}
@Override
public void testCustomFqn()
{
// meaningless when using marshalled values
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/MySet.java 0000644 0001750 0001750 00000000253 10665031725 026150 0 ustar twerner twerner package org.jboss.cache.marshall;
import java.util.HashSet;
public class MySet extends HashSet
{
private static final long serialVersionUID = 2164839240744662205L;
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/AsyncReplTest.java 0000644 0001750 0001750 00000025723 11020007335 027642 0 ustar twerner twerner /*
*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.commands.write.PutKeyValueCommand;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import org.jboss.cache.marshall.data.Address;
import org.jboss.cache.marshall.data.Person;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.ReplicationListener;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.transaction.*;
import java.lang.reflect.Method;
/**
* Test marshalling for async mode.
*
* @author Ben Wang
* @version $Revision: 5919 $
*/
@Test(groups = {"functional", "jgroups"})
public class AsyncReplTest extends RegionBasedMarshallingTestBase
{
CacheSPI cache1, cache2;
String props = null;
Person ben;
Address addr;
Throwable ex;
private Fqn aop = Fqn.fromString("/aop");
protected boolean useMarshalledValues = false;
ReplicationListener replListener1;
ReplicationListener replListener2;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
resetContextClassLoader();
log("creating cache1");
cache1 = createCache("TestCache");
log("creating cache2");
cache2 = createCache("TestCache");
replListener1 = new ReplicationListener(cache1);
replListener2 = new ReplicationListener(cache2);
addr = new Address();
addr.setCity("San Jose");
ben = new Person();
ben.setName("Ben");
ben.setAddress(addr);
// Pause to give caches time to see each other
TestingUtil.blockUntilViewsReceived(new CacheSPI[]{cache1, cache2}, 60000);
}
private CacheSPI createCache(String name)
{
CacheSPI cache = (CacheSPI) new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(CacheMode.REPL_ASYNC), false);
cache.getConfiguration().setClusterName(name);
// Use marshaller
cache.getConfiguration().setUseLazyDeserialization(useMarshalledValues);
cache.getConfiguration().setUseRegionBasedMarshalling(!useMarshalledValues);
cache.create();
cache.start();
return cache;
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache1, cache2);
resetContextClassLoader();
}
/**
* Test replication with classloaders.
*
* @throws Exception
*/
public void testCLSet2() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region existing = cache1.getRegion(aop, true);
existing.registerContextClassLoader(cla);
existing = cache2.getRegion(aop, true);
existing.registerContextClassLoader(clb);
}
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
replListener2.expect(PutKeyValueCommand.class);
cache1.put(aop, "person", ben);
replListener2.waitForReplicationToOccur(500);
replListener2.expect(PutKeyValueCommand.class);
cache1.put(Fqn.fromString("/alias"), "person", ben);
replListener2.waitForReplicationToOccur(500);
if (useMarshalledValues) resetContextClassLoader();
Object ben2 = null;
// Can't cast it to Person. CCE will resutl.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(aop, "person");
if (useMarshalledValues) resetContextClassLoader();
assertNotNull(ben2);
assertEquals(ben.toString(), ben2.toString());
Class claz = clb.loadClass(ADDRESS_CLASSNAME);
Object add = claz.newInstance();
Method setValue = claz.getMethod("setCity", String.class);
setValue.invoke(add, "Sunnyvale");
Class clasz1 = clb.loadClass(PERSON_CLASSNAME);
setValue = clasz1.getMethod("setAddress", claz);
setValue.invoke(ben2, add);
// Set it back to the cache
// Can't cast it to Person. CCE will resutl.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
replListener1.expect(PutKeyValueCommand.class);
cache2.put(aop, "person", ben2);
replListener1.waitForReplicationToOccur(1000);
if (useMarshalledValues) resetContextClassLoader();
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
Object ben3 = cache1.get(aop, "person");
if (useMarshalledValues) resetContextClassLoader();
assertEquals(ben2.toString(), ben3.toString());
}
public void testPuts() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
// Create an empty Person loaded by this classloader
Object scopedBen1 = getPersonFromClassloader(cla);
// Create another empty Person loaded by this classloader
Object scopedBen2 = getPersonFromClassloader(clb);
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
replListener2.expect(PutKeyValueCommand.class);
cache1.put(Fqn.fromString("/aop/1"), "person", ben);
replListener2.waitForReplicationToOccur(1000);
replListener2.expect(PutKeyValueCommand.class);
cache1.put(Fqn.fromString("/aop/2"), "person", scopedBen1);
replListener2.waitForReplicationToOccur(1000);
if (useMarshalledValues) resetContextClassLoader();
Object ben2 = null;
// Can't cast it to Person. CCE will resutl.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(Fqn.fromString("/aop/1"), "person");
assertEquals(ben.toString(), ben2.toString());
ben2 = cache2.get(Fqn.fromString("/aop/2"), "person");
assertFalse("cache2 deserialized with scoped classloader", ben2 instanceof Person);
assertFalse("cache2 deserialized with cache2 classloader", scopedBen1.equals(ben2));
assertEquals("scopedBen deserialized properly", scopedBen2, ben2);
}
public void testTxPut() throws Exception
{
replListener2.expectAny();
beginTransaction();
cache1.put(aop, "person", ben);
commit();
replListener2.waitForReplicationToOccur(1000);
Person ben2 = (Person) cache2.get(aop, "person");
assertNotNull("Person from 2nd cache should not be null ", ben2);
assertEquals(ben.toString(), ben2.toString());
}
public void testTxCLSet2() throws Exception
{
ClassLoader cla = getClassLoader();
ClassLoader clb = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cla);
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(clb);
}
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
replListener2.expectAny();
beginTransaction();
cache1.put(aop, "person", ben);
commit();
replListener2.waitForReplicationToOccur(1000);
if (useMarshalledValues) resetContextClassLoader();
Object ben2 = null;
// Can't cast it to Person. CCE will resutl.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
ben2 = cache2.get(aop, "person");
if (useMarshalledValues) resetContextClassLoader();
assertEquals(ben.toString(), ben2.toString());
Class claz = clb.loadClass(ADDRESS_CLASSNAME);
Object add = claz.newInstance();
Method setValue = claz.getMethod("setCity", String.class);
setValue.invoke(add, "Sunnyvale");
Class clasz1 = clb.loadClass(PERSON_CLASSNAME);
setValue = clasz1.getMethod("setAddress", claz);
setValue.invoke(ben2, add);
// Set it back to the cache
// Can't cast it to Person. CCE will resutl.
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(clb);
replListener1.expectAny();
cache2.put(aop, "person", ben2);
if (useMarshalledValues) resetContextClassLoader();
replListener1.waitForReplicationToOccur(100);
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(cla);
Object ben3 = cache1.get(aop, "person");
if (useMarshalledValues) resetContextClassLoader();
assertEquals(ben2.toString(), ben3.toString());
}
public void testCustomFqn() throws Exception
{
FooClassLoader cl1 = new FooClassLoader(Thread.currentThread().getContextClassLoader());
Region r1 = cache1.getRegion(aop, false) == null ? cache1.getRegion(aop, true) : cache1.getRegion(aop, false);
r1.registerContextClassLoader(cl1);
FooClassLoader cl2 = new FooClassLoader(Thread.currentThread().getContextClassLoader());
Region r2 = cache2.getRegion(aop, false) == null ? cache2.getRegion(aop, true) : cache2.getRegion(aop, false);
r2.registerContextClassLoader(cl2);
Class clazz = cl1.loadFoo();
Object custom1 = clazz.newInstance();
clazz = cl2.loadFoo();
Object custom2 = clazz.newInstance();
Fqn base = Fqn.fromString("/aop");
Fqn fqn = Fqn.fromRelativeElements(base, custom1);
replListener2.expectAny();
cache1.put(fqn, "key", "value");
replListener2.waitForReplicationToOccur(1000);
Fqn fqn2 = Fqn.fromRelativeElements(base, custom2);
Object val = cache2.get(fqn2, "key");
assertEquals("value", val);
}
private Transaction beginTransaction() throws SystemException, NotSupportedException
{
TransactionManager mgr = cache1.getConfiguration().getRuntimeConfig().getTransactionManager();
mgr.begin();
return mgr.getTransaction();
}
private void commit() throws SecurityException, IllegalStateException, RollbackException, HeuristicMixedException, HeuristicRollbackException, SystemException
{
cache1.getConfiguration().getRuntimeConfig().getTransactionManager().commit();
}
protected Object getPersonFromClassloader(ClassLoader cl) throws Exception
{
Class clazz = cl.loadClass(PERSON_CLASSNAME);
return clazz.newInstance();
}
private void log(String msg)
{
System.out.println("-- [" + Thread.currentThread() + "]: " + msg);
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/RegionBasedMarshallingTestBase.java 0000644 0001750 0001750 00000002422 10745240616 033106 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.testng.annotations.Test;
@Test(groups = {"functional"})
public abstract class RegionBasedMarshallingTestBase
{
protected static final String ADDRESS_CLASSNAME = "org.jboss.cache.marshall.data.Address";
protected static final String PERSON_CLASSNAME = "org.jboss.cache.marshall.data.Person";
protected ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
protected ClassLoader getClassLoader() throws Exception
{
String[] includesClasses = {PERSON_CLASSNAME, ADDRESS_CLASSNAME};
String[] excludesClasses = {};
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return new SelectedClassnameClassLoader(includesClasses, excludesClasses, cl);
}
protected ClassLoader getFailingClassLoader() throws Exception
{
String[] includesClasses = {};
String[] excludesClasses = {};
String[] failingClasses = {PERSON_CLASSNAME, ADDRESS_CLASSNAME};
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return new SelectedClassnameClassLoader(includesClasses, excludesClasses, failingClasses, cl);
}
protected void resetContextClassLoader()
{
Thread.currentThread().setContextClassLoader(originalClassLoader);
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/InvalidRegionForStateTransferTest.java jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/InvalidRegionForStateTransferTest.ja0000644 0001750 0001750 00000007037 11020007335 033320 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.Cache;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.ReplicationListener;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.UnitTestCacheConfigurationFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* This test ensures the CacheMarshaller doesn't use stale regions when attempting to unmarshall state transfers. Seen intermittently
* when async replication is used, since JGroups doesn't attempt to marshall a return value, thereby leaving a stale region in thread local
* in the cache marshaller, which then gets reused when the thread is reused to provide state.
*
* Need to ensure that the same thread is used to process incoming requests as well as state transfers, hence limiting the JGroups
* thread pool size to 1.
*
*
* @author Manik Surtani (manik@jboss.org)
* @since 2.1.0
*/
@Test(groups = "functional")
public class InvalidRegionForStateTransferTest
{
Cache c1, c2;
ReplicationListener replListener2;
@BeforeMethod
public void setUp() throws CloneNotSupportedException
{
c1 = new DefaultCacheFactory().createCache(UnitTestCacheConfigurationFactory.createConfiguration(Configuration.CacheMode.REPL_ASYNC), false);
String jgroupsCfg = c1.getConfiguration().getClusterConfig();
// make sure we use STATE_TRANSFER and not STREAMING_STATE_TRANSFER, so the same thread pool is used for incoming calls and ST
jgroupsCfg = jgroupsCfg.replace("STREAMING_STATE_TRANSFER", "STATE_TRANSFER");
// also make sure we use a thread pool size of 1
jgroupsCfg = jgroupsCfg.replaceFirst("thread_pool.max_threads=[0-9]*;", "thread_pool.max_threads=1;");
System.out.println(">>>> " + jgroupsCfg);
c1.getConfiguration().setClusterConfig(jgroupsCfg);
c1.getConfiguration().setUseRegionBasedMarshalling(true);
c1.start();
c2 = new DefaultCacheFactory().createCache(c1.getConfiguration().clone());
replListener2 = new ReplicationListener(c2);
TestingUtil.blockUntilViewsReceived(60000, c1, c2);
}
@AfterMethod
public void tearDown()
{
TestingUtil.killCaches(c1, c2);
}
public void testUseOfInvalidRegion()
{
Fqn fqn = Fqn.fromString("/a/b/c/d");
c1.getRegion(fqn.getParent(), true).registerContextClassLoader(getClass().getClassLoader());
c2.getRegion(fqn.getParent(), true).registerContextClassLoader(getClass().getClassLoader());
replListener2.expectAny();
// write something; will cause a stale region to be stored in C2's cache marshaller
c1.put(fqn, "k", "v");
assert c1.get(fqn, "k").equals("v");
replListener2.waitForReplicationToOccur(250);
// assert that this made it to c2
assert c2.get(fqn, "k").equals("v");
// c2's cache marshaller's thread local would be polluted now.
// restart c1 so that it forces a state transfer from c2
c1.destroy();
c1.create();
Region r = c1.getRegion(fqn.getParent(), true);
r.registerContextClassLoader(getClass().getClassLoader());
r.deactivate();
c1.start();
TestingUtil.blockUntilViewsReceived(60000, c1, c2);
// assert that the state has been transferred to C1
assert c1.get(fqn, "k").equals("v");
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/FooClassLoader.java 0000644 0001750 0001750 00000017232 10701213260 027737 0 ustar twerner twerner package org.jboss.cache.marshall;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
public class FooClassLoader extends ClassLoader
{
private Class foo;
private boolean useCachedByteStream = true;
public FooClassLoader(ClassLoader parent)
{
super(parent);
}
public Class loadFoo() throws ClassNotFoundException
{
if (foo == null)
{
byte[] bytes;
if (useCachedByteStream)
{
bytes = getFooClazzAsBytes();
}
else
{
try
{
InputStream is = getResourceAsStream("org/jboss/cache/marshall/Foo.clazz");
bytes = new byte[1024];
ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
int read;
while ((read = is.read(bytes)) > -1)
{
baos.write(bytes, 0, read);
}
bytes = getFooClazzAsBytes();
}
catch (IOException e)
{
throw new ClassNotFoundException("cannot read org/jboss/cache/marshall/Foo.clazz", e);
}
}
foo = this.defineClass("org.jboss.cache.marshall.Foo", bytes, 0, bytes.length);
}
return foo;
}
private byte[] getFooClazzAsBytes()
{
// GENERATED using main() method to read org/jboss/cache/marshall/Foo.clazz into a byte[]
// so that this byte stream is available even if Foo.clazz is not included in the test classpath by Maven
// Copy out this generated snippet into FooClassLoader.java and use this byte[] instead of
// trying to read Foo.clazz off the classpath.
return new byte[]{
-54, -2, -70, -66, 0, 0, 0, 46, 0, 61, 7, 0, 2, 1, 0, 28, 111, 114, 103, 47, 106, 98, 111, 115, 115, 47, 99, 97, 99, 104,
101, 47, 109, 97, 114, 115, 104, 97, 108, 108, 47, 70, 111, 111, 7, 0, 4, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47,
79, 98, 106, 101, 99, 116, 7, 0, 6, 1, 0, 20, 106, 97, 118, 97, 47, 105, 111, 47, 83, 101, 114, 105, 97, 108, 105, 122, 97, 98,
108, 101, 1, 0, 16, 115, 101, 114, 105, 97, 108, 86, 101, 114, 115, 105, 111, 110, 85, 73, 68, 1, 0, 1, 74, 1, 0, 13, 67, 111,
110, 115, 116, 97, 110, 116, 86, 97, 108, 117, 101, 5, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1,
0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 10, 0, 3, 0, 16, 12, 0, 12, 0, 13, 1, 0, 15, 76, 105, 110, 101, 78,
117, 109, 98, 101, 114, 84, 97, 98, 108, 101, 1, 0, 18, 76, 111, 99, 97, 108, 86, 97, 114, 105, 97, 98, 108, 101, 84, 97, 98, 108,
101, 1, 0, 4, 116, 104, 105, 115, 1, 0, 30, 76, 111, 114, 103, 47, 106, 98, 111, 115, 115, 47, 99, 97, 99, 104, 101, 47, 109, 97,
114, 115, 104, 97, 108, 108, 47, 70, 111, 111, 59, 1, 0, 6, 101, 113, 117, 97, 108, 115, 1, 0, 21, 40, 76, 106, 97, 118, 97, 47,
108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 59, 41, 90, 1, 0, 3, 111, 98, 106, 1, 0, 18, 76, 106, 97, 118, 97, 47, 108,
97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 59, 1, 0, 8, 104, 97, 115, 104, 67, 111, 100, 101, 1, 0, 3, 40, 41, 73, 1, 0,
8, 116, 111, 83, 116, 114, 105, 110, 103, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110,
103, 59, 7, 0, 30, 1, 0, 26, 106, 97, 118, 97, 47, 115, 101, 99, 117, 114, 105, 116, 121, 47, 83, 101, 99, 117, 114, 101, 82, 97,
110, 100, 111, 109, 10, 0, 29, 0, 16, 7, 0, 33, 1, 0, 22, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110,
103, 66, 117, 102, 102, 101, 114, 8, 0, 35, 1, 0, 36, 111, 114, 103, 46, 106, 98, 111, 115, 115, 46, 99, 97, 99, 104, 101, 46, 109,
97, 114, 115, 104, 97, 108, 108, 46, 70, 111, 111, 91, 114, 97, 110, 100, 111, 109, 61, 10, 0, 32, 0, 37, 12, 0, 12, 0, 38, 1,
0, 21, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 41, 86, 10, 0, 40, 0, 42, 7, 0,
41, 1, 0, 16, 106, 97, 118, 97, 47, 117, 116, 105, 108, 47, 82, 97, 110, 100, 111, 109, 12, 0, 43, 0, 26, 1, 0, 7, 110, 101,
120, 116, 73, 110, 116, 10, 0, 32, 0, 45, 12, 0, 46, 0, 47, 1, 0, 6, 97, 112, 112, 101, 110, 100, 1, 0, 27, 40, 73, 41,
76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 66, 117, 102, 102, 101, 114, 59, 8, 0, 49, 1, 0, 1,
93, 10, 0, 32, 0, 51, 12, 0, 46, 0, 52, 1, 0, 44, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105,
110, 103, 59, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 66, 117, 102, 102, 101, 114, 59, 10, 0,
32, 0, 54, 12, 0, 27, 0, 28, 1, 0, 6, 114, 97, 110, 100, 111, 109, 1, 0, 18, 76, 106, 97, 118, 97, 47, 117, 116, 105, 108,
47, 82, 97, 110, 100, 111, 109, 59, 1, 0, 2, 115, 98, 1, 0, 24, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114,
105, 110, 103, 66, 117, 102, 102, 101, 114, 59, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101, 1, 0, 8, 70, 111, 111, 46,
106, 97, 118, 97, 0, 33, 0, 1, 0, 3, 0, 1, 0, 5, 0, 1, 0, 26, 0, 7, 0, 8, 0, 1, 0, 9, 0, 0, 0, 2,
0, 10, 0, 4, 0, 1, 0, 12, 0, 13, 0, 1, 0, 14, 0, 0, 0, 47, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 15,
-79, 0, 0, 0, 2, 0, 17, 0, 0, 0, 6, 0, 1, 0, 0, 0, 15, 0, 18, 0, 0, 0, 12, 0, 1, 0, 0, 0, 5, 0,
19, 0, 20, 0, 0, 0, 1, 0, 21, 0, 22, 0, 1, 0, 14, 0, 0, 0, 57, 0, 1, 0, 2, 0, 0, 0, 5, 43, -63, 0,
1, -84, 0, 0, 0, 2, 0, 17, 0, 0, 0, 6, 0, 1, 0, 0, 0, 22, 0, 18, 0, 0, 0, 22, 0, 2, 0, 0, 0, 5,
0, 19, 0, 20, 0, 0, 0, 0, 0, 5, 0, 23, 0, 24, 0, 1, 0, 1, 0, 25, 0, 26, 0, 1, 0, 14, 0, 0, 0, 44,
0, 1, 0, 1, 0, 0, 0, 2, 4, -84, 0, 0, 0, 2, 0, 17, 0, 0, 0, 6, 0, 1, 0, 0, 0, 27, 0, 18, 0, 0,
0, 12, 0, 1, 0, 0, 0, 2, 0, 19, 0, 20, 0, 0, 0, 1, 0, 27, 0, 28, 0, 1, 0, 14, 0, 0, 0, 111, 0, 3,
0, 3, 0, 0, 0, 37, -69, 0, 29, 89, -73, 0, 31, 76, -69, 0, 32, 89, 18, 34, -73, 0, 36, 77, 44, 43, -74, 0, 39, -74,
0, 44, 18, 48, -74, 0, 50, 87, 44, -74, 0, 53, -80, 0, 0, 0, 2, 0, 17, 0, 0, 0, 18, 0, 4, 0, 0, 0, 32, 0,
8, 0, 33, 0, 18, 0, 34, 0, 32, 0, 35, 0, 18, 0, 0, 0, 32, 0, 3, 0, 0, 0, 37, 0, 19, 0, 20, 0, 0, 0,
8, 0, 29, 0, 55, 0, 56, 0, 1, 0, 18, 0, 19, 0, 57, 0, 58, 0, 2, 0, 1, 0, 59, 0, 0, 0, 2, 0, 60,};
}
/* public static void main(String[] args) throws Exception
{
InputStream is = FooClassLoader.class.getClassLoader().getResourceAsStream("org/jboss/cache/marshall/Foo.clazz");
byte[] bytes = new byte[1024];
ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
int read;
while ((read = is.read(bytes)) > -1)
{
baos.write(bytes, 0, read);
}
bytes = baos.toByteArray();
System.out.println("// GENERATED using main() method to read org/jboss/cache/marshall/Foo.clazz into a byte[]");
System.out.println("// so that this byte stream is available even if Foo.clazz is not included in the test classpath by Maven");
System.out.println("// Copy out this generated snippet into FooClassLoader.java and use this byte[] instead of ");
System.out.println("// trying to read Foo.clazz off the classpath. ");
System.out.println();
System.out.println("return new byte[] {");
int i=0;
for (byte b : bytes)
{
i++;
System.out.print(b);
System.out.print(", ");
if (i % 30 == 0) System.out.println();
}
System.out.println("};");
}*/
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/MyMap.java 0000644 0001750 0001750 00000000253 10665031725 026132 0 ustar twerner twerner package org.jboss.cache.marshall;
import java.util.HashMap;
public class MyMap extends HashMap
{
private static final long serialVersionUID = -269748324316844637L;
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/ReturnValueMarshallingTest.java 0000644 0001750 0001750 00000013307 11017455042 032403 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.buddyreplication.GravitateResult;
import org.jboss.cache.commands.DataCommand;
import org.jboss.cache.commands.read.GetKeyValueCommand;
import org.jboss.cache.commands.read.GravitateDataCommand;
import org.jboss.cache.commands.remote.ClusteredGetCommand;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.CommandsFactory;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.List;
/**
* Tests the marshalling of retvals
*
* @author Manik Surtani
* @since 2.0.0
*/
@Test(groups = {"functional", "jgroups"})
public class ReturnValueMarshallingTest extends RegionBasedMarshallingTestBase
{
protected boolean useMarshalledValues = false;
private CacheSPI cache1, cache2;
private Fqn fqn = Fqn.fromString("/a");
private ClassLoader classLoader;
private Object key = "key", value;
private String className = "org.jboss.cache.marshall.MyList";
private Class listClass;
private CommandsFactory commandsFactory = new CommandsFactory();
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
cache1 = (CacheSPI) new DefaultCacheFactory().createCache(false);
cache1.getConfiguration().setUseLazyDeserialization(useMarshalledValues);
cache1.getConfiguration().setUseRegionBasedMarshalling(!useMarshalledValues);
cache1.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
cache1.getConfiguration().setSyncReplTimeout(60000);// to aid with debugging
cache1.start();
cache2 = (CacheSPI) new DefaultCacheFactory().createCache(false);
cache2.getConfiguration().setUseLazyDeserialization(useMarshalledValues);
cache2.getConfiguration().setUseRegionBasedMarshalling(!useMarshalledValues);
cache2.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
cache2.getConfiguration().setSyncReplTimeout(60000);// to aid with debugging
cache2.start();
classLoader = getClassLoader();
if (!useMarshalledValues)
{
Region r1 = cache1.getRegion(fqn, true);
r1.setActive(true);
r1.registerContextClassLoader(classLoader);
Region r2 = cache2.getRegion(fqn, true);
r2.setActive(true);
r2.registerContextClassLoader(classLoader);
}
listClass = classLoader.loadClass(className);
value = listClass.newInstance();
cache1.put(fqn, key, value);
}
@AfterMethod(alwaysRun = true)
public void tearDown()
{
TestingUtil.killCaches(cache1, cache2);
resetContextClassLoader();
}
@Override
protected ClassLoader getClassLoader()
{
String[] includesClasses = {className};
String[] excludesClasses = {};
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return new SelectedClassnameClassLoader(includesClasses, excludesClasses, cl);
}
public void testClusteredGet() throws Exception
{
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(classLoader);
assertNotNull(cache1.get(fqn, key));
assertNotSame(MyList.class, cache1.get(fqn, key).getClass());
assertSame(listClass, cache1.get(fqn, key).getClass());
assertNotNull(cache2.get(fqn, key));
assertNotSame(MyList.class, cache2.get(fqn, key).getClass());
assertSame(listClass, cache2.get(fqn, key).getClass());
DataCommand command = new GetKeyValueCommand(fqn, key, false);
ClusteredGetCommand clusteredGet = new ClusteredGetCommand(false, command);
List responses = cache1.getRPCManager().callRemoteMethods(null, clusteredGet, true, 15000, false);
List response1 = (List) responses.get(0);// response from the first (and only) node
Boolean found = (Boolean) response1.get(0);
assertTrue("Should have found remote data", found);
Object data = response1.get(1);
// now test that the data returned has been marshalled using the appropriate class loader.
assertNotNull(data);
if (useMarshalledValues) data = ((MarshalledValue) data).get();
assertNotSame(MyList.class, data.getClass());
assertSame(listClass, data.getClass());
}
public void testDataGravitation() throws Exception
{
if (useMarshalledValues) Thread.currentThread().setContextClassLoader(classLoader);
assertNotNull(cache1.get(fqn, key));
assertNotSame(MyList.class, cache1.get(fqn, key).getClass());
assertSame(listClass, cache1.get(fqn, key).getClass());
assertNotNull(cache2.get(fqn, key));
assertNotSame(MyList.class, cache2.get(fqn, key).getClass());
assertSame(listClass, cache2.get(fqn, key).getClass());
GravitateDataCommand gravitateDataCommand = new GravitateDataCommand(fqn, false, cache1.getRPCManager().getLocalAddress());
List responses = cache1.getRPCManager().callRemoteMethods(null, gravitateDataCommand, true, 15000, false);
GravitateResult data = (GravitateResult) responses.get(0);// response from the first (and only) node
assertTrue("Should have found remote data", data.isDataFound());
assertNotNull(data.getNodeData());
Object value = data.getNodeData().get(0).getAttributes().get(key);
assertNotNull(value);
if (useMarshalledValues) value = ((MarshalledValue) value).get();
assertNotSame(MyList.class, value.getClass());
assertSame(listClass, value.getClass());
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/VersionAwareMarshallerTest.java 0000644 0001750 0001750 00000007365 11011035077 032370 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall;
import org.jboss.cache.Version;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.ComponentRegistry;
import org.jboss.cache.invocation.CacheInvocationDelegate;
import org.jboss.util.stream.MarshalledValueInputStream;
import static org.testng.AssertJUnit.assertEquals;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
/**
* Tests the enhanced treecache marshaller
*
* @author Manik Surtani (manik@jboss.org)
*/
@Test(groups = {"functional"})
public class VersionAwareMarshallerTest extends AbstractVersionAwareMarshallerTest
{
@BeforeMethod
public void setUp()
{
cr = new ComponentRegistry(new Configuration(), new CacheInvocationDelegate());
}
@AfterMethod
public void tearDown()
{
cr = null;
}
public void testMarshallerSelection()
{
VersionAwareMarshaller marshaller = createVAMandRestartCache("2.2.0.GA");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("2.1.0.GA");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("2.0.0.GA");
assertEquals(CacheMarshaller200.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("1.4.0.GA");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("1.5.0.GA");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("1.3.0.GA");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("1.3.0.SP2");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("1.3.1.GA");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("1.2.4.SP2");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
marshaller = createVAMandRestartCache("1.2.3");
assertEquals(CacheMarshaller210.class, marshaller.defaultMarshaller.getClass());
}
public void testVersionHeaderDefaultCurrent() throws Exception
{
VersionAwareMarshaller marshaller = createVAMandRestartCache(Version.getVersionString(Version.getVersionShort()));
byte[] bytes = marshaller.objectToByteBuffer("Hello");
ObjectInputStream in = new MarshalledValueInputStream(new ByteArrayInputStream(bytes));
assertEquals("Version header short should be '22'", 22, in.readShort());
}
public void testVersionHeader210() throws Exception
{
VersionAwareMarshaller marshaller = createVAMandRestartCache("2.1.0.GA");
byte[] bytes = marshaller.objectToByteBuffer("Hello");
ObjectInputStream in = new MarshalledValueInputStream(new ByteArrayInputStream(bytes));
assertEquals("Version header short should be '21'", 21, in.readShort());
}
public void testVersionHeader200() throws Exception
{
VersionAwareMarshaller marshaller = createVAMandRestartCache("2.0.0.GA");
byte[] bytes = marshaller.objectToByteBuffer("Hello");
ObjectInputStream in = new MarshalledValueInputStream(new ByteArrayInputStream(bytes));
assertEquals("Version header short should be '20'", 20, in.readShort());
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/Foo.clazz 0000644 0001750 0001750 00000002125 10535375655 026045 0 ustar twerner twerner Êþº¾ . = org/jboss/cache/marshall/Foo java/lang/Object java/io/Serializable serialVersionUID J
ConstantValue ()V Code
LineNumberTable LocalVariableTable this Lorg/jboss/cache/marshall/Foo; equals (Ljava/lang/Object;)Z obj Ljava/lang/Object; hashCode ()I toString ()Ljava/lang/String; java/security/SecureRandom
! java/lang/StringBuffer # $org.jboss.cache.marshall.Foo[random=
% & (Ljava/lang/String;)V
( * ) java/util/Random + nextInt
- . / append (I)Ljava/lang/StringBuffer; 1 ]
3 . 4 ,(Ljava/lang/String;)Ljava/lang/StringBuffer;
6 random Ljava/util/Random; sb Ljava/lang/StringBuffer;
SourceFile Foo.java !
/ *· ± 9 +Á ¬ , ¬ o %» Y· L» Y"· $M,+¶ '¶ ,0¶ 2W,¶ 5° ! " # % 7 8 9 : ; < jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/CacheLoaderMarshallingJDBCTest.java 0000644 0001750 0001750 00000011466 11017455042 032710 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.Cache;
import org.jboss.cache.DefaultCacheFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.CacheLoaderConfig.IndividualCacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.eviction.LRUConfiguration;
import org.jboss.cache.eviction.LRUPolicy;
import org.jboss.cache.loader.JDBCCacheLoaderConfig;
import static org.testng.AssertJUnit.assertEquals;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
/**
* Tests marshalling/unmarshalling during cache loader operations involving types
* not visible to the cache's default classloader.
*
* @author Brian Stansberry
* @since 2.1.0
*/
@Test(groups = "functional")
public class CacheLoaderMarshallingJDBCTest extends RegionBasedMarshallingTestBase
{
private static final String className = "org.jboss.cache.marshall.MyUUID";
private Cache cache;
private Fqn fqn = Fqn.fromString("/a");
@BeforeMethod(alwaysRun = true)
protected void setUp() throws Exception
{
originalClassLoader = Thread.currentThread().getContextClassLoader();
}
@AfterMethod(alwaysRun = true)
protected void tearDown()
{
resetContextClassLoader();
TestingUtil.killCaches(cache);
}
@Override
protected ClassLoader getClassLoader()
{
String[] includesClasses = {className};
String[] excludesClasses = {};
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return new SelectedClassnameClassLoader(includesClasses, excludesClasses, cl);
}
public void testCacheLoaderMarshalling() throws Exception
{
cacheLoaderMarshallingTest(false);
}
public void testCacheLoaderRegionBasedMarshalling() throws Exception
{
cacheLoaderMarshallingTest(true);
}
private void cacheLoaderMarshallingTest(boolean useRegionBased) throws Exception
{
cache = createCache(useRegionBased);
cache.start();
FooClassLoader loader = new FooClassLoader(originalClassLoader);
if (useRegionBased)
{
Region r = cache.getRegion(Fqn.ROOT, true);
r.registerContextClassLoader(loader);
r.activate();
}
Class clazz = loader.loadFoo();
Object obj = clazz.newInstance();
Thread.currentThread().setContextClassLoader(loader);
cache.put(fqn, "key", obj);
this.resetContextClassLoader();
cache.evict(fqn);
Thread.currentThread().setContextClassLoader(loader);
assertEquals(obj, cache.get(fqn, "key"));
}
private Cache createCache(boolean useRegionBased) throws Exception
{
Properties prop = getProperties();
// ensure cleanup after each test
prop.setProperty("cache.jdbc.table.drop", "true");
Cache cache = new DefaultCacheFactory().createCache(false);
Configuration config = cache.getConfiguration();
config.setUseRegionBasedMarshalling(useRegionBased);
config.setInactiveOnStartup(useRegionBased);
EvictionConfig ec = new EvictionConfig();
ec.setDefaultEvictionPolicyClass(LRUPolicy.class.getName());
ec.setWakeupIntervalSeconds(1000); // a long time; really disabled
EvictionRegionConfig erc = new EvictionRegionConfig();
erc.setRegionFqn(Fqn.ROOT);
erc.setRegionName("_default_");
LRUConfiguration epc = new LRUConfiguration();
epc.setMaxNodes(1000);
epc.setTimeToLiveSeconds(1000);
erc.setEvictionPolicyConfig(epc);
List ercs = new ArrayList();
ercs.add(erc);
ec.setEvictionRegionConfigs(ercs);
config.setEvictionConfig(ec);
CacheLoaderConfig clc = new CacheLoaderConfig();
clc.setPassivation(true);
clc.setShared(false);
JDBCCacheLoaderConfig jdbc_clc = new JDBCCacheLoaderConfig();
jdbc_clc.setProperties(prop);
clc.setIndividualCacheLoaderConfigs(Collections.singletonList(jdbc_clc));
config.setCacheLoaderConfig(clc);
return cache;
}
private Properties getProperties() throws Exception
{
Properties properties = new Properties();
try
{
properties.load(this.getClass().getClassLoader().getResourceAsStream("cache-jdbc.properties"));
return properties;
}
catch (Exception e)
{
throw new Exception("Error loading jdbc properties ", e);
}
}
} jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/UnmarshalledReferencesTest.java 0000644 0001750 0001750 00000003042 10763637237 032400 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.testng.annotations.Test;
import static org.testng.Assert.*;
import static org.testng.Assert.assertEquals;
/**
* Tester for UnmarshalledReferences.
*
* @author Mircea.Markus@jboss.com
*/
@Test(groups = {"functional"})
public class UnmarshalledReferencesTest
{
public void testSimpleGetPut()
{
UnmarshalledReferences refs = new UnmarshalledReferences();
for (int i = 0; i < 100; i++)
{
refs.putReferencedObject(i, String.valueOf(i));
}
for (int i = 0; i < 100; i++)
{
assertEquals(refs.getReferencedObject(i), String.valueOf(i));
}
}
public void testPutWithGap()
{
UnmarshalledReferences refs = new UnmarshalledReferences();
refs.putReferencedObject(0, "0");
refs.putReferencedObject(2, "2");
assertEquals(refs.getReferencedObject(0), "0");
assertNull(refs.getReferencedObject(1));
assertEquals(refs.getReferencedObject(2), "2");
}
public void testPutBefore()
{
UnmarshalledReferences refs = new UnmarshalledReferences();
refs.putReferencedObject(2, "2");
refs.putReferencedObject(3, "3");
//when adding this make sure other positions are not shifted
refs.putReferencedObject(1, "1");
assertNull(refs.getReferencedObject(0));
assertEquals("1", refs.getReferencedObject(1));
assertEquals("2", refs.getReferencedObject(2));
assertEquals("3", refs.getReferencedObject(3));
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/SelectedClassnameClassLoader.java 0000644 0001750 0001750 00000017174 10745240616 032615 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
/**
* A ClassLoader that loads classes whose classname begins with one of a
* given set of strings, without attempting first to delegate to its
* parent loader.
*
* This class is intended to allow emulation of 2 different types of common J2EE
* classloading situations.
*
*
Servlet-style child-first classloading, where this class is the
* child loader.
*
Parent-first classloading where the parent does not have access to
* certain classes
*
*
*
* This class can also be configured to raise a ClassNotFoundException if
* asked to load certain classes, thus allowing classes on the classpath
* to be hidden from a test environment.
*
*
* @author Brian Stansberry
*/
public class SelectedClassnameClassLoader extends ClassLoader
{
private String[] includedClasses = null;
private String[] excludedClasses = null;
private String[] notFoundClasses = null;
private Log log = LogFactory.getLog(SelectedClassnameClassLoader.class);
private Map classes = new java.util.HashMap();
/**
* Creates a new classloader that loads the given classes.
*
* @param includedClasses array of class or package names that should be
* directly loaded by this loader. Classes
* whose name starts with any of the strings
* in this array will be loaded by this class,
* unless their name appears in
* excludedClasses.
* Can be null
* @param excludedClasses array of class or package names that should NOT
* be directly loaded by this loader. Loading of
* classes whose name starts with any of the
* strings in this array will be delegated to
* parent, even if the classes
* package or classname appears in
* includedClasses. Typically this
* parameter is used to exclude loading one or
* more classes in a package whose other classes
* are loaded by this object.
* @param parent ClassLoader to which loading of classes should
* be delegated if necessary
*/
public SelectedClassnameClassLoader(String[] includedClasses,
String[] excludedClasses,
ClassLoader parent)
{
super(parent);
this.includedClasses = includedClasses;
this.excludedClasses = excludedClasses;
}
/**
* Creates a new classloader that loads the given classes.
*
* @param includedClasses array of class or package names that should be
* directly loaded by this loader. Classes
* whose name starts with any of the strings
* in this array will be loaded by this class,
* unless their name appears in
* excludedClasses.
* Can be null
* @param excludedClasses array of class or package names that should NOT
* be directly loaded by this loader. Loading of
* classes whose name starts with any of the
* strings in this array will be delegated to
* parent, even if the classes
* package or classname appears in
* includedClasses. Typically this
* parameter is used to exclude loading one or
* more classes in a package whose other classes
* are loaded by this object.
* @param notFoundClasses array of class or package names for which this
* should raise a ClassNotFoundException
* @param parent ClassLoader to which loading of classes should
* be delegated if necessary
*/
public SelectedClassnameClassLoader(String[] includedClasses,
String[] excludedClasses,
String[] notFoundClasses,
ClassLoader parent)
{
super(parent);
this.includedClasses = includedClasses;
this.excludedClasses = excludedClasses;
this.notFoundClasses = notFoundClasses;
}
protected synchronized Class loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
log.info("In SelectedClassnameClassLoader.loadClass(" + name + "," + resolve + ")");
if (isIncluded(name) && (isExcluded(name) == false))
{
Class c = findClass(name);
if (resolve)
{
resolveClass(c);
}
return c;
}
else
{
return super.loadClass(name, resolve);
}
}
protected Class findClass(String name) throws ClassNotFoundException
{
log.info("In SelectedClassnameClassLoader.findClass()");
Class result = classes.get(name);
if (result != null)
{
return result;
}
if (isIncluded(name) && (isExcluded(name) == false))
{
try
{
InputStream is = getResourceAsStream(name.replace('.', '/').concat(".class"));
byte[] bytes = new byte[1024];
ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
int read;
while ((read = is.read(bytes)) > -1)
{
baos.write(bytes, 0, read);
}
bytes = baos.toByteArray();
result = this.defineClass(name, bytes, 0, bytes.length);
}
catch (FileNotFoundException e)
{
throw new ClassNotFoundException("cannot find " + name, e);
}
catch (IOException e)
{
throw new ClassNotFoundException("cannot read " + name, e);
}
}
else if (isNotFound(name))
{
throw new ClassNotFoundException(name + " is discarded");
}
else
{
result = super.findClass(name);
}
classes.put(name, result);
return result;
}
private boolean isIncluded(String className)
{
if (includedClasses != null)
{
for (int i = 0; i < includedClasses.length; i++)
{
if (className.startsWith(includedClasses[i]))
{
return true;
}
}
}
return false;
}
private boolean isExcluded(String className)
{
if (excludedClasses != null)
{
for (int i = 0; i < excludedClasses.length; i++)
{
if (className.startsWith(excludedClasses[i]))
{
return true;
}
}
}
return false;
}
private boolean isNotFound(String className)
{
if (notFoundClasses != null)
{
for (int i = 0; i < notFoundClasses.length; i++)
{
if (className.startsWith(notFoundClasses[i]))
{
return true;
}
}
}
return false;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/MethodIdPreservationTest.java 0000644 0001750 0001750 00000006150 11015045001 032026 0 ustar twerner twerner package org.jboss.cache.marshall;
import org.jboss.cache.Fqn;
import org.jboss.cache.commands.ReversibleCommand;
import org.jboss.cache.commands.tx.PrepareCommand;
import org.jboss.cache.commands.write.PutDataMapCommand;
import org.jboss.cache.factories.CommandsFactory;
import static org.testng.AssertJUnit.assertEquals;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
/**
* @author Manik Surtani
* @since 2.0.0
*/
@Test(groups = {"functional"})
public class MethodIdPreservationTest
{
private Marshaller m;
private ObjectOutputStream stream;
private ByteArrayOutputStream byteStream;
private ReversibleCommand command1;
private List list = new ArrayList(2);
private PrepareCommand prepareComand;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
byteStream = new ByteArrayOutputStream();
stream = new ObjectOutputStream(byteStream);
command1 = new PutDataMapCommand(null, Fqn.ROOT, null);
list.clear();
list.add(command1);
list.add(new PutDataMapCommand(null, Fqn.ROOT, null));
prepareComand = new PrepareCommand(null, list, null, true);
CacheMarshaller210 cm210 = new CacheMarshaller210();
CommandsFactory factory = new CommandsFactory();
cm210.injectCommandsFactory(factory);
m = cm210;
}
public void testSingleMethodCall() throws Exception
{
m.objectToObjectStream(command1, stream);
stream.close();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(byteStream.toByteArray()));
Object result = m.objectFromObjectStream(in);
assertEquals(command1.getClass(), result.getClass());
}
public void testListOfMethodCalls() throws Exception
{
m.objectToObjectStream(list, stream);
stream.close();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(byteStream.toByteArray()));
Object result = m.objectFromObjectStream(in);
assertEquals(list.getClass(), result.getClass());
assertEquals(list.size(), ((List) result).size());
assert ((List) result).get(0) instanceof PutDataMapCommand;
assert ((List) result).get(1) instanceof PutDataMapCommand;
}
public void testMethodCallsInPrepare() throws Exception
{
m.objectToObjectStream(prepareComand, stream);
stream.close();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(byteStream.toByteArray()));
Object result = m.objectFromObjectStream(in);
assertEquals(prepareComand.getClass(), result.getClass());
PrepareCommand prepareCallRes = (PrepareCommand) result;
List listResult = prepareCallRes.getModifications();
assertEquals(list.size(), listResult.size());
assert listResult.get(0) instanceof PutDataMapCommand;
assert listResult.get(1) instanceof PutDataMapCommand;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/MyList.java 0000644 0001750 0001750 00000000257 10665031725 026334 0 ustar twerner twerner package org.jboss.cache.marshall;
import java.util.ArrayList;
public class MyList extends ArrayList
{
private static final long serialVersionUID = 773098444170102370L;
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/marshall/CacheMarshaller200Test.java 0000644 0001750 0001750 00000023043 11066201252 031177 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.marshall;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.RegionManager;
import org.jboss.cache.commands.remote.ClusteredGetCommand;
import org.testng.annotations.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
@Test(groups = {"functional"})
public class CacheMarshaller200Test extends CacheMarshallerTestBase
{
public CacheMarshaller200Test()
{
currentVersion = "2.0.0.GA";
currentVersionShort = 20;
expectedMarshallerClass = CacheMarshaller200.class;
}
public void testBadEquals() throws Exception
{
// object1 and Object2 should NOT be equal, even though their equals() methods are broken.
Broken o1 = new Broken();
Broken o2 = new Broken();
o1.name = "o1";
o2.name = "o2";
assert o1 != o2;
assert o1.equals(o2);
List l = new ArrayList(2); // lists will allow "duplicate" entries.
l.add(o1);
l.add(o2);
CacheMarshaller200 cm200 = new CacheMarshaller200();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
cm200.objectToObjectStream(l, out);
out.close();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bout.toByteArray()));
List l2 = (List) cm200.objectFromObjectStream(in);
assert l2.size() == 2;
assert l2.get(0).name.equals("o1");
assert l2.get(1).name.equals("o2");
assert l2.get(0) != l2.get(1);
assert l2.get(0).equals(l2.get(1));
}
public void testRegionalisedStream() throws Exception
{
// need to test what's going on with
CacheMarshaller200 cm200 = new CacheMarshaller200();
c.setUseRegionBasedMarshalling(true);
cm200.injectDependencies(new RegionManager(), c, getClass().getClassLoader());
cm200.init();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
cm200.objectToObjectStream("Hello World", oos, Fqn.fromString("/hello"));
oos.close();
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
// test that the first thing on the stream is the fqn!
byte magic = ois.readByte();
short ref = ois.readShort();
System.out.println("Magic number is " + magic);
assert magic == CacheMarshaller200.MAGICNUMBER_FQN;
// now the chunks of an Fqn
Fqn f = cm200.unmarshallFqn(ois, new UnmarshalledReferences());
assert f.equals(Fqn.fromString("/hello"));
}
/**
* This test emulates the behaviour observed when an incoming method call is unmarshalled (using objectFromOutputStream),
* region based marshalling is used, and it is expected that we would need to marshall the response using the same
* region as well. To deal with this, the region (as an Fqn) is read off the stream when unmarshalling and then
* stored in a ThreadLocal so it can be accessed for when the response needs to be marshalled again.
*
* The problem here - registered as JBCACHE-1170 - is that this has a tendency to leak scope and affect more than the
* required method call.
*/
public void testLeakageOfFqn() throws Throwable
{
// Use a thread pool so that we know threads will be reused.
// You don't need any concurrency here to demonstrate the failure - a single thread is enough.
ExecutorService e = Executors.newFixedThreadPool(1);
// to capture throwables
final List throwables = new CopyOnWriteArrayList();
// each thread will perform 1 of 3 tasks:
// 1. unmarshall a stream, and marshall a response - typical case such as a clustered get
// 2. unmarshall a stream, and marshall a 'void' response.
// 3. marshall a (primitive response) - case such as a state transfer sending out boolean status
// first create a stream to unmarshall.
// RegionManager rm = new RegionManager();
final CacheMarshaller200 cm200 = new CacheMarshaller200();
c.setInactiveOnStartup(false);
c.setUseRegionBasedMarshalling(true);
c.setCacheMarshaller(cm200);
cr.registerComponent(cm200, CacheMarshaller200.class);
cr.rewire();
cr.start();
RegionManager rm = cr.getComponent(RegionManager.class);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
final Fqn region = Fqn.fromString("/hello");
Region r = rm.getRegion(region, true);
r.registerContextClassLoader(this.getClass().getClassLoader());
cm200.objectToObjectStream(new ClusteredGetCommand(false, null), oos, region);
oos.close();
final byte[] stream = baos.toByteArray();
// so now the stream starts with the Fqn "/hello".
// repeat 100 times
for (int i = 0; i < 100; i++)
{
if (i % 3 == 0)
{
// task 1 above
e.execute(new Runnable()
{
public void run()
{
try
{
RegionalizedMethodCall rmc = cm200.regionalizedMethodCallFromObjectStream(new ObjectInputStream(new ByteArrayInputStream(stream)));
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream outStream = new ObjectOutputStream(out);
RegionalizedReturnValue rrv = new RegionalizedReturnValue("A result", rmc);
cm200.objectToObjectStream(rrv, outStream);
outStream.close();
out.close();
// test that the output stream has got "/hello" as it's region Fqn.
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(out.toByteArray()));
assert in.readByte() == CacheMarshaller200.MAGICNUMBER_FQN : "The stream should start with an Fqn";
// discard the nest refId short
in.readShort();
Fqn f = cm200.unmarshallFqn(in, new UnmarshalledReferences());
assert region.equals(f) : "Should use the same region for the response as was used for the request!";
}
catch (Throwable t)
{
throwables.add(t);
}
}
});
}
else if (i % 3 == 1)
{
// task 2 above
e.execute(new Runnable()
{
public void run()
{
try
{
cm200.objectFromObjectStream(new ObjectInputStream(new ByteArrayInputStream(stream)));
// and now just send back a 'void' return type (In JGroups this is treated as a null)
cm200.objectToObjectStream(null, new ObjectOutputStream(new ByteArrayOutputStream()));
}
catch (Throwable t)
{
throwables.add(t);
}
}
});
}
else if (i % 3 == 2)
{
// task 3 above
e.execute(new Runnable()
{
public void run()
{
try
{
// and now don't bother with any umarshalling
// directly marshall a boolean.
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream outStream = new ObjectOutputStream(out);
cm200.objectToObjectStream(true, outStream);
outStream.close();
out.close();
// test that the output stream has got "/hello" as it's region Fqn.
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(out.toByteArray()));
byte magic = in.readByte();
assert magic != CacheMarshaller200.MAGICNUMBER_FQN : "The stream should NOT start with an Fqn!";
assert magic == CacheMarshaller200.MAGICNUMBER_NULL : "Should start with a NULL. Instead, was " + magic;
assert in.readByte() == CacheMarshaller200.MAGICNUMBER_BOOLEAN : "Should have a boolean magic number before the boolean value";
assert in.readBoolean() : "The boolean written to the stream should be true";
}
catch (Throwable t)
{
throwables.add(t);
}
}
});
}
}
e.shutdown();
e.awaitTermination(60, TimeUnit.SECONDS);
for (Throwable t : throwables)
{
t.printStackTrace();
}
assert throwables.size() == 0 : "Should not have caught any exceptions!";
}
}
class Broken implements Serializable
{
String name;
@Override
public boolean equals(Object o)
{
return true;
}
@Override
public int hashCode()
{
return 10;
}
}
jbosscache-core-2.2.2.GA/src/test/java/org/jboss/cache/FqnTest.java 0000644 0001750 0001750 00000031044 11021223332 024652 0 ustar twerner twerner /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.marshall.CacheMarshaller210;
import org.jboss.cache.marshall.Marshaller;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.HashMap;
/**
* Tests {@link Fqn}.
*
* @author Bela Ban May 9, 2003
* @version $Revision: 5938 $
*/
@Test(groups = "unit")
public class FqnTest
{
private Cache cache;
private Marshaller marshaller;
@BeforeTest
protected void setUp()
{
cache = null;
marshaller = new CacheMarshaller210();
}
@AfterTest
protected void tearDown()
{
if (cache != null)
{
cache.stop();
cache = null;
}
}
public void testNull()
{
Fqn fqn = Fqn.ROOT;
log("null fqn is " + fqn);
assert 0 == fqn.size();
int hcode = fqn.hashCode();
assert hcode != -1;
}
public void testOne()
{
Fqn fqn = Fqn.fromElements(22);
log("one fqn is " + fqn);
assert 1 == fqn.size();
int hcode = fqn.hashCode();
assert hcode != -1;
}
public void testEmptyFqn()
{
Fqn f1 = Fqn.ROOT;
Fqn f2 = Fqn.ROOT;
assert f1.equals(f2);
}
public void testFqn()
{
Fqn fqn = Fqn.fromString("/a/b/c");
log("fqn is " + fqn);
assert 3 == fqn.size();
Fqn fqn2 = Fqn.fromElements("a", "b", "c");
log("fqn2 is " + fqn2);
assert 3 == fqn.size();
assert fqn.equals(fqn2);
assert fqn.hashCode() == fqn2.hashCode();
}
public void testHereogeneousNames()
{
Fqn fqn = Fqn.fromElements("string", 38, true);
log("fqn is " + fqn);
assert 3 == fqn.size();
Fqn fqn2 = Fqn.fromElements("string", 38, true);
assert fqn.equals(fqn2);
assert fqn.hashCode() == fqn2.hashCode();
}
public void testHashcode()
{
Fqn fqn1, fqn2;
fqn1 = Fqn.fromElements("a", "b", "c");
fqn2 = Fqn.fromString("/a/b/c");
log("fqn is " + fqn1);
assert fqn1.equals(fqn2);
HashMap map = new HashMap();
map.put(fqn1, 33);
map.put(fqn2, 34);
assert map.size() == 1;
assert map.get(fqn1).equals(34);
}
public void testHashcode2()
{
Fqn fqn = Fqn.fromElements(-1);
log("one fqn is " + fqn);
assert fqn.size() == 1;
int hcode = fqn.hashCode();
assert hcode == -1;
}
public void testEquals()
{
Fqn fqn1 = Fqn.fromElements("person/test");
Fqn f1, f2, f3;
f1 = Fqn.fromRelativeElements(fqn1, "0");
f2 = Fqn.fromRelativeElements(fqn1, "1");
f3 = Fqn.fromRelativeElements(fqn1, "2");
HashMap map = new HashMap();
map.put(f1, "0");
map.put(f2, "1");
map.put(f3, "2");
assert map.get(Fqn.fromRelativeElements(fqn1, "0")) != null;
assert map.get(Fqn.fromRelativeElements(fqn1, "1")) != null;
assert map.get(Fqn.fromRelativeElements(fqn1, "2")) != null;
}
public void testEquals2()
{
Fqn f1;
Fqn f2;
f1 = Fqn.fromString("/a/b/c");
f2 = Fqn.fromString("/a/b/c");
assert f1.equals(f2);
f2 = Fqn.fromString("/a/b");
assert !f1.equals(f2);
f2 = Fqn.fromString("/a/b/c/d");
assert !f1.equals(f2);
}
public void testEquals2WithMarshalling() throws Exception
{
Fqn f1, f2;
f1 = Fqn.fromString("/a/b/c");
f2 = marshalAndUnmarshal(f1);
assert f1.equals(f2);
}
public void testEquals3()
{
Fqn f1;
Fqn f2;
f1 = Fqn.fromElements("a", 322649, Boolean.TRUE);
f2 = Fqn.ROOT;
assert !f1.equals(f2);
assert !f2.equals(f1);
f2 = Fqn.fromString("a/322649/TRUE");
assert !f1.equals(f2);
f2 = Fqn.fromElements("a", 322649, Boolean.FALSE);
assert !f1.equals(f2);
f2 = Fqn.fromElements("a", 322649, Boolean.TRUE);
assert f1.equals(f2);
}
public void testEquals3WithMarshalling() throws Exception
{
Fqn f1, f2;
f1 = Fqn.fromElements("a", 322649, Boolean.TRUE);
f2 = marshalAndUnmarshal(f1);
assert f1.equals(f2);
assert f2.equals(f1);
Fqn f3 = Fqn.fromString("a/322649/TRUE");
f3 = marshalAndUnmarshal(f3);
assert !f1.equals(f3);
f2 = Fqn.fromElements("a", 322649, Boolean.FALSE);
f2 = marshalAndUnmarshal(f2);
assert !f1.equals(f2);
f2 = Fqn.fromElements("a", 322649, Boolean.TRUE);
f2 = marshalAndUnmarshal(f2);
assert f1.equals(f2);
}
public void testEquals4()
{
Fqn fqn = Fqn.fromString("X");
// Check casting
assert !fqn.equals("X");
// Check null
assert !fqn.equals(null);
}
public void testClone() throws CloneNotSupportedException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = fqn1.clone();
assert fqn1.equals(fqn2);
assert fqn1.hashCode() == fqn2.hashCode();
}
public void testNullElements() throws CloneNotSupportedException
{
Fqn