jbosscache-core-3.2.8.GA/ 0000755 0001750 0001750 00000000000 11675222145 014731 5 ustar moeller moeller jbosscache-core-3.2.8.GA/README-COMMITTERS.txt 0000644 0001750 0001750 00000001167 11111047320 020101 0 ustar moeller moeller Before committing anything, PLEASE make sure you have the following in your ~/.subversion/config.
This will ensure files have the *correct* line endings. Note: we do not use native since cygwin
users like LF endings. Also be sure that your IDE uses this config:
[miscellany]
enable-auto-props = yes
[auto-props]
*.java = svn:keywords=Id Revision;svn:eol-style=LF
*.xml = svn:keywords=Id Revision;svn:eol-style=LF
*.wsdl = svn:keywords=Id Revision;svn:eol-style=LF
*.xsd = svn:keywords=Id Revision;svn:eol-style=LF
*.txt = svn:keywords=Id Revision;svn:eol-style=LF
*.sh = svn:keywords=Id Revision;svn:eol-style=LF;svn:executable
jbosscache-core-3.2.8.GA/README-Maven.txt 0000644 0001750 0001750 00000021762 11363357042 017502 0 ustar moeller moeller
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 groups run are the "unit" and "functional".
* 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.
Important! Please note that if you try to generate user documentation using OpenJDK (at least build 14.0-b15) you might see an
exception like this:
java.lang.NullPointerException
at org.apache.fop.render.pdf.FopPDFImage.setup(FopPDFImage.java:144)
at org.apache.fop.pdf.PDFDocument.addImage(PDFDocument.java:794)
at org.apache.fop.render.pdf.PDFRenderer.putImage(PDFRenderer.java:1725)
at org.apache.fop.render.pdf.PDFRenderer.renderImage(PDFRenderer.java:1652)
...
This appears to be a known issue: https://lists.launchpad.net/openjdk/msg00820.html. To get around the issue, simply switch
to Sun JDK 5 or 6 to generate documentation.
* 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 username and password to make releases and shapshot release
--------------------------------------------------------------------------------
You will also have to configure maven to use your username and password to access the 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:
...
...
jboss-developer
jboss.org username
jboss.org password
jboss-snapshots
jboss.org username
jboss.org password
jboss-releases
jboss.org username
jboss.org password
...
...
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.
The JBoss repository will hold this release in a staging directory which can be accessed by logging in to
https://repository.jboss.org/nexus
After verifying the POM and the artifacts in Nexus, you can then close the repository and push the relase live.
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-3.2.8.GA/assembly/ 0000755 0001750 0001750 00000000000 11675221271 016547 5 ustar moeller moeller jbosscache-core-3.2.8.GA/assembly/assembly-1.1.0-SNAPSHOT.xsd 0000644 0001750 0001750 00000173017 11057166721 023011 0 ustar moeller moeller
1.0.0+
An assembly defines a collection of files usually distributed in an
archive format such as zip, tar, or tar.gz that is generated from a
project. For example, a project could produce a ZIP assembly which
contains a project's JAR artifact in the root directory, the
runtime dependencies in a lib/ directory, and a shell script to launch
a stand-alone application.
1.0.0+
An assembly defines a collection of files usually distributed in an
archive format such as zip, tar, or tar.gz that is generated from a
project. For example, a project could produce a ZIP assembly which
contains a project's JAR artifact in the root directory, the
runtime dependencies in a lib/ directory, and a shell script to launch
a stand-alone application.
1.0.0+
Sets the id of this assembly. This is a symbolic name for a
particular assembly of files from this project. Also, aside from
being used to distinctly name the assembled package by attaching
its value to the generated archive, the id is used as your
artifact's classifier when deploying.
1.0.0+
Specifies the formats of the assembly. Multiple formats can be
supplied and the Assembly Plugin will generate an archive for each
desired formats. When deploying your project, all file formats
specified will also be deployed. A format is specified by supplying
one of the following values in a <format> subelement:
<ul>
<li><b>"zip"</b> - Creates a ZIP file format</li>
<li><b>"gz"</b> - Creates a GZIP format</li>
<li><b>"tar"</b> - Creates a TAR format</li>
<li><b>"tar.gz"</b> - Creates a gzip'd TAR format</li>
<li><b>"tar.bz2</b> - Creates a bzip'd TAR format</li>
</ul>
0.0.0+
Includes a base directory in the final archive. For example,
if you are creating an assembly named "your-app", setting
includeBaseDirectory to true will create an archive that
includes this base directory. If this option is set to false
the archive created will unzip its content to the current
directory. Default value is true.
1.1.0
Sets the base directory of the resulting assembly archive. If this is not
set and includeBaseDirectory == true, ${project.build.finalName} will be used instead.
0.0.0+
Includes a site directory in the final archive. The site directory
location of a project is determined by the siteDirectory parameter
of the Assembly Plugin. Default value is false.
1.0.0+
Specifies which module files to include in the assembly. A moduleSet
is specified by providing one or more of <moduleSet>
subelements.
1.0.0+
Specifies which groups of files to include in the assembly. A
fileSet is specified by providing one or more of <fileSet>
subelements.
1.0.0+
Specifies which single files to include in the assembly. A file
is specified by providing one or more of <file>
subelements.
1.0.0+
Specifies which dependencies to include in the assembly. A
dependencySet is specified by providing one or more of
<dependencySet> subelements.
1.0.0+
Specifies which repository files to include in the assembly. A
repository is specified by providing one or more of
<repository> subelements.
1.0.0+
Specifies the shared components xml file locations to include in the
assembly. The locations specified must be relative to the basedir of
the project. When multiple componentDescriptors are found, their
contents are merged. Check out the <a href="component.html">
descriptor components</a> for more information. A
componentDescriptor is specified by providing one or more of
<componentDescriptor> subelements.
1.0.0+
Defines a Maven repository to be included in the assembly. The artifacts
available to be included in a repository are your project's dependency
artifacts. The repository created contains the needed metadata entries
and also contains both sha1 and md5 checksums. This is useful for creating
archives which will be deployed to internal repositories.
<br/><b>NOTE:</b> Currently, only artifacts from the central repository
are allowed.
1.0.0+
If set to true, this property will trigger the creation of repository
metadata which will allow the repository to be used as a functional remote
repository. Default value is false.
1.0.0+
Specifies that you want to align a group of artifacts to a specified
version. A groupVersionAlignment is specified by providing one or
more of <groupVersionAlignment> subelements.
1.1.0
Specifies the scope for artifacts included in this repository.
Default scope value is "runtime".
1.1.0
When specified as true, any include/exclude patterns which aren't used to filter an actual
artifact during assembly creation will cause the build to fail with an error. This is meant
to highlight obsolete inclusions or exclusions, or else signal that the assembly descriptor
is incorrectly configured.
1.1.0
Whether standard exclusion patterns, such as those matching CVS and Subversion
metadata files, should be used when calculating the files affected by this set.
For backward compatibility, the default value is true.
1.0.0+
Sets the output directory relative to the root
of the root directory of the assembly. For example,
"log" will put the specified files in the log directory.
1.0.0+
When <include> subelements are present, they define a set of
files and directory to include. If none is present, then
<includes> represents all valid values.
1.0.0+
When <exclude> subelements are present, they define a set of
files and directory to exclude. If none is present, then
<excludes> represents no exclusions.
1.0.0+
Similar to a UNIX permission, sets the file mode of the files included.
Format: (User)(Group)(Other) where each component is a sum of Read = 4,
Write = 2, and Execute = 1. For example, the default value of 0644
translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
Similar to a UNIX permission, sets the directory mode of the directories
included. Format: (User)(Group)(Other) where each component is a sum of
Read = 4, Write = 2, and Execute = 1. For example, the default value of
0755 translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
Allows a group of artifacts to be aligned to a specified version.
1.0.0+
The groupId of the artifacts for which you want to align the
versions.
1.0.0+
The version you want to align this group to.
1.0.0+
When <exclude> subelements are present, they define the
artifactIds of the artifacts to exclude. If none is present, then
<excludes> represents no exclusions. An exclude is specified
by providing one or more of <exclude> subelements.
1.0.0+
A dependencySet allows inclusion and exclusion of project dependencies
in the assembly.
1.0.0+
Sets the mapping pattern for all dependencies included in this
assembly. Default is ${artifactId}-${version}.${extension}.
1.0.0+
If set to true, this property will unpack all dependencies
into the specified output directory. When set to false
dependencies will be includes as archives (jars). Can only unpack
jar, zip, tar.gz, and tar.bz archives. Default value is false.
1.1.0
Allows the specification of includes and excludes, along with filtering options, for items
unpacked from a dependency artifact.
1.0.0+
Sets the dependency scope for this dependencySet.
Default scope value is "runtime".
1.1.0
When specified as true, any include/exclude patterns which aren't used to filter an actual
artifact during assembly creation will cause the build to fail with an error. This is meant
to highlight obsolete inclusions or exclusions, or else signal that the assembly descriptor
is incorrectly configured.
1.1.0
Whether standard exclusion patterns, such as those matching CVS and Subversion
metadata files, should be used when calculating the files affected by this set.
For backward compatibility, the default value is true.
1.0.0+
Sets the output directory relative to the root
of the root directory of the assembly. For example,
"log" will put the specified files in the log directory.
1.0.0+
When <include> subelements are present, they define a set of
files and directory to include. If none is present, then
<includes> represents all valid values.
1.0.0+
When <exclude> subelements are present, they define a set of
files and directory to exclude. If none is present, then
<excludes> represents no exclusions.
1.0.0+
Similar to a UNIX permission, sets the file mode of the files included.
Format: (User)(Group)(Other) where each component is a sum of Read = 4,
Write = 2, and Execute = 1. For example, the default value of 0644
translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
Similar to a UNIX permission, sets the directory mode of the directories
included. Format: (User)(Group)(Other) where each component is a sum of
Read = 4, Write = 2, and Execute = 1. For example, the default value of
0755 translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.1.0
Specifies options for including/excluding/filtering items extracted from an archive.
1.1.0
Set of patterns for matching items to be included from an archive as it is unpacked.
1.1.0
Set of patterns for matching items to be excluded from an archive as it is unpacked.
1.1.0
Whether to filter symbols in the files as they are unpacked from the archive, using
properties from the build configuration.
1.0.0+
A moduleSet represent one or more project <module> present inside
a project's pom.xml. This allows you to include sources or binaries
belonging to a project's <modules>.
<br/><b>NOTE:</b> When using <moduleSets> from the command-line, it
is required to pass first the package phase by doing: "mvn package
assembly:assembly". This bug/issue is scheduled to be addressed by Maven 2.1.
1.1.0
If set to false, the plugin will exclude sub-modules from processing in this ModuleSet.
Otherwise, it will process all sub-modules, each subject to include/exclude rules.
Default value is true.
1.0.0+
This is a list of <include/> subelements, each containing a
module reference of the type groupId:artifactId. Modules matching
these elements will be included in this set. If none is present,
then <includes> represents all valid values.
1.0.0+
This is a list of <exclude/> subelements, each containing a
module reference of the type groupId:artifactId. Modules matching
these elements will be excluded from this set.
1.0.0+
When this is present, the plugin will include the source files of
the included modules from this set in the resulting assembly.
1.0.0+
When this is present, the plugin will include the binaries of the
included modules from this set in the resulting assembly.
1.0.0+
Contains configuration options for including the source files of a
project module in an assembly.
1.1.0
Specifies which groups of files from each included module to include in the assembly. A
fileSet is specified by providing one or more of <fileSet> subelements.
1.1.0
Specifies whether the module's finalName should be prepended to the outputDirectory
values of any fileSets applied to it. Default value is true.
1.1.0
Specifies whether sub-module directories below the current module should be excluded
from fileSets applied to that module. This might be useful if you only mean to copy
the sources for the exact module list matched by this ModuleSet, ignoring (or processing
separately) the modules which exist in directories below the current one.
Default value is true.
1.1.0
Sets the mapping pattern for all module base-directories included in this assembly.
NOTE: This field is only used if includeModuleDirectory == true.
Default is the module's ${artifactId}.
1.1.0
When specified as true, any include/exclude patterns which aren't used to filter an actual
artifact during assembly creation will cause the build to fail with an error. This is meant
to highlight obsolete inclusions or exclusions, or else signal that the assembly descriptor
is incorrectly configured.
1.1.0
Whether standard exclusion patterns, such as those matching CVS and Subversion
metadata files, should be used when calculating the files affected by this set.
For backward compatibility, the default value is true.
1.0.0+
Sets the output directory relative to the root
of the root directory of the assembly. For example,
"log" will put the specified files in the log directory.
1.0.0+
When <include> subelements are present, they define a set of
files and directory to include. If none is present, then
<includes> represents all valid values.
1.0.0+
When <exclude> subelements are present, they define a set of
files and directory to exclude. If none is present, then
<excludes> represents no exclusions.
1.0.0+
Similar to a UNIX permission, sets the file mode of the files included.
Format: (User)(Group)(Other) where each component is a sum of Read = 4,
Write = 2, and Execute = 1. For example, the default value of 0644
translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
Similar to a UNIX permission, sets the directory mode of the directories
included. Format: (User)(Group)(Other) where each component is a sum of
Read = 4, Write = 2, and Execute = 1. For example, the default value of
0755 translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
A fileSet allows the inclusion of groups of files into the assembly.
1.0.0+
Sets the absolute or relative location from the module's
directory. For example, "src/main/bin" would select this
subdirectory of the project in which this dependency is defined.
1.0.0+
Sets the line-endings of the files in this fileSet.
Valid values:
<ul>
<li><b>"keep"</b> - Preserve all line endings</li>
<li><b>"unix"</b> - Use Unix-style line endings</li>
<li><b>"lf"</b> - Use a single line-feed line endings</li>
<li><b>"dos"</b> - Use DOS-style line endings</li>
<li><b>"crlf"</b> - Use Carraige-return, line-feed line endings</li>
</ul>
1.1.0
Whether to filter symbols in the files as they are copied, using
properties from the build configuration.
1.1.0
When specified as true, any include/exclude patterns which aren't used to filter an actual
artifact during assembly creation will cause the build to fail with an error. This is meant
to highlight obsolete inclusions or exclusions, or else signal that the assembly descriptor
is incorrectly configured.
1.1.0
Whether standard exclusion patterns, such as those matching CVS and Subversion
metadata files, should be used when calculating the files affected by this set.
For backward compatibility, the default value is true.
1.0.0+
Sets the output directory relative to the root
of the root directory of the assembly. For example,
"log" will put the specified files in the log directory.
1.0.0+
When <include> subelements are present, they define a set of
files and directory to include. If none is present, then
<includes> represents all valid values.
1.0.0+
When <exclude> subelements are present, they define a set of
files and directory to exclude. If none is present, then
<excludes> represents no exclusions.
1.0.0+
Similar to a UNIX permission, sets the file mode of the files included.
Format: (User)(Group)(Other) where each component is a sum of Read = 4,
Write = 2, and Execute = 1. For example, the default value of 0644
translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
Similar to a UNIX permission, sets the directory mode of the directories
included. Format: (User)(Group)(Other) where each component is a sum of
Read = 4, Write = 2, and Execute = 1. For example, the default value of
0755 translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
Contains configuration options for including the binary files of a
project module in an assembly.
1.1.0
When specified, the attachmentClassifier will cause the assembler to look at artifacts
attached to the module instead of the main project artifact. If it can find an attached
artifact matching the specified classifier, it will use it; otherwise, it will throw an
exception.
1.0.0+
If set to true, the plugin will include the direct and transitive dependencies of
of the project modules included here. Otherwise, it will only include the module
packages only. Default value is true.
1.1.0
Specifies which dependencies of the module to include in the assembly. A
dependencySet is specified by providing one or more of
<dependencySet> subelements.
1.0.0+
If set to true, this property will unpack all module packages
into the specified output directory. When set to false
module packages will be included as archives (jars).
Default value is true.
1.1.0
Allows the specification of includes and excludes, along with filtering options, for items
unpacked from a module artifact.
1.0.0+
Sets the mapping pattern for all dependencies included
in this assembly.
Default is ${artifactId}-${version}.${extension}.
1.1.0
When specified as true, any include/exclude patterns which aren't used to filter an actual
artifact during assembly creation will cause the build to fail with an error. This is meant
to highlight obsolete inclusions or exclusions, or else signal that the assembly descriptor
is incorrectly configured.
1.1.0
Whether standard exclusion patterns, such as those matching CVS and Subversion
metadata files, should be used when calculating the files affected by this set.
For backward compatibility, the default value is true.
1.0.0+
Sets the output directory relative to the root
of the root directory of the assembly. For example,
"log" will put the specified files in the log directory.
1.0.0+
When <include> subelements are present, they define a set of
files and directory to include. If none is present, then
<includes> represents all valid values.
1.0.0+
When <exclude> subelements are present, they define a set of
files and directory to exclude. If none is present, then
<excludes> represents no exclusions.
1.0.0+
Similar to a UNIX permission, sets the file mode of the files included.
Format: (User)(Group)(Other) where each component is a sum of Read = 4,
Write = 2, and Execute = 1. For example, the default value of 0644
translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
Similar to a UNIX permission, sets the directory mode of the directories
included. Format: (User)(Group)(Other) where each component is a sum of
Read = 4, Write = 2, and Execute = 1. For example, the default value of
0755 translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
A file allows individual file inclusion with the option to change
the destination filename not supported by fileSets.
1.0.0+
Sets the absolute or relative path from the module's directory
of the file to be included in the assembly.
1.0.0+
Sets the output directory relative to the root
of the root directory of the assembly. For example,
"log" will put the specified files in the log directory.
1.0.0+
Sets the destination filename in the outputDirectory.
Default is the same name as the source's file.
1.0.0+
Similar to a UNIX permission, sets the file mode of the files included.
Format: (User)(Group)(Other) where each component is a sum of Read = 4,
Write = 2, and Execute = 1. For example, the default value of 0644
translates to User read-write, Group and Other read-only.
<a href="http://www.onlamp.com/pub/a/bsd/2000/09/06/FreeBSD_Basics.html">(more on
unix-style permissions)</a>
1.0.0+
Sets the line-endings of the files in this file.
Valid values are:
<ul>
<li><b>"keep"</b> - Preserve all line endings</li>
<li><b>"unix"</b> - Use Unix-style line endings</li>
<li><b>"lf"</b> - Use a single line-feed line endings</li>
<li><b>"dos"</b> - Use DOS-style line endings</li>
<li><b>"crlf"</b> - Use Carraige-return, line-feed line endings</li>
</ul>
1.0.0+
Sets whether to determine if the file is filtered.
jbosscache-core-3.2.8.GA/assembly/doc.xml 0000644 0001750 0001750 00000002030 11057166721 020033 0 ustar moeller moeller
doc
zip
true
src/main/release
*.txt
**lib**
license/*
target/site/apidocs
doc/apidocs
target/docbook
doc/
jbosscache-core-3.2.8.GA/assembly/src.xml 0000644 0001750 0001750 00000001627 11057166721 020070 0 ustar moeller moeller
src
zip
true
target/**
output/**
test-output/**
jbossdb/**
*.jdb
*.iml
*.ipr
*.iws
*.log
*.lck
jbosscache-core-3.2.8.GA/assembly/all.xml 0000644 0001750 0001750 00000006021 11074713752 020043 0 ustar moeller moeller
all
zip
true
target
*.jar
*test*.jar
src/main/resources
etc
**/*.sh
src/main/resources
etc
**/*.sh
0777
src/test/resources
etc
log4j.xml
src/main/release
**/*.txt
target/site/apidocs
doc/apidocs
target/docbook
doc/
src/main/tutorial
tutorial/
target
tutorial/lib/
**/jbosscache-core-tests.jar
lib
${artifactId}.${extension}
false
runtime
tutorial/lib
${artifactId}.${extension}
false
test
jbosscache-core-3.2.8.GA/assembly/bin.xml 0000644 0001750 0001750 00000004221 11057166721 020042 0 ustar moeller moeller
bin
zip
true
target
*.jar
*test*.jar
*sources*.jar
src/main/resources
etc
**/*.sh
src/main/resources
etc
**/*.sh
0777
src/test/resources
etc
log4j.xml
src/main/release
**/*.txt
lib
${artifactId}.${extension}
false
runtime
jbosscache-core-3.2.8.GA/fixlineendings.sh 0000755 0001750 0001750 00000000716 11111047320 020263 0 ustar moeller moeller #!/bin/bash
find src -name \*.java -or -name \*.xml -or -name \*.txt -or -name \*.xsd -or -name \*.sh | xargs svn ps --force svn:eol-style LF
find src -name \*.java -or -name \*.xml -or -name \*.txt -or -name \*.xsd -or -name \*.sh | xargs svn ps --force svn:keywords 'Id Revision'
find src -name \*.sh | xargs svn ps svn:executable on
svn ps --force svn:eol-style LF *.txt *.sh
svn ps --force svn:keywords 'Id Revision' *.txt *.sh
svn ps svn:executable on *.sh
jbosscache-core-3.2.8.GA/src/ 0000755 0001750 0001750 00000000000 11675221627 015524 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/ 0000755 0001750 0001750 00000000000 11675221613 016476 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/ 0000755 0001750 0001750 00000000000 11675221272 017420 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/ 0000755 0001750 0001750 00000000000 11675221273 020210 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/ 0000755 0001750 0001750 00000000000 11675221273 021330 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/ 0000755 0001750 0001750 00000000000 11675221612 022370 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/ 0000755 0001750 0001750 00000000000 11675221302 024343 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/LifeCycleTest.java 0000644 0001750 0001750 00000022467 11121730272 027715 0 ustar moeller moeller package org.jboss.cache.factories;
import org.jboss.cache.CacheException;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.CacheStatus;
import org.jboss.cache.Fqn;
import org.jboss.cache.ReplicationException;
import org.jboss.cache.SuspectException;
import org.jboss.cache.config.Configuration;
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.util.TestingUtil;
import org.testng.AssertJUnit;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
import javax.transaction.NotSupportedException;
import javax.transaction.RollbackException;
import javax.transaction.SystemException;
import javax.transaction.TransactionManager;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import org.jboss.cache.UnitTestCacheFactory;
/**
* Tests restart (stop-destroy-create-start) of ComponentRegistry
*
* @author Bela Ban
* @version $Id: LifeCycleTest.java 7332 2008-12-16 13:44:26Z mircea.markus $
*/
@Test(groups = "functional", sequential = true, testName = "factories.LifeCycleTest")
public class LifeCycleTest
{
private CacheSPI[] c;
@AfterMethod
public void tearDown()
{
TestingUtil.killCaches(c);
c = null;
}
@SuppressWarnings("unchecked")
private void createAndRegisterCache(Configuration.CacheMode mode, boolean start) throws Exception
{
CacheSPI cache = createCache(mode);
List> caches = new LinkedList>();
if (c != null) caches.addAll(Arrays.asList(c));
caches.add(cache);
c = caches.toArray(new CacheSPI[]{});
if (start)
{
cache.start();
if (c.length > 1) TestingUtil.blockUntilViewsReceived(c, 10000);
}
}
public void testLocalRestartNoTransactions() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, true);
c[0].put("/a/b/c", null);
assertTrue(c[0].getNumberOfNodes() > 0);
assertEquals(0, c[0].getNumberOfLocksHeld());
restartCache(c[0]);
assertEquals(0, c[0].getNumberOfNodes());
assertEquals(0, c[0].getNumberOfLocksHeld());
}
public void testLocalRestartWithTransactionsPessimistic() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, false);
c[0].getConfiguration().setNodeLockingScheme(Configuration.NodeLockingScheme.PESSIMISTIC);
c[0].start();
TransactionManager tm = beginTransaction();
c[0].put("/a/b/c", null);
assertTrue(c[0].getNumberOfNodes() > 0);
assertEquals(4, c[0].getNumberOfLocksHeld());
restartCache(c[0]);
//assertEquals(4, cache.getNumberOfLocksHeld());
assertEquals(0, c[0].getNumberOfNodes());
tm.rollback();
assertEquals(0, c[0].getNumberOfLocksHeld());
}
public void testStartNoCreate() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, false);
c[0].start();
c[0].put("/a/b/c", null);
assertTrue(c[0].getNumberOfNodes() > 0);
assertEquals(0, c[0].getNumberOfLocksHeld());
restartCache(c[0]);
assertEquals(0, c[0].getNumberOfNodes());
assertEquals(0, c[0].getNumberOfLocksHeld());
}
public void testReStartNoCreate() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, false);
c[0].start();
c[0].stop();
c[0].start();
c[0].put("/a/b/c", null);
assertTrue(c[0].getNumberOfNodes() > 0);
assertEquals(0, c[0].getNumberOfLocksHeld());
restartCache(c[0]);
assertEquals(0, c[0].getNumberOfNodes());
assertEquals(0, c[0].getNumberOfLocksHeld());
}
public void testDuplicateInvocation() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, false);
c[0].create();
c[0].start();
c[0].create();
c[0].start();
c[0].put("/a/b/c", null);
assertTrue(c[0].getNumberOfNodes() > 0);
assertEquals(0, c[0].getNumberOfLocksHeld());
restartCache(c[0]);
assertEquals(0, c[0].getNumberOfNodes());
assertEquals(0, c[0].getNumberOfLocksHeld());
c[0].stop();
c[0].destroy();
c[0].stop();
c[0].destroy();
}
public void testFailedStart() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, false);
AssertJUnit.assertEquals("Correct state", CacheStatus.INSTANTIATED, c[0].getCacheStatus());
DisruptLifecycleListener listener = new DisruptLifecycleListener();
c[0].addCacheListener(listener);
c[0].create();
listener.disrupt = true;
assertEquals("Correct state", CacheStatus.CREATED, c[0].getCacheStatus());
try
{
c[0].start();
fail("Listener did not prevent start");
}
catch (CacheException good)
{
}
assertEquals("Correct state", CacheStatus.FAILED, c[0].getCacheStatus());
c[0].addCacheListener(listener);
listener.disrupt = false;
c[0].start();
assertEquals("Correct state", CacheStatus.STARTED, c[0].getCacheStatus());
c[0].put("/a/b/c", null);
assertTrue(c[0].getNumberOfNodes() > 0);
assertEquals(0, c[0].getNumberOfLocksHeld());
listener.disrupt = true;
c[0].addCacheListener(listener);
try
{
c[0].stop();
fail("Listener did not prevent stop");
}
catch (CacheException good)
{
}
assertEquals("Correct state", CacheStatus.FAILED, c[0].getCacheStatus());
listener.disrupt = false;
c[0].stop();
assertEquals("Correct state", CacheStatus.STOPPED, c[0].getCacheStatus());
c[0].destroy();
assertEquals("Correct state", CacheStatus.DESTROYED, c[0].getCacheStatus());
}
public void testInvalidStateInvocations() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, false);
try
{
c[0].get(Fqn.ROOT, "k");
fail("Cache isn't ready!");
}
catch (IllegalStateException good)
{
}
c[0].create();
try
{
c[0].get(Fqn.ROOT, "k");
fail("Cache isn't ready!");
}
catch (IllegalStateException good)
{
}
c[0].start();
c[0].get(Fqn.ROOT, "k"); // should work
c[0].stop();
try
{
c[0].get(Fqn.ROOT, "k");
fail("Cache isn't ready!");
}
catch (IllegalStateException good)
{
}
c[0].destroy();
try
{
c[0].get(Fqn.ROOT, "k");
fail("Cache isn't ready!");
}
catch (IllegalStateException good)
{
}
}
public void testInvalidStateTxCommit() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, true);
c[0].getTransactionManager().begin();
c[0].put(Fqn.ROOT, "k1", "v1");
c[0].put(Fqn.ROOT, "k2", "v2");
// now DIRECTLY change the status of c.
ComponentRegistry cr0 = TestingUtil.extractComponentRegistry(c[0]);
cr0.state = CacheStatus.STOPPING;
try
{
c[0].getTransactionManager().commit();
fail("Cache isn't STARTED!");
}
catch (RollbackException good)
{
}
}
public void testInvalidStateTxRollback() throws Exception
{
createAndRegisterCache(Configuration.CacheMode.LOCAL, true);
c[0].getTransactionManager().begin();
c[0].put(Fqn.ROOT, "k1", "v1");
c[0].put(Fqn.ROOT, "k2", "v2");
// now DIRECTLY change the status of c.
ComponentRegistry cr0 = TestingUtil.extractComponentRegistry(c[0]);
cr0.state = CacheStatus.STOPPING;
// rollbacks should just log a message
c[0].getTransactionManager().rollback();
}
private CacheSPI createCache(Configuration.CacheMode cache_mode)
{
Configuration c = new Configuration();
c.setCacheMode(cache_mode);
c.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
CacheSPI retval = (CacheSPI) new UnitTestCacheFactory().createCache(c, false, getClass());
return retval;
}
private TransactionManager beginTransaction() throws SystemException, NotSupportedException
{
TransactionManager mgr = c[0].getConfiguration().getRuntimeConfig().getTransactionManager();
mgr.begin();
return mgr;
}
private void startCache(CacheSPI c)
{
c.create();
c.start();
}
private void stopCache(CacheSPI c)
{
c.stop();
c.destroy();
}
private void restartCache(CacheSPI c) throws Exception
{
stopCache(c);
startCache(c);
}
@CacheListener
public class DisruptLifecycleListener
{
private boolean disrupt;
@CacheStarted
public void cacheStarted(Event e)
{
if (disrupt) throw new IllegalStateException("I don't want to start");
}
@CacheStopped
public void cacheStopped(Event e)
{
if (disrupt) throw new IllegalStateException("I don't want to stop");
}
public void setDisrupt(boolean disrupt)
{
this.disrupt = disrupt;
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/UnitTestConfigurationFactory.java 0000644 0001750 0001750 00000024043 11132354355 033053 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.factories;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.CacheLoaderConfig.IndividualCacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.config.ConfigurationException;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.parsing.XmlConfigurationParser;
import org.jboss.cache.transaction.TransactionSetup;
import org.jboss.cache.util.FileLookup;
import org.jboss.cache.UnitTestCacheFactory;
import org.jgroups.conf.XmlConfigurator;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import java.io.InputStream;
import java.net.URL;
import java.util.Properties;
import org.jgroups.conf.ConfiguratorFactory;
/**
* Cache configuration factory used by unit tests.
*/
public class UnitTestConfigurationFactory
{
public static final String JGROUPS_CHANNEL;
public static final String JGROUPS_STACK_TYPE = "jgroups.stack";
public static final String DEFAULT_CONFIGURATION_FILE = "unit-test-cache-service.xml";
static
{
JGROUPS_CHANNEL = System.getProperty(JGROUPS_STACK_TYPE, "tcp");
System.out.println("IN USE JGROUPS_CHANNEL = " + JGROUPS_CHANNEL);
}
public static Configuration createConfiguration(CacheMode mode) throws ConfigurationException
{
return createConfiguration(mode, false, false);
}
public static Configuration createConfiguration(CacheMode mode, boolean useEviction) throws ConfigurationException
{
return createConfiguration(mode, useEviction, false);
}
public static Configuration createConfiguration(CacheMode mode, boolean useEviction, boolean usePassivation) throws ConfigurationException
{
return createConfiguration(mode, useEviction, usePassivation, false);
}
public static Configuration createConfiguration(CacheMode mode, boolean useEviction, boolean usePassivation, boolean killable) throws ConfigurationException
{
UnitTestXmlConfigurationParser parser = new UnitTestXmlConfigurationParser();
Configuration c = parser.parseFile(DEFAULT_CONFIGURATION_FILE, mode);
if (!useEviction)
{
c.setEvictionConfig(null);
}
if (!usePassivation)
{
c.setCacheLoaderConfig(null);
}
c.setTransactionManagerLookupClass(TransactionSetup.getManagerLookup());
if (mode != CacheMode.LOCAL && killable)
{
String clusterConfig = c.getClusterConfig();
c.setClusterConfig(injectDiscard(clusterConfig, 0, 0));
}
return c;
}
public static CacheLoaderConfig buildSingleCacheLoaderConfig(boolean passivation, String preload, String cacheloaderClass,
String properties, boolean async, boolean fetchPersistentState,
boolean shared, boolean purgeOnStartup, boolean ignoreModifications) throws Exception
{
CacheLoaderConfig clc = new CacheLoaderConfig();
IndividualCacheLoaderConfig iclc = new IndividualCacheLoaderConfig();
iclc.setClassName(cacheloaderClass);
iclc.setAsync(async);
iclc.setFetchPersistentState(fetchPersistentState);
iclc.setPurgeOnStartup(purgeOnStartup);
iclc.setIgnoreModifications(ignoreModifications);
iclc.setProperties(properties);
clc.addIndividualCacheLoaderConfig(iclc);
clc.setPassivation(passivation);
clc.setShared(shared);
clc.setPreload(preload);
return clc;
}
public static CacheLoaderConfig buildSingleCacheLoaderConfig(boolean passivation, String preload, String cacheloaderClass,
Properties properties, boolean async, boolean fetchPersistentState,
boolean shared, boolean purgeOnStartup, boolean ignoreModifications) throws Exception
{
CacheLoaderConfig clc = new CacheLoaderConfig();
IndividualCacheLoaderConfig iclc = new IndividualCacheLoaderConfig();
iclc.setClassName(cacheloaderClass);
iclc.setAsync(async);
iclc.setFetchPersistentState(fetchPersistentState);
iclc.setPurgeOnStartup(purgeOnStartup);
iclc.setIgnoreModifications(ignoreModifications);
iclc.setProperties(properties);
clc.addIndividualCacheLoaderConfig(iclc);
clc.setPassivation(passivation);
clc.setShared(shared);
clc.setPreload(preload);
return clc;
}
public static CacheLoaderConfig.IndividualCacheLoaderConfig buildIndividualCacheLoaderConfig(String preload, String cacheloaderClass, String properties, boolean async, boolean fetchPersistentState, boolean purgeOnStartup, boolean ignoreModifications) throws Exception
{
return buildSingleCacheLoaderConfig(false, preload, cacheloaderClass, properties, async, fetchPersistentState, false, purgeOnStartup, ignoreModifications).getFirstCacheLoaderConfig();
}
/**
* Helper method that takes a JGroups configuration file and creates an old-style JGroups config {@link String} that can be used
* in {@link org.jboss.cache.config.Configuration#setClusterConfig(String)}. Note that expressions
* in the file - such as ${jgroups.udp.mcast_port:45588} are expanded out accordingly.
*
* @param properties config properties
* @return a String
*/
public static String getClusterConfigFromProperties(String properties)
{
try
{
XmlConfigurator conf = XmlConfigurator.getInstance(ConfiguratorFactory.getConfigStream(properties));
String tmp = conf.getProtocolStackString();
// parse this string for ${} substitutions
// Highly crappy approach!!
tmp = tmp.replace("${jgroups.udp.mcast_addr:228.10.10.10}", "228.10.10.10");
tmp = tmp.replace("${jgroups.udp.mcast_port:45588}", "45588");
tmp = tmp.replace("${jgroups.udp.ip_ttl:2}", "2");
return tmp;
}
catch (Exception e)
{
throw new RuntimeException("Problems with properties " + properties, e);
}
}
/**
* Takes a JGroups configuration "old-style" String and injects the "DELAY" protcol.
*
* @param jgroupsConfigString JGroups config string
* @param incomingDelay incoming delay
* @param outgoingDelay outgoing delay
* @return new string
*/
public static String injectDelay(String jgroupsConfigString, int incomingDelay, int outgoingDelay)
{
String delay = ":DELAY(in_delay=" + incomingDelay + ";out_delay=" + outgoingDelay + ")";
return jgroupsConfigString.substring(0, jgroupsConfigString.indexOf(":")) + delay + jgroupsConfigString.substring(jgroupsConfigString.indexOf(":"));
}
/**
* Takes a JGroups configuration "old-style" String and injects the "DISCARD" protcol.
*
* @param jgroupsConfigString JGroups config string
* @param up factor of incoming messages to discard. 0 is none, 1 is all.
* @param down factor of outgoing messages to discard. 0 is none, 1 is all.
* @return new string
*/
public static String injectDiscard(String jgroupsConfigString, double up, double down)
{
String delay = ":DISCARD(up=" + up + ";down=" + down + ")";
return jgroupsConfigString.substring(0, jgroupsConfigString.indexOf(":")) + delay + jgroupsConfigString.substring(jgroupsConfigString.indexOf(":"));
}
/**
* This will make sure that cluster config is according {@link #JGROUPS_STACK_TYPE}, even for local caches.
* This is to avoid the following scenario: if you build a Configuration through new Configuration() then clusterCOnfig
* is set to default value, which might be UDP.
*
*/
public static Configuration getEmptyConfiguration()
{
Configuration tmp = createConfiguration(CacheMode.REPL_SYNC);
Configuration conf = new Configuration();
conf.setClusterConfig(UnitTestCacheFactory.mangleClusterConfiguration(tmp.getClusterConfig()));
assert conf.getClusterConfig() != null;
return conf;
}
private static class UnitTestXmlConfigurationParser extends XmlConfigurationParser
{
public Configuration parseFile(String filename, CacheMode mode)
{
String finalFileName = filename == null ? DEFAULT_CONFIGURATION_FILE : filename;
return parseStream(new FileLookup().lookupFile(finalFileName), mode);
}
public Configuration parseStream(InputStream stream, CacheMode mode)
{
// loop through all elements in XML.
if (stream == null) throw new ConfigurationException("Input stream for configuration xml is null!");
Element root = XmlConfigHelper.getDocumentRoot(stream);
XmlConfigurationParser parser = new UnitTestXmlConfigurationParser();
Configuration conf = parser.parseElement(root);
Element list = (Element) root.getElementsByTagNameNS("*","protocol_stacks").item(0);
NodeList stacks = list.getElementsByTagNameNS("*", "stack");
for (int i = 0; i < stacks.getLength(); i++)
{
Element stack = (Element) stacks.item(i);
String stackName = stack.getAttribute("name");
if (stackName.startsWith(JGROUPS_CHANNEL))
{
Element jgroupsStack = (Element) stack.getElementsByTagNameNS("*", "config").item(0);
if (!mode.isSynchronous() && !stackName.contains("-"))
{
conf.setClusterConfig(jgroupsStack);
conf.setCacheMode(CacheMode.REPL_ASYNC);
break;
}
else if (mode.isSynchronous() && stackName.contains("-"))
{
conf.setClusterConfig(jgroupsStack);
conf.setCacheMode(CacheMode.REPL_SYNC);
break;
}
}
}
// either way, set mode in the config!!
conf.setCacheMode(mode);
return conf;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/CustomInterceptorConstructionTest.java jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/CustomInterceptorConstructionTest.j0000644 0001750 0001750 00000013743 11132625723 033475 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source
* Copyright 2008, Red Hat Middleware LLC, and individual contributors
* by the @authors tag. See the copyright.txt 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.factories;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.CustomInterceptorConfig;
import org.jboss.cache.config.parsing.custominterceptors.AaaCustomInterceptor;
import org.jboss.cache.interceptors.MVCCLockingInterceptor;
import org.jboss.cache.interceptors.base.CommandInterceptor;
import org.jboss.cache.util.TestingUtil;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
import java.util.Collections;
import java.util.List;
/**
* Tests how custom interceptor construction is handled.
*
* @author Mircea.Markus@jboss.com
* @since 3.0
*/
@Test(groups = "functional", sequential = true, testName = "factories.CustomInterceptorConstructionTest")
public class CustomInterceptorConstructionTest
{
CacheSPI cache;
int defaultInterceptroCount;
@AfterMethod
public void tearDown()
{
if (cache != null)
{
TestingUtil.killCaches(cache);
}
cache = null;
}
public void testAddFirst()
{
AaaCustomInterceptor interceptor = new AaaCustomInterceptor();
CustomInterceptorConfig config = new CustomInterceptorConfig(interceptor);
config.setFirst(true);
buildCache(config);
assert cache.getInterceptorChain().get(0).equals(interceptor);
assert cache.getInterceptorChain().size() == defaultInterceptroCount + 1;
}
public void testAddLast()
{
AaaCustomInterceptor interceptor = new AaaCustomInterceptor();
CustomInterceptorConfig config = new CustomInterceptorConfig(interceptor);
config.setLast(true);
buildCache(config);
List chain = cache.getInterceptorChain();
assert chain.get(chain.size() - 1).equals(interceptor);
assert cache.getInterceptorChain().size() == defaultInterceptroCount + 1;
}
public void testAddAfter()
{
AaaCustomInterceptor interceptor = new AaaCustomInterceptor();
CustomInterceptorConfig config = new CustomInterceptorConfig(interceptor);
config.setAfterClass(MVCCLockingInterceptor.class.getName());
buildCache(config);
List chain = cache.getInterceptorChain();
int occurenceCount = 0;
for (CommandInterceptor ci : chain)
{
if (ci instanceof MVCCLockingInterceptor)
{
assert ci.getNext().equals(interceptor);
occurenceCount++;
}
}
assert occurenceCount == 1;
assert cache.getInterceptorChain().size() == defaultInterceptroCount + 1;
}
public void testAddBefore()
{
AaaCustomInterceptor interceptor = new AaaCustomInterceptor();
CustomInterceptorConfig config = new CustomInterceptorConfig(interceptor);
config.setBeforeClass(MVCCLockingInterceptor.class.getName());
buildCache(config);
List chain = cache.getInterceptorChain();
int occurenceCount = 0;
for (CommandInterceptor ci : chain)
{
if (ci instanceof AaaCustomInterceptor)
{
assert ci.getNext() instanceof MVCCLockingInterceptor;
occurenceCount++;
}
}
assert occurenceCount == 1;
assert cache.getInterceptorChain().size() == defaultInterceptroCount + 1;
}
@Test(enabled = true)
public void testAddAtIndex()
{
AaaCustomInterceptor interceptor = new AaaCustomInterceptor();
CustomInterceptorConfig config = new CustomInterceptorConfig(interceptor);
config.setIndex(1);
buildCache(config);
List chain = cache.getInterceptorChain();
assert chain.get(1).equals(interceptor);
assert cache.getInterceptorChain().size() == defaultInterceptroCount + 1;
}
public void testAddAtInvalidIndex()
{
AaaCustomInterceptor interceptor = new AaaCustomInterceptor();
CustomInterceptorConfig config = new CustomInterceptorConfig(interceptor);
config.setIndex(1000);
try
{
buildCache(config);
assert false : "exception expected here";
}
catch (Exception e)
{
//expected
}
}
private void buildCache(CustomInterceptorConfig interceptorConfig)
{
buildCache(Collections.singletonList(interceptorConfig));
}
private void buildCache(List interceptorConfig)
{
Configuration config = new Configuration();
config.setCacheMode(Configuration.CacheMode.LOCAL);
config.setNodeLockingScheme(Configuration.NodeLockingScheme.MVCC);
UnitTestCacheFactory cacheFactory2 = new UnitTestCacheFactory();
CacheSPI tmpCacheSPI = (CacheSPI) cacheFactory2.createCache(config, getClass());
defaultInterceptroCount = tmpCacheSPI.getInterceptorChain().size();
tmpCacheSPI.stop();
UnitTestCacheFactory cacheFactory = new UnitTestCacheFactory();
config.setCustomInterceptors(interceptorConfig);
cache = (CacheSPI) cacheFactory.createCache(config, true, getClass());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/UnitTestXmlConfigurationParser.java0000644 0001750 0001750 00000010127 11131613416 033352 0 ustar moeller moeller package org.jboss.cache.factories;
import org.jboss.cache.config.parsing.XmlConfigurationParser;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.ConfigurationException;
import org.jboss.cache.util.FileLookup;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.InputStream;
import java.util.Map;
import java.util.HashMap;
/**
* The purpose of this class is to make sure that the parsing of the test files is only performed once.
*
* @author Mircea.Markus@jboss.com
*/
class UnitTestXmlConfigurationParser
{
private static Log log = LogFactory.getLog(UnitTestConfigurationFactory.class);
public static final String DEFAULT_CONFIGURATION_FILE = "unit-test-cache-service.xml";
public static final String JGROUPS_CHANNEL;
public static final String JGROUPS_STACK_TYPE = "jgroups.stack";
static
{
JGROUPS_CHANNEL = System.getProperty(JGROUPS_STACK_TYPE);
}
private volatile static UnitTestXmlConfigurationParser instance;
private volatile Configuration confCache;
private volatile Map elementCache = new HashMap();
public static Configuration getConfiguration(Configuration.CacheMode cacheMode, boolean useTcp)
{
if (instance == null)
{
synchronized (UnitTestXmlConfigurationParser.class)
{
if (instance == null)
{
instance = new UnitTestXmlConfigurationParser();
instance.parseFile();
}
}
}
if (instance == null)
{
log.error("instance is null after creating node!!!");
throw new IllegalStateException();
}
//if there is an enforced jgroups stack, then only consider that one
if (JGROUPS_CHANNEL != null)
{
useTcp = JGROUPS_CHANNEL.trim().equals("tcp");
}
String resultKey = useTcp ? "tcp-" : "udp-";
resultKey += cacheMode.isSynchronous() ? "sync" : "async";
Configuration resultConf;
try
{
resultConf = instance.confCache.clone();
} catch (CloneNotSupportedException e)
{
log.error("Could not clone:", e);
throw new IllegalStateException(e);
}
Element stack = instance.elementCache.get(resultKey);
if (stack == null)
{
log.error("stack is null!!!");
throw new NullPointerException();
}
resultConf.setClusterConfig(stack);
if (resultConf.getClusterConfig() == null)
{
log.error("Null cluster config");
throw new IllegalStateException();
}
resultConf.setCacheMode(cacheMode);
return resultConf;
}
private void parseFile()
{
parseStream(new FileLookup().lookupFile(DEFAULT_CONFIGURATION_FILE));
}
private void parseStream(InputStream stream)
{
try
{
// loop through all elements in XML.
if (stream == null) throw new ConfigurationException("Input stream for configuration xml is null!");
Element root = XmlConfigHelper.getDocumentRoot(stream);
XmlConfigurationParser parser = new XmlConfigurationParser();
confCache = parser.parseElement(root);
if (confCache == null) throw new NullPointerException("Null conf cache!!");
Element list = (Element) root.getElementsByTagNameNS("*", "protocol_stacks").item(0);
NodeList stacks = list.getElementsByTagNameNS("*", "stack");
for (int i = 0; i < stacks.getLength(); i++)
{
Element stack = (Element) stacks.item(i);
String stackName = stack.getAttribute("name");
Element jgroupsStack = (Element) stack.getElementsByTagNameNS("*", "config").item(0);
elementCache.put(stackName, jgroupsStack);
}
}
catch (Exception e)
{
log.error(e);
throw new IllegalStateException(e);
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/InterceptorChainFactoryTest.java 0000644 0001750 0001750 00000065001 11121730272 032636 0 ustar moeller moeller package org.jboss.cache.factories;
import org.jboss.cache.Cache;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.BuddyReplicationConfig;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.CacheLoaderConfig.IndividualCacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import static org.jboss.cache.config.Configuration.CacheMode.*;
import static org.jboss.cache.config.Configuration.NodeLockingScheme.MVCC;
import static org.jboss.cache.config.Configuration.NodeLockingScheme.OPTIMISTIC;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.interceptors.*;
import org.jboss.cache.interceptors.base.CommandInterceptor;
import org.jboss.cache.loader.testloaders.DummyInMemoryCacheLoader;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
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.util.Iterator;
import java.util.List;
@Test(groups = "unit", sequential = true, testName = "factories.InterceptorChainFactoryTest")
public class InterceptorChainFactoryTest extends InterceptorChainTestBase
{
CacheSPI cache = null;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
Configuration configuration = new Configuration();
configuration.setCacheMode(LOCAL);
configuration.setNodeLockingScheme(Configuration.NodeLockingScheme.PESSIMISTIC);
configuration.setUseLazyDeserialization(false);
cache = (CacheSPI) new UnitTestCacheFactory().createCache(configuration,false, getClass());
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
public void testBareConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(5, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testBatchingConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setInvocationBatchingEnabled(true);
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(6, list.size());
assertEquals(BatchingInterceptor.class, interceptors.next().getClass());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testMvccConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setNodeLockingScheme(MVCC);
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(5, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(MVCCLockingInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testTxConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(5, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
protected CacheLoaderConfig getCacheLoaderConfig(boolean pasv, boolean fetchPersistentState) throws Exception
{
CacheLoaderConfig clc = new CacheLoaderConfig();
IndividualCacheLoaderConfig iclc = new IndividualCacheLoaderConfig();
iclc.setClassName(DummyInMemoryCacheLoader.class.getName());
iclc.setFetchPersistentState(fetchPersistentState);
clc.addIndividualCacheLoaderConfig(iclc);
clc.setPassivation(pasv);
return clc;
}
public void testSharedCacheLoaderConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache.getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(false, false));
cache.getConfiguration().setCacheMode(REPL_ASYNC);
cache.getConfiguration().setFetchInMemoryState(false);
cache.create();
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(8, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(ReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyCacheLoaderInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyCacheStoreInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testSharedCacheLoaderMvccConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache.getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(false, false));
cache.getConfiguration().setCacheMode(REPL_ASYNC);
cache.getConfiguration().setNodeLockingScheme(MVCC);
cache.getConfiguration().setFetchInMemoryState(false);
cache.create();
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(8, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(ReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(CacheLoaderInterceptor.class, interceptors.next().getClass());
assertEquals(MVCCLockingInterceptor.class, interceptors.next().getClass());
assertEquals(CacheStoreInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testUnsharedCacheLoaderConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache.getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(false, true));
cache.getConfiguration().setCacheMode(REPL_ASYNC);
cache.getConfiguration().setFetchInMemoryState(false);
cache.create();
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(8, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(ReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyCacheLoaderInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyCacheStoreInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testUnsharedCacheLoaderMvccConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache.getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(false, true));
cache.getConfiguration().setCacheMode(REPL_ASYNC);
cache.getConfiguration().setNodeLockingScheme(MVCC);
cache.getConfiguration().setFetchInMemoryState(false);
cache.create();
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(8, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(ReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(CacheLoaderInterceptor.class, interceptors.next().getClass());
assertEquals(MVCCLockingInterceptor.class, interceptors.next().getClass());
assertEquals(CacheStoreInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testTxAndRepl() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setCacheMode(REPL_SYNC);
cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(6, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(ReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testOptimisticChain() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setNodeLockingScheme(OPTIMISTIC);
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertEquals(8, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticTxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticLockingInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticValidatorInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticCreateIfNotExistsInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticNodeInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testOptimisticReplicatedChain() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setNodeLockingScheme(OPTIMISTIC);
cache.getConfiguration().setCacheMode(REPL_SYNC);
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertEquals(9, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticTxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticLockingInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticValidatorInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticCreateIfNotExistsInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticNodeInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testOptimisticCacheLoaderChain() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setNodeLockingScheme(OPTIMISTIC);
cache.getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(false, false));
cache.create();
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertEquals(10, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticTxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyCacheLoaderInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyCacheStoreInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticLockingInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticValidatorInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticCreateIfNotExistsInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticNodeInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testOptimisticPassivationCacheLoaderChain() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setNodeLockingScheme(OPTIMISTIC);
cache.getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(true, false));
cache.create();
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertEquals(10, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticTxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyActivationInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyPassivationInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticLockingInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticValidatorInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticCreateIfNotExistsInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticNodeInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testPassivationMvccChain() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setNodeLockingScheme(MVCC);
cache.getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(true, false));
cache.create();
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertEquals(7, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(ActivationInterceptor.class, interceptors.next().getClass());
assertEquals(MVCCLockingInterceptor.class, interceptors.next().getClass());
assertEquals(PassivationInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testInvalidationInterceptorChain() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setCacheMode(REPL_ASYNC);
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertEquals(6, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(ReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
// ok, my replication chain looks good.
// now for my invalidation chain.
cache.getConfiguration().setExposeManagementStatistics(false);
cache.getConfiguration().setCacheMode(INVALIDATION_ASYNC);
chain = getInterceptorChainFactory(cache).buildInterceptorChain();
list = chain.asList();
interceptors = list.iterator();
assertEquals(6, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(InvalidationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testCacheMgmtConfig() throws Exception
{
cache.getConfiguration().setExposeManagementStatistics(true);
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(6, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(CacheMgmtInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testEvictionInterceptorConfig() throws Exception
{
cache.getConfiguration().setEvictionConfig(new EvictionConfig()
{
private static final long serialVersionUID = -6644183636899605065L;
public boolean isValidConfig()
{
return true;
}
}
);
InterceptorChainFactory factory = getInterceptorChainFactory(cache);
InterceptorChain chain = factory.buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(7, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(CacheMgmtInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(EvictionInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testBuddyReplicationOptLocking() throws Exception
{
BuddyReplicationConfig brc = new BuddyReplicationConfig();
brc.setEnabled(true);
cache.getConfiguration().setBuddyReplicationConfig(brc);
cache.getConfiguration().setCacheMode(REPL_SYNC);
cache.getConfiguration().setNodeLockingScheme(OPTIMISTIC);
cache.create();// initialise various subsystems such as BRManager
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(11, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(CacheMgmtInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticTxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyDataGravitatorInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticLockingInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticValidatorInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticCreateIfNotExistsInterceptor.class, interceptors.next().getClass());
assertEquals(OptimisticNodeInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
public void testBuddyReplicationPessLocking() throws Exception
{
BuddyReplicationConfig brc = new BuddyReplicationConfig();
brc.setEnabled(true);
cache.getConfiguration().setBuddyReplicationConfig(brc);
cache.getConfiguration().setCacheMode(REPL_SYNC);
cache.create();// initialise various subsystems such as BRManager
InterceptorChain chain = getInterceptorChainFactory(cache).buildInterceptorChain();
List list = chain.asList();
Iterator interceptors = list.iterator();
assertNotNull(list);
assertEquals(8, list.size());
assertEquals(InvocationContextInterceptor.class, interceptors.next().getClass());
assertEquals(CacheMgmtInterceptor.class, interceptors.next().getClass());
assertEquals(TxInterceptor.class, interceptors.next().getClass());
assertEquals(NotificationInterceptor.class, interceptors.next().getClass());
assertEquals(ReplicationInterceptor.class, interceptors.next().getClass());
assertEquals(PessimisticLockInterceptor.class, interceptors.next().getClass());
assertEquals(LegacyDataGravitatorInterceptor.class, interceptors.next().getClass());
assertEquals(CallInterceptor.class, interceptors.next().getClass());
assertInterceptorLinkage(list);
}
private InterceptorChainFactory getInterceptorChainFactory(Cache cache)
{
return InterceptorChainFactory.getInstance(TestingUtil.extractComponentRegistry(cache), cache.getConfiguration());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/ComponentRegistryUnitTest.java 0000644 0001750 0001750 00000006736 11131613416 032413 0 ustar moeller moeller package org.jboss.cache.factories;
import org.jboss.cache.Cache;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.config.Configuration;
import org.testng.annotations.Test;
/**
* @author Manik Surtani (manik AT jboss DOT org)
* @since 2.1.0
*/
@Test(groups = "functional", testName = "factories.ComponentRegistryUnitTest")
public class ComponentRegistryUnitTest
{
public void testConstruction()
{
Cache c = new UnitTestCacheFactory().createCache(UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.REPL_SYNC), getClass());
c.put("/a", "b", "c");
TestingUtil.killCaches(c);
}
// ComponentRegistry cr;
// Configuration cfg;
//
// @BeforeMethod
// public void setUp()
// {
// cr = new ComponentRegistry(new Configuration());
// cfg = cr.getConfiguration();
// }
//
// public void testChangingComponentState()
// {
// cr.registerComponent("c2", new C2(), C2.class);
// cr.registerComponent("c1", new C1(), C1.class);
// cr.registerComponent("c3", new C3(), C3.class);
//
// ComponentRegistry.Component c1 = cr.componentLookup.get("c1");
// ComponentRegistry.Component c2 = cr.componentLookup.get("c2");
// ComponentRegistry.Component c3 = cr.componentLookup.get("c3");
//
// // add some dependencies
// ComponentRegistry.Component d1 = cr.new Component("c1", null);
// ComponentRegistry.Component d2 = cr.new Component("c2", null);
// ComponentRegistry.Component d3 = cr.new Component("c3", null);
//
// // c1 depends on c2
// // c3 depends on c1
//
// // test dependency and dependencyFor
//
// assert c2.dependencies.isEmpty();
// assert c1.dependencies.contains(d2);
// assert c1.dependencies.size() == 1;
// assert c3.dependencies.contains(d1);
// assert c3.dependencies.size() == 1;
//
// assert c2.dependencyFor.contains(d1);
// assert c2.dependencyFor.size() == 1;
// assert c1.dependencyFor.contains(d3);
// assert c1.dependencyFor.size() == 1;
// assert c3.dependencyFor.isEmpty();
//
// assert c1.state == ComponentRegistry.State.CONSTRUCTED;
// assert c2.state == ComponentRegistry.State.CONSTRUCTED;
// assert c3.state == ComponentRegistry.State.CONSTRUCTED;
//
// c1.changeState(ComponentRegistry.State.WIRED);
//
// assert c1.state == ComponentRegistry.State.WIRED;
// assert c2.state == ComponentRegistry.State.WIRED;
// assert c3.state == ComponentRegistry.State.CONSTRUCTED;
//
// c3.changeState(ComponentRegistry.State.STARTED);
//
// assert c1.state == ComponentRegistry.State.STARTED;
// assert c2.state == ComponentRegistry.State.STARTED;
// assert c3.state == ComponentRegistry.State.STARTED;
//
// c1.changeState(ComponentRegistry.State.CONSTRUCTED);
//
// assert c1.state == ComponentRegistry.State.CONSTRUCTED;
// assert c2.state == ComponentRegistry.State.STARTED;
// assert c3.state == ComponentRegistry.State.CONSTRUCTED;
// }
//
// public static class C1
// {
// C2 c2;
//
// @Inject
// private void inject(@ComponentName("c2")C2 c2)
// {
// this.c2 = c2;
// }
// }
//
// public static class C2
// {
//
// }
//
// public static class C3
// {
// C1 c1;
//
// @Inject
// private void inject(@ComponentName("c1")C1 c1)
// {
// this.c1 = c1;
// }
// }
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/CustomInterceptorChainTest.java 0000644 0001750 0001750 00000013206 11120421412 032471 0 ustar moeller moeller package org.jboss.cache.factories;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.interceptors.base.CommandInterceptor;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.fail;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.List;
/**
* @author Manik Surtani
*/
@Test(groups = {"functional"}, sequential = true, testName = "factories.CustomInterceptorChainTest")
public class CustomInterceptorChainTest extends InterceptorChainTestBase
{
private CacheSPI cache;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
Configuration c = new Configuration();
cache = (CacheSPI) new UnitTestCacheFactory().createCache(c, getClass());
cache.create();
}
@AfterMethod(alwaysRun = true)
public void tearDown()
{
if (cache != null)
{
TestingUtil.killCaches(cache);
cache = null;
}
}
public void testChainImmutability()
{
try
{
cache.getInterceptorChain().add(new TestInterceptor());
fail("unsupportedException should have been thrown as the chain obtained from the cache should be immutable");
}
catch (UnsupportedOperationException uoe)
{
// this is expected.
}
}
public void testInjectionAtHead()
{
List interceptors = cache.getInterceptorChain();
assertEquals("Expecting 6 interceptors", 6, interceptors.size());
assertInterceptorLinkage(interceptors);
CommandInterceptor x = new TestInterceptor();
cache.addInterceptor(x, 0);
interceptors = cache.getInterceptorChain();
assertEquals("Expecting 7 interceptors", 7, interceptors.size());
assertInterceptorLinkage(interceptors);
assertEquals(x, interceptors.get(0));
}
public void testInjectionAtTail()
{
List interceptors = cache.getInterceptorChain();
assertEquals("Expecting 6 interceptors", 6, interceptors.size());
assertInterceptorLinkage(interceptors);
CommandInterceptor x = new TestInterceptor();
cache.addInterceptor(x, 6);
interceptors = cache.getInterceptorChain();
assertEquals("Expecting 7 interceptors", 7, interceptors.size());
assertInterceptorLinkage(interceptors);
assertEquals(x, interceptors.get(6));
}
public void testInjectionInMiddle()
{
List interceptors = cache.getInterceptorChain();
assertEquals("Expecting 6 interceptors", 6, interceptors.size());
assertInterceptorLinkage(interceptors);
CommandInterceptor x = new TestInterceptor();
cache.addInterceptor(x, 3);
interceptors = cache.getInterceptorChain();
assertEquals("Expecting 7 interceptors", 7, interceptors.size());
assertInterceptorLinkage(interceptors);
assertEquals(x, interceptors.get(3));
}
public void testInjectionBeyondTail()
{
List interceptors = cache.getInterceptorChain();
assertEquals("Expecting 6 interceptors", 6, interceptors.size());
assertInterceptorLinkage(interceptors);
CommandInterceptor x = new TestInterceptor();
try
{
cache.addInterceptor(x, 9);
fail("Should throw an exception");
}
catch (IllegalArgumentException e)
{
// expected
}
}
public void testRemoveAtHead()
{
List interceptors = cache.getInterceptorChain();
CommandInterceptor afterHead = interceptors.get(1);
assertEquals("Expecting 6 interceptors", 6, interceptors.size());
assertInterceptorLinkage(interceptors);
cache.removeInterceptor(0);
interceptors = cache.getInterceptorChain();
assertEquals("Expecting 5 interceptors", 5, interceptors.size());
assertInterceptorLinkage(interceptors);
assertEquals(afterHead, interceptors.get(0));
}
public void testRemoveAtTail()
{
List interceptors = cache.getInterceptorChain();
CommandInterceptor beforeTail = interceptors.get(4);
assertEquals("Expecting 6 interceptors", 6, interceptors.size());
assertInterceptorLinkage(interceptors);
cache.removeInterceptor(5);
interceptors = cache.getInterceptorChain();
assertEquals("Expecting 5 interceptors", 5, interceptors.size());
assertInterceptorLinkage(interceptors);
assertEquals(beforeTail, interceptors.get(4));
}
public void testRemoveAtMiddle()
{
List interceptors = cache.getInterceptorChain();
assertEquals("Expecting 6 interceptors", 6, interceptors.size());
assertInterceptorLinkage(interceptors);
cache.removeInterceptor(3);
interceptors = cache.getInterceptorChain();
assertEquals("Expecting 5 interceptors", 5, interceptors.size());
assertInterceptorLinkage(interceptors);
}
public void testRemoveBeyondTail()
{
List interceptors = cache.getInterceptorChain();
assertEquals("Expecting 6 interceptors", 6, interceptors.size());
assertInterceptorLinkage(interceptors);
try
{
cache.removeInterceptor(9);
fail("Should throw an exception");
}
catch (IllegalArgumentException e)
{
// expected
}
}
public static class TestInterceptor extends CommandInterceptor
{
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/InterceptorChainTestBase.java 0000644 0001750 0001750 00000001322 11111047320 032067 0 ustar moeller moeller package org.jboss.cache.factories;
import org.jboss.cache.interceptors.base.CommandInterceptor;
import static org.testng.AssertJUnit.assertEquals;
import java.util.List;
/**
* @author Manik Surtani
*/
public abstract class InterceptorChainTestBase
{
protected void assertInterceptorLinkage(List list)
{
CommandInterceptor previous = null;
for (CommandInterceptor i : list)
{
if (previous == null)
{
previous = i;
continue;
}
assertEquals("Expecting the next interceptor after " + previous + " to be " + i, i, previous.getNext());
previous = i;
}
}
} jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/LateConfigurationTest.java 0000644 0001750 0001750 00000011113 11121730272 031455 0 ustar moeller moeller package org.jboss.cache.factories;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.BuddyReplicationConfig;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.interceptors.OptimisticLockingInterceptor;
import org.jboss.cache.loader.testloaders.DummyInMemoryCacheLoader;
import org.jboss.cache.marshall.AbstractMarshaller;
import org.jboss.cache.marshall.VersionAwareMarshaller;
import org.jboss.cache.transaction.DummyTransactionManager;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.TestingUtil;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* @author Manik Surtani (manik AT jboss DOT org)
* @since 2.1.0
*/
@Test(groups = "functional", sequential = true, testName = "factories.LateConfigurationTest")
public class LateConfigurationTest
{
CacheSPI c;
@BeforeMethod
public void setUp()
{
c = (CacheSPI) new UnitTestCacheFactory().createCache(false, getClass());
}
@AfterMethod
public void tearDown()
{
TestingUtil.killCaches(c);
c = null;
}
public void testTransactionManager()
{
assert c.getTransactionManager() == null;
c.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
assert c.getTransactionManager() == null;
c.start();
assert c.getTransactionManager() == DummyTransactionManager.getInstance();
}
public void testTransactionManagerinRuntime()
{
assert c.getTransactionManager() == null;
c.getConfiguration().getRuntimeConfig().setTransactionManager(DummyTransactionManager.getInstance());
assert c.getTransactionManager() == null;
c.start();
assert c.getTransactionManager() == DummyTransactionManager.getInstance();
}
public void testCacheLoader()
{
assert c.getCacheLoaderManager() != null;
assert c.getCacheLoaderManager().getCacheLoader() == null;
CacheLoaderConfig clc = new CacheLoaderConfig();
CacheLoaderConfig.IndividualCacheLoaderConfig iclc = new CacheLoaderConfig.IndividualCacheLoaderConfig();
iclc.setCacheLoader(new DummyInMemoryCacheLoader());
clc.addIndividualCacheLoaderConfig(iclc);
c.getConfiguration().setCacheLoaderConfig(clc);
c.start();
assert c.getCacheLoaderManager() != null;
assert c.getCacheLoaderManager().getCacheLoader() instanceof DummyInMemoryCacheLoader;
}
public void testBuddyManagerLocal()
{
// leaving cache mode as local
assert c.getBuddyManager() == null;
BuddyReplicationConfig brc = new BuddyReplicationConfig();
brc.setEnabled(true);
c.getConfiguration().setBuddyReplicationConfig(brc);
c.start();
assert c.getBuddyManager() == null;
}
public void testBuddyManager()
{
// we need to not be LOCAL if we want things to work with BR!
c.getConfiguration().setCacheMode(Configuration.CacheMode.REPL_SYNC);
assert c.getBuddyManager() == null;
BuddyReplicationConfig brc = new BuddyReplicationConfig();
brc.setEnabled(true);
c.getConfiguration().setBuddyReplicationConfig(brc);
c.start();
assert c.getBuddyManager() != null;
assert c.getBuddyManager().isEnabled();
}
public void testInterceptors()
{
assert TestingUtil.findInterceptor(c, OptimisticLockingInterceptor.class) == null;
c.getConfiguration().setNodeLockingScheme("OPTIMISTIC");
assert TestingUtil.findInterceptor(c, OptimisticLockingInterceptor.class) == null;
c.start();
assert TestingUtil.findInterceptor(c, OptimisticLockingInterceptor.class) != null;
}
public void testCacheMarshaller()
{
assert c.getMarshaller() instanceof VersionAwareMarshaller;
c.getConfiguration().setCacheMarshaller(new AbstractMarshaller()
{
public void objectToObjectStream(Object obj, ObjectOutputStream out) throws Exception
{
}
public Object objectFromObjectStream(ObjectInputStream in) throws Exception
{
return null;
}
public void objectToObjectStream(Object obj, ObjectOutputStream out, Fqn region)
{
}
});
c.start();
assert !(c.getMarshaller() instanceof VersionAwareMarshaller) && c.getMarshaller() != null;
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/ComponentRegistryFunctionalTest.java jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/ComponentRegistryFunctionalTest.jav0000644 0001750 0001750 00000017476 11111047320 033431 0 ustar moeller moeller package org.jboss.cache.factories;
import org.testng.annotations.Test;
/**
* @author Manik Surtani (manik AT jboss DOT org)
* @since 2.1.0
*/
@Test(groups = {"functional"}, testName = "factories.ComponentRegistryFunctionalTest")
public class ComponentRegistryFunctionalTest
{
// private ComponentRegistry cr;
// private Configuration configuration;
//
// @BeforeMethod
// public void setUp() throws Exception
// {
// CacheFactory cf = new DefaultCacheFactory();
//
// Cache cache = cf.createCache(false);
// cr = TestingUtil.extractComponentRegistry(cache);
// configuration = cache.getConfiguration();
// }
//
// public void testDefaultFactoryScanning()
// {
// cr.scanDefaultFactories();
//
// assert cr.defaultFactories != null : "Should be populated";
//
// // at very least, expecting a Marshaller factory and a DefaultCacheFactory.
// assert cr.defaultFactories.containsKey(Marshaller.class);
// assert cr.defaultFactories.get(Marshaller.class).equals(EmptyConstructorFactory.class);
// assert cr.defaultFactories.containsKey(Notifier.class);
// assert cr.defaultFactories.get(Notifier.class).equals(EmptyConstructorFactory.class);
//
// }
//
// public void testDependencyConsistency()
// {
// for (ComponentRegistry.Component component : cr.componentLookup.values())
// {
// // test that this component appears in all dependencies' dependencyFor collection.
// for (ComponentRegistry.Component dep : component.dependencies)
// {
// assert cr.componentLookup.get(dep.name).dependencyFor.contains(component) : "Dependency " + dep.name + " does not have component " + component.name + " in its dependencyFor collection.";
// }
// }
//
// for (ComponentRegistry.Component component : cr.componentLookup.values())
// {
// // test that this component appears in all dependencies' dependencyFor collection.
// for (ComponentRegistry.Component dep : component.dependencyFor)
// {
// assert cr.componentLookup.get(dep.name).dependencies.contains(component) : "Dependency " + dep.name + " does not have component " + component.name + " in its dependencies collection.";
// }
// }
// }
//
//
// public void testNamedComponents()
// {
// cr.registerComponent("blah", new Object(), Object.class);
// Object namedComponent1 = cr.getOrCreateComponent("blah", Object.class);
// Object namedComponent2 = cr.getOrCreateComponent("blah", Object.class);
//
// assert namedComponent1 == namedComponent2;
// }
//
// /**
// * Case 1:
// * nothing injected, nothing specified in Configuration. Should use default factory.
// */
// public void testConstructionOrder1()
// {
// Class componentToTest = Marshaller.class;
// Marshaller m = cr.getOrCreateComponent(null, componentToTest);
// assert m instanceof VersionAwareMarshaller;
// VersionAwareMarshaller vam = (VersionAwareMarshaller) m;
// vam.initReplicationVersions();
// m = (Marshaller) TestingUtil.extractField(vam, "defaultMarshaller");
// assert m instanceof CacheMarshaller210;
// }
//
// /**
// * Case 2:
// * instance injected, class specified in Configuration. Should use injected.
// */
// public void testConstructionOrder2()
// {
// Class componentToTest = Marshaller.class;
// configuration.setMarshallerClass(CacheMarshaller200.class.getName());
// Marshaller instance = new CacheMarshaller210();
// configuration.setCacheMarshaller(instance);
//
// // the setup() would have wired the default marshaller. Need to update deps.
// cr.unregisterComponent(Marshaller.class);
// cr.updateDependencies();
//
// Marshaller m = cr.getOrCreateComponent(null, componentToTest);
// assert m == instance : "m is " + m + " but expected " + instance;
// }
//
// /**
// * Case 3:
// * instance injected, no class specified in Configuration. Should use injected.
// */
// public void testConstructionOrder3()
// {
// Class componentToTest = Marshaller.class;
// Marshaller instance = new CacheMarshaller210();
// configuration.setCacheMarshaller(instance);
//
// // the setup() would have wired the default marshaller. Need to update deps.
// cr.unregisterComponent(Marshaller.class);
// cr.updateDependencies();
//
// Marshaller m = cr.getOrCreateComponent(null, componentToTest);
// assert m == instance : "m is " + m + " but expected " + instance;
// }
//
// /**
// * Case 4:
// * nothing injected, class specified in Configuration. Should use class specified.
// */
// public void testConstructionOrder4()
// {
// Class componentToTest = Marshaller.class;
// configuration.setMarshallerClass(CacheMarshaller200.class.getName());
// Marshaller m = cr.getOrCreateComponent(null, componentToTest);
// assert m instanceof VersionAwareMarshaller;
// VersionAwareMarshaller vam = (VersionAwareMarshaller) m;
// vam.initReplicationVersions();
// m = (Marshaller) TestingUtil.extractField(vam, "defaultMarshaller");
// assert m instanceof CacheMarshaller200;
// }
//
// public void testTransitiveDependencies()
// {
// Class componentToTest = BuddyManager.class;
//
// // configure the cfg to use BR
// BuddyReplicationConfig brc = new BuddyReplicationConfig();
// brc.setEnabled(true);
// BuddyReplicationConfig.BuddyLocatorConfig blc = new BuddyReplicationConfig.BuddyLocatorConfig();
// blc.setBuddyLocatorClass(NextMemberBuddyLocator.class.getName());
// brc.setBuddyLocatorConfig(blc);
// configuration.setBuddyReplicationConfig(brc);
//
// // needs to be a non-LOCAL configuration
// configuration.setCacheMode(Configuration.CacheMode.REPL_ASYNC);
// BuddyManager bm = cr.getOrCreateComponent(null, componentToTest);
// assert bm != null;
//
// StateTransferManager stm = (StateTransferManager) TestingUtil.extractField(bm, "stateTransferManager");
// assert stm != null;
//
// RPCManager rpcm = (RPCManager) TestingUtil.extractField(bm, "rpcManager");
// assert rpcm != null;
//
// RegionManager rm = (RegionManager) TestingUtil.extractField(bm, "regionManager");
// assert rm != null;
//
// Configuration cfg = (Configuration) TestingUtil.extractField(bm, "configuration");
// assert cfg == configuration;
// }
//
// public void testInjectionOrder()
// {
// // injection should only occur after dependent components have been fully wired.
//
// // E.g. Test1 depends on Test2 and Test2 depends on Test3.
// //cr.reset();
//
// // DefaultFactoryFor annotation won't work since tests are compiled into a separate classpath
// cr.defaultFactories.put(Test1.class, EmptyConstructorFactory.class);
// cr.defaultFactories.put(Test2.class, EmptyConstructorFactory.class);
// cr.defaultFactories.put(Test3.class, EmptyConstructorFactory.class);
//
// Test1 t1 = cr.getOrCreateComponent(null, Test1.class);
//
// assert t1 != null;
// assert t1.test2 != null;
// assert t1.test2.test3 != null;
// assert t1.someValue == t1.test2.test3.someValue;
// }
//
// public static class Test1
// {
// private Test2 test2;
// private boolean someValue = false;
//
// @Inject
// public void setTest2(Test2 test2)
// {
// this.test2 = test2;
// someValue = test2.test3.someValue;
// }
// }
//
// public static class Test2
// {
// private Test3 test3;
//
// @Inject
// public void setTest3(Test3 test3)
// {
// this.test3 = test3;
// }
// }
//
// public static class Test3
// {
// private boolean someValue = true;
// }
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/factories/LifeCycleWithReplTest.java 0000644 0001750 0001750 00000012203 11142423437 031364 0 ustar moeller moeller package org.jboss.cache.factories;
import org.jboss.cache.*;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.fail;
import org.testng.annotations.Test;
import java.util.LinkedList;
import java.util.List;
/**
* @author Mircea.Markus@jboss.com
*/
@Test(groups = {"functional"}, testName = "factories.LifeCycleWithReplTest")
public class LifeCycleWithReplTest extends AbstractMultipleCachesTest
{
private CacheSPI first;
private CacheSPI second;
protected void createCaches() throws Throwable
{
first = createCache(Configuration.CacheMode.REPL_SYNC);
second = createCache(Configuration.CacheMode.REPL_SYNC);
TestingUtil.blockUntilViewReceived(first, 2, 10000);
registerCaches(first, second);
}
public void testRemoteInvalidStateInvocations() throws Exception
{
try
{
// now DIRECTLY change the status of c2.
// emulate the race condition where the remote cache is stopping but hasn't disconnected from the channel.
ComponentRegistry cr1 = TestingUtil.extractComponentRegistry(second);
cr1.state = CacheStatus.STOPPING;
// Thanks to JBCACHE-1179, this should only log a warning and not throw an exception
first.put(Fqn.ROOT, "k", "v");
}
finally
{
ComponentRegistry cr1 = TestingUtil.extractComponentRegistry(second);
cr1.state = CacheStatus.STARTED;
}
}
public void testStopInstanceWhileOtherInstanceSends() throws Exception
{
final Fqn fqn = Fqn.fromString("/a");
final List running = new LinkedList();
final List exceptions = new LinkedList();
running.add(true);
first.put(fqn, "k", "v");
assert "v".equals(first.get(fqn, "k"));
assert "v".equals(second.get(fqn, "k"));
// now kick start a thread on second that will constantly update the fqn
Thread updater = new Thread()
{
public void run()
{
int i = 0;
while (running.get(0))
{
try
{
i++;
if (running.get(0)) second.put(fqn, "k", "v" + i);
}
catch (ReplicationException re)
{
// this sometimes happens when JGroups suspects the remote node. This is ok, as long as we don't get an ISE.
}
catch (SuspectException se)
{
// this sometimes happens when JGroups suspects the remote node. This is ok, as long as we don't get an ISE.
}
catch (Exception e)
{
exceptions.add(e);
}
TestingUtil.sleepThread(20);
}
}
};
updater.start();
running.add(false);
running.remove(true);
updater.join();
for (Exception e : exceptions) throw e;
}
public void testRemoteInvalidStateInvocations2() throws Exception
{
try
{
// now DIRECTLY change the status of second.
// emulate the race condition where the remote cache is stopping but hasn't disconnected from the channel.
// there is a lousy race condition here - we need to make sure seconds's start() method doesn't set status to STARTED
// after we attempt to change this.
ComponentRegistry cr1 = TestingUtil.extractComponentRegistry(second);
cr1.state = CacheStatus.STARTING;
try
{
// This call should wait for up to StateRetrievalTimeout secs or until second has entered the STARTED state, and then barf.
first.put(Fqn.ROOT, "k", "v");
fail("Should barf!");
}
catch (Exception good)
{
}
// now kick off another thread to sleep for a few secs and then set second to STARTED
final int sleepTime = 500;
new Thread()
{
public void run()
{
TestingUtil.sleepThread(sleepTime);
ComponentRegistry cr1 = TestingUtil.extractComponentRegistry(second);
cr1.state = CacheStatus.STARTED;
}
}.start();
first.put(Fqn.ROOT, "k", "v");
}
finally
{
// reset second to running so the tearDown method can clean it up
ComponentRegistry cr1 = TestingUtil.extractComponentRegistry(second);
cr1.state = CacheStatus.STARTED;
}
}
private CacheSPI createCache(Configuration.CacheMode cacheMode)
{
Configuration c = new Configuration();
c.setCacheMode(cacheMode);
c.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
CacheSPI retval = (CacheSPI) new UnitTestCacheFactory().createCache(c, false, getClass());
retval.start();
return retval;
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/ResourceCleanupTest.java 0000644 0001750 0001750 00000004571 11144530753 027201 0 ustar moeller moeller package org.jboss.cache;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.AfterSuite;
import org.jboss.cache.util.TestingUtil;
import java.io.File;
/**
* Make sure that all files are being deleted after each test run.
*
* @author Mircea.Markus@jboss.com
*/
public class ResourceCleanupTest
{
@BeforeSuite
public void removeTempDir()
{
TestingUtil.recursiveFileRemove(TestingUtil.TEST_FILES);
System.out.println("Removing all the files from " + TestingUtil.TEST_FILES);
File file = new File(TestingUtil.TEST_FILES);
if (file.exists())
{
System.err.println("!!!!!!!!!!!!! Directory '" + TestingUtil.TEST_FILES + "' should have been deleted!!!");
}
else
{
System.out.println("Successfully removed folder: '" + TestingUtil.TEST_FILES + "'");
}
}
@BeforeSuite
@AfterSuite
public void printEnvInformation()
{
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~ ENVIRONMENT INFO ~~~~~~~~~~~~~~~~~~~~~~~~~~");
String bindAddress = System.getProperty("bind.address");
System.out.println("bind.address = " + bindAddress);
//todo for some funny reasons MVN ignores bind.address passed in. This is a hack..
if (bindAddress == null)
{
System.out.println("Setting bind.address to 127.0.0.1 as it is missing!!!");
System.setProperty("bind.address","127.0.0.1");
}
System.out.println("java.runtime.version = " + System.getProperty("java.runtime.version"));
System.out.println("java.runtime.name =" + System.getProperty("java.runtime.name"));
System.out.println("java.vm.version = " + System.getProperty("java.vm.version"));
System.out.println("java.vm.vendor = " + System.getProperty("java.vm.vendor"));
System.out.println("os.name = " + System.getProperty("os.name"));
System.out.println("os.version = " + System.getProperty("os.version"));
System.out.println("sun.arch.data.model = " + System.getProperty("sun.arch.data.model"));
System.out.println("sun.cpu.endian = " + System.getProperty("sun.cpu.endian"));
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~ ENVIRONMENT INFO ~~~~~~~~~~~~~~~~~~~~~~~~~~");
}
public static void main(String[] args)
{
System.out.println("System.getProperties() = " + System.getProperties());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ 0000755 0001750 0001750 00000000000 11675221324 024210 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/FIFOPolicyTest.java 0000644 0001750 0001750 00000023171 11132110773 027613 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
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.List;
import org.jboss.cache.UnitTestCacheFactory;
/**
* Unit tests for FIFOPolicy.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7439 $
*/
@Test(groups = {"functional"}, testName = "eviction.FIFOPolicyTest")
public class FIFOPolicyTest extends EvictionTestsBase
{
CacheSPI cache;
long wakeupIntervalMillis = 0;
final String ROOT_STR = "/test";
volatile Throwable t1_ex, t2_ex;
volatile boolean isTrue;
int maxNodes = 50;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
initCaches();
wakeupIntervalMillis = cache.getConfiguration().getEvictionConfig().getWakeupInterval();
if (wakeupIntervalMillis < 0)
{
fail("testEviction(): eviction thread wake up interval is illegal " + wakeupIntervalMillis);
}
t1_ex = t2_ex = null;
isTrue = true;
}
void initCaches() throws Exception
{
Configuration config = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
EvictionConfig evConfig = new EvictionConfig(new EvictionRegionConfig(Fqn.ROOT, new FIFOAlgorithmConfig(maxNodes), 2000000), 0);
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/org/jboss/test/data"), new FIFOAlgorithmConfig(5)));
config.setEvictionConfig(evConfig);
config.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
config.setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache = (CacheSPI) new UnitTestCacheFactory().createCache(config, true, getClass());// read in generic local xml
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
public void testEviction()
{
String rootStr = "/org/jboss/test/data/";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
try
{
cache.put(fqn, str, str);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
EvictionController evictionController = new EvictionController(cache);
evictionController.startEviction();
try
{
String val = (String) cache.get(rootStr + "3", rootStr + "3");
assertNull("DataNode should be empty ", val);
assertNull(cache.get(rootStr + "1", rootStr + "1"));
assertNull(cache.get(rootStr + "2", rootStr + "2"));
assertNull(cache.get(rootStr + "0", rootStr + "0"));
assertNull(cache.get(rootStr + "4", rootStr + "4"));
assertNotNull(cache.get(rootStr + "5", rootStr + "5"));
}
catch (Exception e)
{
e.printStackTrace();
fail("Failed to get" + e);
}
}
public void testEviction2() throws Exception
{
String rootStr = "/org/jboss/data";
for (int i = 0; i < maxNodes * 2; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
}
EvictionController evictionController = new EvictionController(cache);
evictionController.startEviction();
// wait a few secs for eviction to complete
// TestingUtil.sleepThread(500);
assertEquals("Number of nodes", maxNodes + 2, cache.getNumberOfNodes());
for (int i = 0; i < maxNodes; i++)
{
String n = rootStr + i;
assertNull("DataNode should be empty " + cache.getNode(n) + " " + n,
cache.get(n, n));
}
for (int i = maxNodes; i < maxNodes * 2; i++)
{
assertNotNull(cache.get(rootStr + Integer.toString(i), rootStr + Integer.toString(i)));
}
// add another node to cache. this should push node 5000 out of cache.
cache.put(rootStr + "a", rootStr + "a", rootStr + "a");
for (int i = maxNodes + 1; i < maxNodes; i++)
{
assertNotNull(cache.get(rootStr + Integer.toString(i), rootStr + Integer.toString(i)));
}
assertNotNull(cache.get(rootStr + "a", rootStr + "a"));
}
public void testNodeVisited() throws InterruptedException
{
String rootStr = "/org/jboss/test/data/";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
try
{
cache.put(fqn, str, str);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
EvictionController evictionController = new EvictionController(cache);
evictionController.startEviction();
try
{
for (int i = 0; i < 5; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
assertNull(cache.get(fqn, str));
}
for (int i = 5; i < 10; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
assertNotNull(cache.get(fqn, str));
}
// since it is FIFO if we leave it alone and revisit, cache should remain the same.
for (int i = 5; i < 10; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
cache.get(fqn, str);// just to keep it fresh
}
}
catch (Exception e)
{
e.printStackTrace();
fail("Failed to evict" + e);
}
}
public void testNodeRemoved()
{
String rootStr = "/org/jboss/test";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i + "/" + i;
Fqn fqn = Fqn.fromString(str);
String str2 = rootStr + i;
Fqn fqn2 = Fqn.fromString(str2);
try
{
cache.put(fqn, str, str);
cache.put(fqn2, str2, str2);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
EvictionController evictionController = new EvictionController(cache);
evictionController.startEviction();
String str1 = rootStr + "7";
Fqn fqn1 = Fqn.fromString(str1);
String str2 = rootStr + "7/7";
Fqn fqn2 = Fqn.fromString(str2);
try
{
assertNotNull(cache.get(fqn2, str2));
assertNotNull(cache.get(fqn1, str1));
cache.removeNode(fqn2);
evictionController.startEviction();
assertNull(cache.get(fqn2, str2));
assertNotNull(cache.get(fqn1, str1));
cache.removeNode(fqn1);
evictionController.startEviction();
assertNull(cache.get(fqn1, str1));
assertNull(cache.get(fqn2, str2));
String str3 = rootStr + "5/5";
String str4 = rootStr + "5";
Fqn fqn3 = Fqn.fromString(str3);
Fqn fqn4 = Fqn.fromString(str4);
assertNotNull(cache.get(fqn3, str3));
assertNotNull(cache.get(fqn4, str4));
evictionController.startEviction();
// remove the node above fqn4 /org/jboss/test/5 will cascade the delete into /org/jboss/test/5/5
cache.removeNode(fqn4);
evictionController.startEviction();
assertNull(cache.get(fqn3, str3));
assertNull(cache.get(fqn4, str4));
}
catch (Exception e)
{
e.printStackTrace();
fail("Failed to evict" + e);
}
}
class MyPutter extends Thread
{
public MyPutter(String name)
{
super(name);
}
public void run()
{
int i = 0;
final String myName = ROOT_STR + "/test1/node" + getName();
while (isTrue)
{
try
{
cache.put(myName + i++, "value", i);
TestingUtil.sleepThread(2);
}
catch (Throwable e)
{
e.printStackTrace();
if (t1_ex == null)
{
isTrue = false;
t1_ex = e;
}
}
}
}
}
public void testConcurrentPutAndEvict() throws Exception
{
cache.put(ROOT_STR + "/concurrentPutAndEvict", "value", 1);
List putters = new ArrayList();
for (int i = 0; i < 5; i++)
{
MyPutter p = new MyPutter("FifoPolicyTestPutter" + i);
putters.add(p);
p.start();
}
int counter = 0;
while (true)
{
counter++;
if (t1_ex != null)
{
fail("Exception generated in put() " + t1_ex);
}
TestingUtil.sleepThread(250);
if (counter > 5)
{// run for 5 seconds
isTrue = false;
break;
}
}
for (MyPutter p : putters) p.join();
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LRUAlgorithmTest.java 0000755 0001750 0001750 00000032157 11357727733 030253 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.RegionImpl;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import org.jboss.cache.util.TestingUtil;
import org.testng.annotations.AfterMethod;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit tests for LRUAlgorithm.
*
* @author Ben Wang, Feb 11, 2004
* @author Daniel Huang (dhuang@jboss.org)
*/
@Test(groups = "functional", testName = "eviction.LRUAlgorithmTest")
public class LRUAlgorithmTest extends EvictionTestsBase
{
RegionManager regionManager;
LRUAlgorithm algorithm;
LRUAlgorithmConfig config;
Log log = LogFactory.getLog(LRUAlgorithm.class);
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
regionManager = new RegionManagerImpl();
config = new LRUAlgorithmConfig();
config.setTimeToLive(-1);
algorithm = (LRUAlgorithm) createAndAssignToRegion("/a/b", regionManager, config);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
regionManager = null;
config = null;
algorithm = null;
}
/**
* maxNodes = 1. Eception is evictFromCacheNode. Should be commented for now.
*/
public void testEvictException() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(1);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 1, algorithm.getEvictionQueue().getNumberOfNodes());
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 1, algorithm.getEvictionQueue().getNumberOfNodes());
}
/**
* maxNodes = -1 case
*/
public void testMaxNode1() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(-1);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 2, algorithm.getEvictionQueue().getNumberOfNodes());
}
/**
* maxNodes = 0 case
*/
public void testMaxNode2() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(0);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 0, algorithm.getEvictionQueue().getNumberOfNodes());
}
/**
* maxNodes = 1
*/
public void testMaxNode3() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(1);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 1, algorithm.getEvictionQueue().getNumberOfNodes());
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 1, algorithm.getEvictionQueue().getNumberOfNodes());
}
/**
* TimeToIdleSeconds = 0
*/
public void testIdleTimeSeconds1() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(-1);
config.setTimeToLive(-1);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 2, algorithm.getEvictionQueue().getNumberOfNodes());
}
/**
* TimeToIdleSeconds = 1
*/
public void testIdleTimeSeconds2() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(-1);
config.setTimeToLive(1000);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size #1: ", 3, algorithm.getEvictionQueue().getNumberOfNodes());
TestingUtil.sleepThread(1100);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size #2: ", 0, algorithm.getEvictionQueue().getNumberOfNodes());
}
/**
* TimeToIdleSeconds = 1 with node visited in between.
*/
public void testIdleTimeSeconds3() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(-1);
config.setTimeToLive(1000);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size #1: ", 3, algorithm.getEvictionQueue().getNumberOfNodes());
TestingUtil.sleepThread(1100);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.VISIT_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size #2: ", 1, algorithm.getEvictionQueue().getNumberOfNodes());
}
/**
* MaxAgeSeconds = 1 with 3 nodes.
*
* @throws Exception
*/
public void testMaxAgeSeconds1() throws Exception
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(-1);
config.setTimeToLive(-1);
config.setMaxAge(1000);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size #1: ", 3, algorithm.getEvictionQueue().getNumberOfNodes());
TestingUtil.sleepThread(1100);
algorithm.process(region.getEvictionEventQueue());
assertEquals("Queue size #2: ", 0, algorithm.getEvictionQueue().getNumberOfNodes());
}
/**
* Generic combo case.
*/
public void testCombo1() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
Fqn fqn4 = Fqn.fromString("/a/b/f");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
// Should have a maximum of 2 nodes.
config.setMaxNodes(2);
config.setTimeToLive(1000);
config.setMaxAge(3000);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn4, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
EvictionQueue eq = algorithm.getEvictionQueue();
int numNodesInQueue = eq.getNumberOfNodes();
assert 2 == numNodesInQueue : "Queue size #1: expected 2 but was " + numNodesInQueue;
// make sure all nodes now expire
TestingUtil.sleepThread(1100);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
numNodesInQueue = eq.getNumberOfNodes();
assert 1 == numNodesInQueue : "Queue size #2: expected 1 but was " + numNodesInQueue;
TestingUtil.sleepThread(3100);
// visit the node now to prevent the idle time from doing the pruning - node still gets pruned but by
// max age.
region.registerEvictionEvent(fqn3, EvictionEvent.Type.VISIT_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
numNodesInQueue = eq.getNumberOfNodes();
assert 0 == numNodesInQueue : "Queue size #3: expected 0 but was " + numNodesInQueue;
}
/**
* Generic combo case with newly added node should be around.
*/
public void testCombo2() throws EvictionException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(2);
config.setTimeToLive(1000);
config.setMaxAge(3000);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.REMOVE_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
EvictionQueue eq = algorithm.getEvictionQueue();
int numNodesInQueue = eq.getNumberOfNodes();
assert 1 == numNodesInQueue : "Queue size #1: expected 1 but was " + numNodesInQueue;
// make sure existing events all time out
TestingUtil.sleepThread(1100);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
numNodesInQueue = eq.getNumberOfNodes();
assert 1 == numNodesInQueue : "Queue size #2: expected 1 but was " + numNodesInQueue;
TestingUtil.sleepThread(3100);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.VISIT_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
numNodesInQueue = eq.getNumberOfNodes();
assert 0 == numNodesInQueue : "Queue size #3: expected 0 but was " + numNodesInQueue;
}
public void testEvictionSortOrder() throws EvictionException
{
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxAge(1000000);
config.setMaxNodes(0);
config.setTimeToLive(1000000);
for (int i = 0; i < 100; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
}
algorithm.process(region.getEvictionEventQueue());
for (int i = 0; i < 100; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
if (i % 2 == 0)
{
region.registerEvictionEvent(fqn, EvictionEvent.Type.VISIT_NODE_EVENT);
}
}
algorithm.process(region.getEvictionEventQueue());
LRUQueue queue = (LRUQueue) algorithm.getEvictionQueue();
NodeEntry ne;
int count = 0;
while ((ne = queue.getFirstLRUNodeEntry()) != null)
{
if (count < 50)
{
assertEquals(1, ne.getNumberOfNodeVisits());
}
else
{
assertEquals(2, ne.getNumberOfNodeVisits());
}
queue.removeNodeEntry(ne);
count++;
}
for (int i = 0; i < 100; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
}
algorithm.process(region.getEvictionEventQueue());
long lastCreateTimestamp = 0;
while ((ne = queue.getFirstMaxAgeNodeEntry()) != null)
{
assertTrue(ne.getCreationTimeStamp() >= lastCreateTimestamp);
lastCreateTimestamp = ne.getCreationTimeStamp();
queue.removeNodeEntry(ne);
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/MRUAlgorithmTest.java 0000644 0001750 0001750 00000012011 11111047320 030203 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.Fqn;
import org.jboss.cache.RegionImpl;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import org.testng.annotations.AfterMethod;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit tests for MRUAlgorithm.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.MRUAlgorithmTest")
public class MRUAlgorithmTest extends EvictionTestsBase
{
MRUAlgorithm algorithm;
RegionManager regionManager;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
regionManager = new RegionManagerImpl();
MRUAlgorithmConfig config = new MRUAlgorithmConfig();
config.setMaxNodes(0);
algorithm = (MRUAlgorithm) createAndAssignToRegion("/a/b", regionManager, config);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
regionManager = null;
algorithm = null;
}
public void testMaxNodes() throws Exception
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
MRUAlgorithmConfig config = (MRUAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(1);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals(1, algorithm.getEvictionQueue().getNumberOfNodes());
config.setMaxNodes(100);
for (int i = 0; i < 150; i++)
{
Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
}
algorithm.process(region.getEvictionEventQueue());
assertEquals(100, algorithm.getEvictionQueue().getNumberOfNodes());
}
public void testMRU() throws Exception
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
Fqn fqn4 = Fqn.fromString("/a/b/f");
Fqn fqn5 = Fqn.fromString("/a/b/g");
Fqn fqn6 = Fqn.fromString("/a/b/h");
Fqn fqn7 = Fqn.fromString("/a/b/i");
Fqn fqn8 = Fqn.fromString("/a/b/j");
Fqn fqn9 = Fqn.fromString("/a/b/k");
Fqn fqn10 = Fqn.fromString("/a/b/l");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
MRUAlgorithmConfig config = (MRUAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(8);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn4, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn5, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn6, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn7, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn8, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals(8, algorithm.getEvictionQueue().getNumberOfNodes());
region.registerEvictionEvent(fqn9, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn10, EvictionEvent.Type.ADD_NODE_EVENT);
// Thread.sleep(5000);
assertEquals(8, algorithm.getEvictionQueue().getNumberOfNodes());
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn4, EvictionEvent.Type.ADD_NODE_EVENT);
algorithm.process(region.getEvictionEventQueue());
assertEquals(8, algorithm.getEvictionQueue().getNumberOfNodes());
assertNull(algorithm.getEvictionQueue().getNodeEntry(fqn2));
assertNull("No FQN4 " + algorithm.getEvictionQueue(),
algorithm.getEvictionQueue().getNodeEntry(fqn4));
assertNotNull(algorithm.getEvictionQueue().getNodeEntry(fqn1));
assertNotNull(algorithm.getEvictionQueue().getNodeEntry(fqn3));
assertNotNull(algorithm.getEvictionQueue().getNodeEntry(fqn5));
assertNotNull(algorithm.getEvictionQueue().getNodeEntry(fqn6));
assertNotNull(algorithm.getEvictionQueue().getNodeEntry(fqn7));
assertNotNull(algorithm.getEvictionQueue().getNodeEntry(fqn8));
assertNotNull(algorithm.getEvictionQueue().getNodeEntry(fqn9));
assertNotNull(algorithm.getEvictionQueue().getNodeEntry(fqn10));
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ReplicatedLRUPolicyTest.java 0000755 0001750 0001750 00000013100 11136027056 031526 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.notifications.annotation.CacheListener;
import org.jboss.cache.notifications.annotation.NodeEvicted;
import org.jboss.cache.notifications.event.Event;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
import org.jboss.cache.util.internals.EvictionWatcher;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.concurrent.TimeUnit;
import org.jboss.cache.UnitTestCacheFactory;
/**
* @author Ben Wang, Feb 11, 2004
*/
@Test(groups = {"functional"}, testName = "eviction.ReplicatedLRUPolicyTest")
public class ReplicatedLRUPolicyTest extends EvictionTestsBase
{
CacheSPI cache1, cache2;
EvictionListener listener = new EvictionListener();
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
cache1 = (CacheSPI) new UnitTestCacheFactory().createCache(UnitTestConfigurationFactory.createConfiguration(CacheMode.REPL_SYNC, true), false, getClass());
cache1.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache1.getConfiguration().setUseRegionBasedMarshalling(true);
cache1.getConfiguration().getEvictionConfig().setWakeupInterval(0);
cache1.start();
cache1.getNotifier().addCacheListener(listener);
listener.resetCounter();
cache2 = (CacheSPI) new UnitTestCacheFactory().createCache(cache1.getConfiguration().clone(), false, getClass());
cache2.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache2.getConfiguration().setUseRegionBasedMarshalling(true);
cache2.getConfiguration().getEvictionConfig().setWakeupInterval(0);
cache2.start();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache1, cache2);
cache1 = null;
cache2 = null;
}
/**
* Test local eviction policy that failed for eviction event.
*/
public void testBasic() throws Exception
{
String rootStr = "/org/jboss/test/data/";
LRUAlgorithmConfig cfg = (LRUAlgorithmConfig) cache1.getConfiguration().getEvictionConfig().getEvictionRegionConfig(rootStr).getEvictionAlgorithmConfig();
cfg.setMaxAge(0);
cfg.setTimeToLive(0);
cfg = (LRUAlgorithmConfig) cache2.getConfiguration().getEvictionConfig().getEvictionRegionConfig(rootStr).getEvictionAlgorithmConfig();
cfg.setMaxAge(-1, TimeUnit.SECONDS);
cfg.setTimeToLive(-1, TimeUnit.SECONDS);
cfg.setMaxNodes(200);
String str = rootStr + "0";
Fqn fqn = Fqn.fromString(str);
cache1.put(str, str, str);
new EvictionController(cache1).startEviction();
Object node = cache1.peek(fqn, false);
assertNull("Node should be evicted already ", node);
assertEquals("Eviction counter ", 1, listener.getCounter());
String val = (String) cache2.get(str, str);
assertNotNull("DataNode should not be evicted here ", val);
assertEquals("Eviction counter ", 1, listener.getCounter());
}
public void testEviction() throws Exception
{
String rootStr = "/org/jboss/test/data/";
LRUAlgorithmConfig cfg = (LRUAlgorithmConfig) cache2.getConfiguration().getEvictionConfig().getEvictionRegionConfig(rootStr).getEvictionAlgorithmConfig();
cfg.setMaxAge(60, TimeUnit.SECONDS);
cfg.setTimeToLive(360, TimeUnit.SECONDS);
cfg.setMaxNodes(200);
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
cache1.put(fqn, str, str);
}
new EvictionController(cache1).startEviction();
String val = (String) cache1.get(rootStr + "3", rootStr + "3");
assertNull("DataNode should be evicted already ", val);
val = (String) cache2.get(rootStr + "3", rootStr + "3");
assertNotNull("DataNode should not be evicted here ", val);
}
public void testEvictionReplication() throws Exception
{
String rootStr = "/org/jboss/test/data/";
LRUAlgorithmConfig cfg = (LRUAlgorithmConfig) cache2.getConfiguration().getEvictionConfig().getEvictionRegionConfig(rootStr).getEvictionAlgorithmConfig();
cfg.setMaxAge(60, TimeUnit.SECONDS);
cfg.setTimeToLive(360, TimeUnit.SECONDS);
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
cache1.put(fqn, str, str);
}
String str = rootStr + "7";
Fqn fqn = Fqn.fromString(str);
cache1.get(fqn, str);
new EvictionController(cache1).startEviction();
String val = (String) cache1.get(rootStr + "3", rootStr + "3");
assertNull("DataNode should be empty ", val);
val = (String) cache2.get(rootStr + "7", rootStr + "7");
assertNotNull("DataNode should not be null", val);
}
@CacheListener
public class EvictionListener
{
int counter = 0;
public int getCounter()
{
return counter;
}
public void resetCounter()
{
counter = 0;
}
@NodeEvicted
public void nodeEvicted(Event e)
{
if (e.isPre()) counter++;
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/EvictionQueueListTest.java 0000644 0001750 0001750 00000015161 11120421353 031325 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7289 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.EvictionQueueListTest")
public class EvictionQueueListTest
{
EvictionQueueList list;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
list = new EvictionQueueList();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
list = null;
}
public void testAddToBottom() throws Exception
{
for (int i = 0; i < 100; i++)
{
NodeEntry ne = new NodeEntry("/" + Integer.toString(i));
EvictionListEntry listEntry = new EvictionListEntry(ne);
list.addToBottom(listEntry);
}
assertEquals(100, list.size());
for (int i = 0; i < 100; i++)
{
EvictionListEntry entry = list.getFirst();
assertEquals("/" + Integer.toString(i), entry.node.getFqn().toString());
list.remove(entry);
}
}
public void testAddToTop() throws Exception
{
for (int i = 0; i < 100; i++)
{
NodeEntry ne = new NodeEntry("/" + Integer.toString(i));
EvictionListEntry listEntry = new EvictionListEntry(ne);
list.addToTop(listEntry);
}
assertEquals(100, list.size());
for (int i = 99; i >= 0; i--)
{
EvictionListEntry entry = list.getFirst();
assertEquals("/" + Integer.toString(i), entry.node.getFqn().toString());
list.remove(entry);
}
}
public void testRemoveAndClear() throws Exception
{
EvictionListEntry listEntry1 = new EvictionListEntry(new NodeEntry("/0"));
list.addToBottom(listEntry1);
assertEquals(list.getFirst(), list.getLast());
EvictionListEntry listEntry2 = new EvictionListEntry(new NodeEntry("/1"));
list.addToBottom(listEntry2);
EvictionListEntry listEntry3 = new EvictionListEntry(new NodeEntry("/2"));
list.addToBottom(listEntry3);
EvictionListEntry listEntry4 = new EvictionListEntry(new NodeEntry("/3"));
list.addToBottom(listEntry4);
EvictionListEntry listEntry5 = new EvictionListEntry(new NodeEntry("/4"));
list.addToBottom(listEntry5);
EvictionListEntry listEntry6 = new EvictionListEntry(new NodeEntry("/5"));
list.addToBottom(listEntry6);
assertEquals(6, list.size());
assertEquals(listEntry1, list.getFirst());
assertEquals(listEntry6, list.getLast());
// test removal from the top.
list.remove(list.getFirst());
assertEquals(5, list.size());
assertEquals(listEntry2, list.getFirst());
// test removal from the bottom.
list.remove(list.getLast());
assertEquals(4, list.size());
assertEquals(listEntry5, list.getLast());
// test removal from the middle
list.remove(listEntry3);
assertEquals(3, list.size());
assertEquals(listEntry2, list.getFirst());
assertEquals(listEntry5, list.getLast());
Iterator it = list.iterator();
int count = 0;
while (it.hasNext())
{
NodeEntry e = (NodeEntry) it.next();
if (count == 0)
{
assertEquals(listEntry2.node, e);
}
else if (count == 1)
{
assertEquals(listEntry4.node, e);
}
else if (count == 2)
{
assertEquals(listEntry5.node, e);
}
count++;
}
assertEquals(3, count);
// test clear.
list.clear();
assertEquals(0, list.size());
boolean caught = false;
try
{
list.getFirst();
}
catch (NoSuchElementException e)
{
caught = true;
}
assertTrue(caught);
caught = false;
try
{
list.getLast();
}
catch (NoSuchElementException e)
{
caught = true;
}
assertTrue(caught);
}
public void testIterator() throws Exception
{
for (int i = 0; i < 100; i++)
{
NodeEntry ne = new NodeEntry("/" + Integer.toString(i));
EvictionListEntry listEntry = new EvictionListEntry(ne);
list.addToBottom(listEntry);
}
Iterator it = list.iterator();
int count = 0;
while (it.hasNext())
{
NodeEntry e = (NodeEntry) it.next();
assertEquals("/" + Integer.toString(count), e.getFqn().toString());
it.remove();
count++;
}
assertEquals(0, list.size());
it = list.iterator();
assertFalse(it.hasNext());
for (int i = 0; i < 100; i++)
{
NodeEntry ne = new NodeEntry("/" + Integer.toString(i));
EvictionListEntry listEntry = new EvictionListEntry(ne);
list.addToBottom(listEntry);
}
it = list.iterator();
boolean caught = false;
try
{
while (it.hasNext())
{
list.addToBottom(new EvictionListEntry(new NodeEntry("/a/b/c")));
}
}
catch (ConcurrentModificationException e)
{
caught = true;
}
assertTrue(caught);
}
public void testToArray() throws Exception
{
for (int i = 0; i < 100; i++)
{
NodeEntry ne = new NodeEntry("/" + Integer.toString(i));
EvictionListEntry listEntry = new EvictionListEntry(ne);
list.addToTop(listEntry);
}
EvictionListEntry entries[] = list.toArray();
assertEquals(100, entries.length);
for (int i = 0, j = 99; i < 100; i++, j--)
{
assertEquals("/" + Integer.toString(j), entries[i].node.getFqn().toString());
}
}
public void testFromArray() throws Exception
{
EvictionListEntry entries[] = new EvictionListEntry[100];
for (int i = 0; i < 100; i++)
{
entries[i] = new EvictionListEntry(new NodeEntry("/" + Integer.toString(i)));
}
assertEquals(0, list.size());
list.fromArray(entries);
assertEquals(100, list.size());
for (int i = 0; i < 100; i++)
{
assertEquals(entries[i], list.getFirst());
list.remove(list.getFirst());
}
assertEquals(0, list.size());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/BaseEvictionAlgorithmTest.java 0000644 0001750 0001750 00000013530 11111047320 032122 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source.
* Copyright 2008, 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.eviction;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.RegionImpl;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import org.jboss.cache.RegionRegistry;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.ConfigurationException;
import org.jboss.cache.config.EvictionAlgorithmConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import static org.testng.AssertJUnit.fail;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
* Tests BaseEvictionAlgorithm class.
*
* @author Galder Zamarreno
*/
@Test(groups = "functional", testName = "eviction.BaseEvictionAlgorithmTest")
public class BaseEvictionAlgorithmTest
{
private static final Log log = LogFactory.getLog(BaseEvictionAlgorithmTest.class);
private RegionManager regionManager;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
RegionManagerImpl rmi = new RegionManagerImpl();
rmi.injectDependencies(null, new Configuration(), null, null, null, new RegionRegistry());
regionManager = rmi;
}
public void testFillUpRecycleQueue() throws Exception
{
final int recycleQueueCapacity = 10;
/* override recycle queue capacity to make the test shorter */
BaseEvictionAlgorithm algorithm = new MockEvictionAlgorithm(recycleQueueCapacity);
Region region = regionManager.getRegion("/a/b/c", true);
region.setEvictionRegionConfig(new EvictionRegionConfig(region.getFqn(), new MockEvictionAlgorithmConfig()));
for (int i = 0; i < (recycleQueueCapacity + 1); i++)
{
Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i + 1));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
}
ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(new ProcessEvictionRegion((RegionImpl) region, algorithm));
try
{
future.get(20, TimeUnit.SECONDS);
}
catch (TimeoutException te)
{
log.error("Region eviction processing did not finish on time", te);
fail("Region eviction processing should have finished by now, something is wrong. Recycle queue may have filled up.");
}
finally
{
log.info("recycle queue size: " + algorithm.recycleQueue.size());
}
}
/**
* Classes *
*/
public static class MockEvictionAlgorithm extends BaseEvictionAlgorithm
{
private static MockEvictionAlgorithm singleton;
private MockEvictionAlgorithm(int recycleQueueCapacity)
{
recycleQueue = new LinkedBlockingQueue(recycleQueueCapacity);
singleton = this;
}
public static MockEvictionAlgorithm getInstance()
{
return singleton;
}
@Override
protected EvictionQueue setupEvictionQueue() throws EvictionException
{
return new LRUQueue();
}
@Override
protected boolean shouldEvictNode(NodeEntry ne)
{
/* all node entries need evicting */
return true;
}
public Class getConfigurationClass()
{
return null;
}
}
public static class MockEvictionAlgorithmConfig implements EvictionAlgorithmConfig
{
public void reset()
{
/* no op */
}
public String getEvictionAlgorithmClassName()
{
return MockEvictionAlgorithm.class.getName();
}
public void validate() throws ConfigurationException
{
/* no op */
}
public EvictionAlgorithmConfig clone() throws CloneNotSupportedException
{
return (EvictionAlgorithmConfig) super.clone();
}
}
public class ProcessEvictionRegion implements Callable
{
private RegionImpl region;
private EvictionAlgorithm algorithm;
public ProcessEvictionRegion(RegionImpl region, EvictionAlgorithm algorithm)
{
this.region = region;
this.algorithm = algorithm;
}
public Void call() throws Exception
{
try
{
algorithm.process(region.getEvictionEventQueue());
}
catch (EvictionException e)
{
log.error("Eviction exception reported", e);
fail("Eviction exception reported" + e);
}
return null;
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/MRUPolicyTest.java 0000644 0001750 0001750 00000014601 11132110773 027531 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit tests for MRUPolicy.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7439 $
*/
@Test(groups = {"functional"}, testName = "eviction.MRUPolicyTest")
public class MRUPolicyTest
{
CacheSPI cache;
long wakeupIntervalMillis = 0;
final String ROOT_STR = "/test";
volatile Throwable t1_ex, t2_ex;
volatile boolean isTrue;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
initCaches();
wakeupIntervalMillis = cache.getConfiguration().getEvictionConfig().getWakeupInterval();
if (wakeupIntervalMillis < 0)
{
fail("testEviction(): eviction thread wake up interval is illegal " + wakeupIntervalMillis);
}
t1_ex = t2_ex = null;
isTrue = true;
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
private void initCaches()
{
Configuration config = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
EvictionConfig evConfig = config.getEvictionConfig();
evConfig.setWakeupInterval(200);
// root ERC
evConfig.setDefaultEvictionRegionConfig(new EvictionRegionConfig(Fqn.ROOT, new MRUAlgorithmConfig(100), 200000));
// new region ERC
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/org/jboss/test/data"), new MRUAlgorithmConfig(6)));
config.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
config.setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache = (CacheSPI) new UnitTestCacheFactory().createCache(config, getClass());
}
public void testEviction() throws Exception
{
cache.put("/org/jboss/test/data/a", "/org/jboss/test/data/a", "/org/jboss/test/data/a");
cache.put("/org/jboss/test/data/b", "/org/jboss/test/data/b", "/org/jboss/test/data/b");
cache.put("/org/jboss/test/data/c", "/org/jboss/test/data/c", "/org/jboss/test/data/c");
cache.put("/org/jboss/test/data/d", "/org/jboss/test/data/d", "/org/jboss/test/data/d");
cache.put("/org/jboss/test/data/e", "/org/jboss/test/data/e", "/org/jboss/test/data/e");
EvictionController ec = new EvictionController(cache);
ec.startEviction();
cache.put("/org/jboss/test/data/f", "/org/jboss/test/data/f", "/org/jboss/test/data/f");
cache.put("/org/jboss/test/data/g", "/org/jboss/test/data/g", "/org/jboss/test/data/g");
cache.put("/org/jboss/test/data/h", "/org/jboss/test/data/h", "/org/jboss/test/data/h");
assertNotNull(cache.get("/org/jboss/test/data/a", "/org/jboss/test/data/a"));
assertNotNull(cache.get("/org/jboss/test/data/b", "/org/jboss/test/data/b"));
ec.startEviction();
assertNull(cache.get("/org/jboss/test/data/a", "/org/jboss/test/data/a"));
assertNull(cache.get("/org/jboss/test/data/b", "/org/jboss/test/data/b"));
}
public void testNodeRemoved() throws Exception
{
cache.put("/org/jboss/test/data/a", "/org/jboss/test/data/a", "/org/jboss/test/data/a");
cache.put("/org/jboss/test/data/b", "/org/jboss/test/data/b", "/org/jboss/test/data/b");
cache.put("/org/jboss/test/data/c", "/org/jboss/test/data/c", "/org/jboss/test/data/c");
cache.put("/org/jboss/test/data/d", "/org/jboss/test/data/d", "/org/jboss/test/data/d");
cache.put("/org/jboss/test/data/e", "/org/jboss/test/data/e", "/org/jboss/test/data/e");
EvictionController ec = new EvictionController(cache);
ec.startEviction();
cache.removeNode("/org/jboss/test/data/d");
cache.removeNode("/org/jboss/test/data/e");
cache.put("/org/jboss/test/data/f", "/org/jboss/test/data/f", "/org/jboss/test/data/f");
cache.put("/org/jboss/test/data/g", "/org/jboss/test/data/g", "/org/jboss/test/data/g");
ec.startEviction();
assertNull(cache.get("/org/jboss/test/data/d", "/org/jboss/test/data/d"));
assertNull(cache.get("/org/jboss/test/data/e", "/org/jboss/test/data/e"));
assertNotNull(cache.get("/org/jboss/test/data/f", "/org/jboss/test/data/f"));
assertNotNull(cache.get("/org/jboss/test/data/g", "/org/jboss/test/data/g"));
}
class MyPutter extends Thread
{
public MyPutter(String name)
{
super(name);
}
public void run()
{
int i = 0;
final String myName = ROOT_STR + "/test1/node" + getName();
while (isTrue)
{
try
{
cache.put(myName + i++, "value", i);
TestingUtil.sleepThread(1);
}
catch (Throwable e)
{
e.printStackTrace();
if (t1_ex == null)
{
isTrue = false;
t1_ex = e;
}
}
}
}
}
public void testConcurrentPutAndEvict() throws Exception
{
cache.stop();
cache.destroy();
cache.getConfiguration().setIsolationLevel(IsolationLevel.REPEATABLE_READ);
cache.start();
cache.put(ROOT_STR + "/concurrentPutAndEvict", "value", 1);
for (int i = 0; i < 5; i++)
{
new MyPutter("MRUPolicyTestPutter" + i).start();
}
int counter = 0;
while (true)
{
counter++;
if (t1_ex != null)
{
fail("Exception generated in put() " + t1_ex);
}
TestingUtil.sleepThread(250);
if (counter > 5)
{// run for 5 seconds
isTrue = false;
break;
}
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ConcurrentEvictionTest.java 0000644 0001750 0001750 00000010167 11131613416 031535 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.Cache;
import org.jboss.cache.Fqn;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.TestingUtil;
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 java.io.IOException;
import org.jboss.cache.UnitTestCacheFactory;
/**
* Tests cache behavior in the presence of concurrent passivation.
*
* @author Brian Stansberry
* @version $Revision: 7422 $
*/
@Test(groups = {"functional"}, testName = "eviction.ConcurrentEvictionTest")
public class ConcurrentEvictionTest
{
private Cache cache;
private long wakeupIntervalMillis = 0;
private String tmpDir = TestingUtil.TEST_FILES;
private String cacheLoaderDir = "JBossCacheFileCacheLoader";
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
initCaches();
wakeupIntervalMillis = cache.getConfiguration().getEvictionConfig().getWakeupInterval();
if (wakeupIntervalMillis < 0)
{
fail("testEviction(): eviction thread wake up interval is illegal " + wakeupIntervalMillis);
}
}
void initCaches() throws Exception
{
UnitTestCacheFactory factory = new UnitTestCacheFactory();
Configuration conf = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
conf.setEvictionConfig(buildEvictionConfig());
conf.setCacheLoaderConfig(buildCacheLoaderConfig());
conf.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache = factory.createCache(conf, true, getClass());// read in generic local xml
}
private CacheLoaderConfig buildCacheLoaderConfig()
throws IOException
{
CacheLoaderConfig cacheLoaderConfig = new CacheLoaderConfig();
cacheLoaderConfig.setPassivation(false);
cacheLoaderConfig.setPreload("/");
cacheLoaderConfig.setShared(false);
CacheLoaderConfig.IndividualCacheLoaderConfig iclc = new CacheLoaderConfig.IndividualCacheLoaderConfig();
iclc.setClassName("org.jboss.cache.loader.testloaders.DummyInMemoryCacheLoader");
iclc.setAsync(false);
iclc.setFetchPersistentState(true);
iclc.setIgnoreModifications(false);
cacheLoaderConfig.addIndividualCacheLoaderConfig(iclc);
return cacheLoaderConfig;
}
private EvictionConfig buildEvictionConfig()
{
return new EvictionConfig(
new EvictionRegionConfig(
Fqn.ROOT,
new LRUAlgorithmConfig(1000000, 5000)
),
200);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
}
public void testConcurrentEviction() throws Exception
{
Fqn base = Fqn.fromString("/org/jboss/test/data/concurrent/eviction");
// Create a bunch of nodes; more than the /org/jboss/test/data
// region's maxNodes so we know eviction will kick in
for (int i = 0; i < 1000; i++)
{
cache.put(Fqn.fromRelativeElements(base, i / 100), i, "value");
}
// Loop for long enough to have 5 runs of the eviction thread
long loopDone = System.currentTimeMillis() + (5 * wakeupIntervalMillis);
while (System.currentTimeMillis() < loopDone)
{
// If any get returns null, that's a failure
for (int i = 0; i < 1000; i++)
{
Fqn fqn = Fqn.fromRelativeElements(base, i / 100);
assertNotNull("found value under Fqn " + fqn + " and key " + i,
cache.get(fqn, i));
}
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/OptimisticEvictionTest.java 0000644 0001750 0001750 00000007557 11131613416 031550 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.interceptors.EvictionInterceptor;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
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 java.util.Iterator;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.jboss.cache.UnitTestCacheFactory;
/**
* Tests the eviction and the possible lack of locking nodes.
* The configuration is with an aggressive eviction policy, 100 objects 2 seconds interval.
*
* It is possible that the number needs to be changed a little, depending on the machine speed.
*
* @author fhenning
*/
@Test(groups = {"functional"}, testName = "eviction.OptimisticEvictionTest")
public class OptimisticEvictionTest extends EvictionTestsBase
{
private CacheSPI cache;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
Configuration config = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
config.setNodeLockingScheme(Configuration.NodeLockingScheme.OPTIMISTIC);
config.setEvictionConfig(buildEvictionConfig());
cache = (CacheSPI) new UnitTestCacheFactory().createCache(config, getClass());
}
private EvictionConfig buildEvictionConfig() throws Exception
{
EvictionConfig result = new EvictionConfig(new EvictionRegionConfig(Fqn.ROOT, new LRUAlgorithmConfig(0, 0, 10)), 200);
result.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/testingRegion"), new LRUAlgorithmConfig(0, 0, 10)));
result.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/timeBased"), new LRUAlgorithmConfig(1000, 1000, 0)));
return result;
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
public void testEvictionOccurence() throws Exception
{
cache.put("/timeBased/test", "key", "value");
assertTrue(cache.exists("/timeBased/test"));
TestingUtil.sleepThread(2000);
new EvictionController(cache).startEviction();
assertTrue(!cache.exists("/timeBased/test"));
}
public void testInterceptorChain() throws Exception
{
List interceptors = cache.getInterceptorChain();
Iterator i = interceptors.iterator();
boolean found = false;
while (i.hasNext())
{
Object o = i.next();
if (o instanceof EvictionInterceptor)
{
found = true;
}
}
assertTrue("Eviction interceptor should be in interceptor chain.", found);
}
public void testCompleteRemoval() throws Exception
{
String rootStr = "/timeBased/";
// Add a parent, then a child. LRU will evict the parent,
// then the child, leaving behind an empty parent
Fqn parent = Fqn.fromString(rootStr + "parent");
cache.put(parent, "key", "value");
cache.put(Fqn.fromRelativeElements(parent, "child"), "key", "value");
// Give eviction time to run a few times, then confirm parent
// is completely gone
assert waitForEviction(cache, 30, TimeUnit.SECONDS, parent);
// wait for this twice since the first time will only clear the parent's contents since a child exists.
assert waitForEviction(cache, 30, TimeUnit.SECONDS, parent);
assertFalse("Parent completely removed", cache.getRoot().hasChild(parent));
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ProgrammaticLRUPolicyTest.java 0000644 0001750 0001750 00000016271 11131613416 032104 0 ustar moeller moeller /*
* 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.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.RegionManager;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
/**
* Unit tests for programmatic configuration of LRU policy
*
* @author Ben Wang, Oct, 2006
* @version $Revision: 7422 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.ProgrammaticLRUPolicyTest")
public class ProgrammaticLRUPolicyTest extends EvictionTestsBase
{
CacheSPI cache;
EvictionController evController;
long wakeupIntervalMillis = 0;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
initCache();
wakeupIntervalMillis = cache.getConfiguration().getEvictionConfig().getWakeupInterval();
evController = new EvictionController(cache);
}
private void initCache()
{
Configuration conf = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
UnitTestCacheFactory instance = new UnitTestCacheFactory();
cache = (CacheSPI) instance.createCache(conf, false, getClass());
EvictionConfig erc = new EvictionConfig(new EvictionRegionConfig(Fqn.ROOT, new LRUAlgorithmConfig(0, 0, 10)), -1);
conf.setEvictionConfig(erc);
cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache.getConfiguration().setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache.create();
cache.start();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
private void addStringBasedRegion() throws Exception
{
LRUAlgorithmConfig lru = new LRUAlgorithmConfig(150, 0, 1000);
EvictionRegionConfig regConfig = new EvictionRegionConfig(Fqn.fromString("/dummy"), lru);
RegionManager regionManager = cache.getRegionManager();
EvictionConfig topConfig = cache.getConfiguration().getEvictionConfig();
topConfig.addEvictionRegionConfig(regConfig);
regionManager.setEvictionConfig(topConfig);
// Fqn is the region name
regionManager.getRegion("/programmatic", true).setEvictionRegionConfig(regConfig);
}
public void testStringBasedFqnEviction() throws Exception
{
addStringBasedRegion();
String rootStr = "/programmatic/";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
}
String val = (String) cache.get(rootStr + "3", rootStr + "3");
assertNotNull("DataNode should be empty ", val);
evController.startEviction();
val = (String) cache.get(rootStr + "3", rootStr + "3");
assertNull("DataNode should be empty ", val);
}
private void addObjectBasedRegion() throws Exception
{
LRUAlgorithmConfig lru = new LRUAlgorithmConfig(150, 1000);
EvictionRegionConfig regConfig = new EvictionRegionConfig(Fqn.fromElements(1), lru);
RegionManager regionManager = cache.getRegionManager();
EvictionConfig topConfig = cache.getConfiguration().getEvictionConfig();
topConfig.addEvictionRegionConfig(regConfig);
regionManager.setEvictionConfig(topConfig);
regionManager.getRegion(Fqn.fromElements(1), true).setEvictionRegionConfig(regConfig);
}
public void testObjectBasedFqnEviction1() throws Exception
{
addStringBasedRegion();
String rootStr = "programmatic";
for (int i = 0; i < 10; i++)
{
String str = rootStr;
Integer in = i;
Fqn fqn = Fqn.fromElements(rootStr, in);
try
{
cache.put(fqn, str, str);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
Integer in = 3;
Fqn fqn = Fqn.fromElements(rootStr, in);
try
{
String val = (String) cache.get(fqn, in);
assertNull("DataNode should be empty ", val);
}
catch (Exception e)
{
e.printStackTrace();
fail("Failed to get" + e);
}
evController.startEviction();
try
{
String val = (String) cache.get(fqn, in);
assertNull("DataNode should be empty ", val);
}
catch (Exception e)
{
e.printStackTrace();
fail("Failed to get" + e);
}
}
public void testObjectBasedFqnEviction2() throws Exception
{
addObjectBasedRegion();
Fqn rootfqn = Fqn.fromElements((Integer) 1);
for (int i = 0; i < 10; i++)
{
Fqn fqn = Fqn.fromRelativeElements(rootfqn, i);
try
{
cache.put(fqn, i, i);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
try
{
Integer in = 3;
Fqn fqn = Fqn.fromRelativeElements(rootfqn, in);
Object val = cache.get(fqn, in);
assertNotNull("DataNode should not be empty ", val);
}
catch (Exception e)
{
e.printStackTrace();
fail("Failed to get" + e);
}
Integer in = 3;
Fqn fqn = Fqn.fromRelativeElements(rootfqn, in);
Thread.sleep(1500);//max age is 1000, so this should expire
evController.startEviction();
try
{
Object val = cache.get(fqn, in);
assertNull("DataNode should be empty ", val);
}
catch (Exception e)
{
e.printStackTrace();
fail("Failed to get" + e);
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/FIFOQueueTest.java 0000644 0001750 0001750 00000012543 11121730272 027441 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertNull;
import static org.testng.AssertJUnit.assertTrue;
import org.jboss.cache.config.EvictionConfig;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit tests for FIFOQueue.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7332 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.FIFOQueueTest")
public class FIFOQueueTest
{
private static final int CAPACITY = EvictionConfig.EVENT_QUEUE_SIZE_DEFAULT/4;
private FIFOQueue queue;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
queue = new FIFOQueue();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
queue = null;
}
public void testQueue() throws Exception
{
for (int i = 0; i < 50000; i++)
{
NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
queue.addNodeEntry(ne);
}
assertEquals(queue.getFirstNodeEntry().getFqn().toString(), "/a/b/c/0");
assertEquals(50000, queue.getNumberOfNodes());
assertTrue(queue.containsNodeEntry(new NodeEntry("/a/b/c/250")));
NodeEntry ne27500 = queue.getNodeEntry("/a/b/c/27500");
assertEquals("/a/b/c/27500", ne27500.getFqn().toString());
// now make sure the ordering is correct.
int k = 0;
NodeEntry ne;
while ((ne = queue.getFirstNodeEntry()) != null)
{
assertEquals("/a/b/c/" + Integer.toString(k), ne.getFqn().toString());
queue.removeNodeEntry(ne);
k++;
if (k == 25000)
{
break;
}
}
assertEquals(queue.getFirstNodeEntry().getFqn().toString(), "/a/b/c/25000");
assertEquals(25000, queue.getNumberOfNodes());
k = 25000;
while ((ne = queue.getFirstNodeEntry()) != null)
{
assertEquals(ne.getFqn().toString(), "/a/b/c/" + Integer.toString(k));
queue.removeNodeEntry(ne);
k++;
}
assertEquals(0, queue.getNumberOfNodes());
assertFalse(queue.containsNodeEntry(new NodeEntry("/a/b/c/27500")));
assertNull(queue.getNodeEntry("/a/b/c/27500"));
}
public void testGetFirstNodeEntry() throws Exception
{
for (int i = 0; i < 50000; i++)
{
NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
queue.addNodeEntry(ne);
}
NodeEntry ne;
int count = 0;
while ((ne = queue.getFirstNodeEntry()) != null)
{
assertEquals("/a/b/c/" + Integer.toString(count), ne.getFqn().toString());
queue.removeNodeEntry(ne);
count++;
}
}
public void testLargeAddAndRemoval() throws Exception
{
for (int i = 0; i < CAPACITY; i++)
{
queue.addNodeEntry(new NodeEntry("/test/" + Integer.toString(i)));
}
assertEquals(CAPACITY, queue.getNumberOfNodes());
for (int i = CAPACITY - 1; i >= 0; i--)
{
// pop it backwards for worse case scenario if O(n) = n
queue.removeNodeEntry(new NodeEntry("/test/" + Integer.toString(i)));
}
assertEquals(0, queue.getNumberOfNodes());
for (int i = 0; i < CAPACITY; i++)
{
queue.addNodeEntry(new NodeEntry("/test/" + Integer.toString(i)));
}
assertEquals(CAPACITY, queue.getNumberOfNodes());
NodeEntry ne;
while ((ne = queue.getFirstNodeEntry()) != null)
{
queue.removeNodeEntry(ne);
}
assertEquals(0, queue.getNumberOfNodes());
}
public void testNumElements() throws Exception
{
FIFOQueue queue = new FIFOQueue();
NodeEntry ne = new NodeEntry("/a/b/c");
ne.setNumberOfElements(50);
queue.addNodeEntry(ne);
assertEquals(50, queue.getNumberOfElements());
assertEquals(1, queue.getNumberOfNodes());
queue.removeNodeEntry(ne);
assertEquals(0, queue.getNumberOfElements());
for (int i = 0; i < 10; i++)
{
ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
ne.setNumberOfElements(i);
queue.addNodeEntry(ne);
}
assertEquals(45, queue.getNumberOfElements());
assertEquals(10, queue.getNumberOfNodes());
ne = queue.getNodeEntry("/a/b/c/0");
assertNotNull(ne);
assertEquals(0, ne.getNumberOfElements());
ne.setNumberOfElements(500);
assertEquals(545, queue.getNumberOfElements());
ne = queue.getNodeEntry("/a/b/c/0");
assertEquals(500, ne.getNumberOfElements());
queue.removeNodeEntry(ne);
assertEquals(45, queue.getNumberOfElements());
assertEquals(9, queue.getNumberOfNodes());
for (int i = 1; i < 10; i++)
{
ne = queue.getNodeEntry("/a/b/c/" + Integer.toString(i));
assertEquals(i, ne.getNumberOfElements());
queue.removeNodeEntry(ne);
}
assertEquals(0, queue.getNumberOfNodes());
assertEquals(0, queue.getNumberOfElements());
assertNull(queue.getNodeEntry("/a/b/c/0"));
assertNull(queue.getFirstNodeEntry());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LongTransactionEvictionsTest.java 0000644 0001750 0001750 00000012264 11435676533 032723 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.Cache;
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.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.testng.AssertJUnit;
import org.testng.annotations.Test;
import static org.testng.AssertJUnit.*;
@Test(groups = {"functional"}, testName = "eviction.LongTransactionEvictionsTest")
public class LongTransactionEvictionsTest
{
public void testFIFOAlgoWithLongTx() throws Exception
{
// Create the cache
CacheFactory factory = new DefaultCacheFactory();
final Cache cache = factory.createCache(false);
// Configure the Eviction
EvictionConfig evictionConfig = new EvictionConfig();
cache.getConfiguration().setEvictionConfig(evictionConfig);
// Set the LRUAlgorithm as eviction algorithm
int maxNodes = 1;
long timeout = 4000;
FIFOAlgorithmConfig fifo = new FIFOAlgorithmConfig(maxNodes);
fifo.setMinTimeToLive(timeout);
EvictionRegionConfig erConfig = new EvictionRegionConfig(Fqn.ROOT, fifo);
evictionConfig.setDefaultEvictionRegionConfig(erConfig);
// Set the wakeup interval
long wakeupInterval = 1000;
evictionConfig.setWakeupInterval(wakeupInterval);
cache.getConfiguration().setInvocationBatchingEnabled(true);
// Start the cache
cache.start();
cache.startBatch();
cache.put(Fqn.fromElements("a"), "a", "value");
// Add a pause before committing
long pause = wakeupInterval + 1000;
Thread.sleep(pause);
cache.endBatch(true);
AssertJUnit.assertEquals(1, ((CacheSPI)cache).getNumberOfNodes());
cache.startBatch();
cache.put(Fqn.fromElements("b"), "b", "value");
// Add a pause before committing
pause = wakeupInterval + 1000;
assertEquals(1, ((CacheSPI)cache).getNumberOfNodes());
Thread.sleep(pause);
cache.endBatch(true);
assertEquals(2, ((CacheSPI)cache).getNumberOfNodes());
Thread.sleep(timeout + pause);
// We expect to have 1 entry into the cache there
assertEquals(1, ((CacheSPI)cache).getNumberOfNodes());
}
public void testLRUAlgoWithLongTx() throws Exception
{
// Create the cache
CacheFactory factory = new DefaultCacheFactory();
final Cache cache = factory.createCache(false);
// Configure the Eviction
EvictionConfig evictionConfig = new EvictionConfig();
cache.getConfiguration().setEvictionConfig(evictionConfig);
// Set the LRUAlgorithm as eviction algorithm
int maxNodes = 5;
long timeout = 4000;
LRUAlgorithmConfig lru = new LRUAlgorithmConfig(1000, timeout, maxNodes);
EvictionRegionConfig erConfig = new EvictionRegionConfig(Fqn.ROOT, lru);
evictionConfig.setDefaultEvictionRegionConfig(erConfig);
// Set the wakeup interval
long wakeupInterval = 1000;
evictionConfig.setWakeupInterval(wakeupInterval);
cache.getConfiguration().setInvocationBatchingEnabled(true);
// Start the cache
cache.start();
cache.startBatch();
Fqn fqn = Fqn.fromElements("key");
cache.put(fqn, "key", "value");
// Add a pause before committing
long pause = wakeupInterval + 1000;
Thread.sleep(pause);
cache.endBatch(true);
Thread.sleep(timeout + pause);
// We expect to have an empty cache there
assertEquals(0, ((CacheSPI)cache).getNumberOfNodes());
}
public void testExpAlgoWithLongTx() throws Exception
{
// Create the cache
CacheFactory factory = new DefaultCacheFactory();
final Cache cache = factory.createCache(false);
// Configure the Eviction
EvictionConfig evictionConfig = new EvictionConfig();
cache.getConfiguration().setEvictionConfig(evictionConfig);
// Set the ExpirationAlgorithm as eviction algorithm
int maxNodes = 5;
ExpirationAlgorithmConfig ea = new ExpirationAlgorithmConfig();
ea.setMaxNodes(maxNodes);
EvictionRegionConfig erConfig = new EvictionRegionConfig(Fqn.ROOT, ea);
evictionConfig.setDefaultEvictionRegionConfig(erConfig);
// Set the wakeup interval
long wakeupInterval = 1000;
evictionConfig.setWakeupInterval(wakeupInterval);
cache.getConfiguration().setInvocationBatchingEnabled(true);
// Start the cache
cache.start();
cache.startBatch();
long timeout = 4000;
Fqn fqn = Fqn.fromElements("key");
Long future = new Long(System.currentTimeMillis() + timeout);
cache.put(fqn, ExpirationAlgorithmConfig.EXPIRATION_KEY, future);
// Add a pause before committing
long pause = wakeupInterval + 1000;
Thread.sleep(pause);
cache.endBatch(true);
Thread.sleep(timeout + pause);
// We expect to have an empty cache there
assertEquals(0, ((CacheSPI)cache).getNumberOfNodes());
}
} jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ElementSizeQueueTest.java 0000644 0001750 0001750 00000013140 11120421353 031130 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.List;
import java.util.Set;
import org.testng.annotations.AfterMethod;
/**
* @author Daniel Huang
* @version $Revision: 7289 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.ElementSizeQueueTest")
public class ElementSizeQueueTest
{
private ElementSizeQueue queue;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
queue = new ElementSizeQueue();
}
@AfterMethod(alwaysRun = true)
public void tearDown() {
queue = null;
}
public void testQueue() throws Exception
{
for (int i = 0; i < 500; i++)
{
queue.addNodeEntry(new NodeEntry("/a/b/c/" + Integer.toString(i)));
}
queue.resortEvictionQueue();
assertEquals(500, queue.getNumberOfNodes());
assertTrue(queue.containsNodeEntry(new NodeEntry("/a/b/c/250")));
NodeEntry ne275 = queue.getNodeEntry("/a/b/c/275");
assertEquals("/a/b/c/275", ne275.getFqn().toString());
// now make sure the ordering is correct.
int k = 0;
for (NodeEntry ne : queue)
{
assertEquals("/a/b/c/" + Integer.toString(k), ne.getFqn().toString());
if (k % 2 == 0)
{
ne.setNumberOfElements(k);
}
k++;
}
queue.resortEvictionQueue();
k = 0;
for (NodeEntry ne : queue)
{
// the first 250 elements should have (250 - 1 - n) * 2 elements. The rest should have 0 elements.
int expectedElements = 0;
if (k < 250)
{
expectedElements = (250 - 1 - k) * 2;
}
assertEquals("k is " + k, expectedElements, ne.getNumberOfElements());
k++;
}
}
public void testPrune() throws Exception
{
for (int i = 0; i < 5000; i++)
{
queue.addNodeEntry(new NodeEntry("/a/b/c/" + Integer.toString(i)));
}
int i = 0;
for (NodeEntry ne : queue)
{
if (i % 2 == 0)
{
queue.removeNodeEntry(ne);
}
i++;
}
assertEquals(2500, queue.getNumberOfNodes());
Set removalQueue = queue.getRemovalQueue();
List evictionList = queue.getEvictionList();
assertEquals(2500, removalQueue.size());
for (NodeEntry ne : removalQueue)
{
int currentIndex = Integer.parseInt((String) ne.getFqn().get(3));
assertEquals(0, currentIndex % 2);
assertFalse(queue.containsNodeEntry(ne));
assertNull(queue.getNodeEntry(ne.getFqn()));
assertTrue(evictionList.contains(ne));
}
assertEquals(5000, evictionList.size());
queue.prune();
assertEquals(0, removalQueue.size());
assertEquals(2500, evictionList.size());
}
public void testGetFirstNodeEntry() throws Exception
{
for (int i = 0; i < 500; i++)
{
NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
queue.addNodeEntry(ne);
if (i % 2 == 0)
{
ne.setNumberOfElements(2);
}
}
queue.resortEvictionQueue();
NodeEntry ne;
int count = 0;
while ((ne = queue.getFirstNodeEntry()) != null)
{
if (count < 250)
{
assertEquals(2, ne.getNumberOfElements());
}
else
{
assertEquals(0, ne.getNumberOfNodeVisits());
}
queue.removeNodeEntry(ne);
count++;
}
assertEquals(0, queue.getNumberOfNodes());
}
public void testNumElements() throws Exception
{
ElementSizeQueue queue = new ElementSizeQueue();
NodeEntry ne = new NodeEntry("/a/b/c");
ne.setNumberOfElements(50);
queue.addNodeEntry(ne);
queue.resortEvictionQueue();
assertEquals(50, queue.getNumberOfElements());
assertEquals(1, queue.getNumberOfNodes());
queue.removeNodeEntry(ne);
assertEquals(0, queue.getNumberOfElements());
for (int i = 0; i < 10; i++)
{
ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
ne.setNumberOfElements(i);
queue.addNodeEntry(ne);
}
queue.resortEvictionQueue();
assertEquals(45, queue.getNumberOfElements());
assertEquals(10, queue.getNumberOfNodes());
ne = queue.getNodeEntry("/a/b/c/0");
assertNotNull(ne);
assertEquals(0, ne.getNumberOfElements());
ne.setNumberOfElements(500);
assertEquals(545, queue.getNumberOfElements());
ne = queue.getNodeEntry("/a/b/c/0");
assertEquals(500, ne.getNumberOfElements());
queue.resortEvictionQueue();
ne = queue.getNodeEntry("/a/b/c/1");
assertNotNull(ne);
assertEquals(1, ne.getNumberOfElements());
queue.resortEvictionQueue();
ne.setNumberOfElements(2);
queue.resortEvictionQueue();
assertEquals(546, queue.getNumberOfElements());
queue.removeNodeEntry(ne);
assertEquals(544, queue.getNumberOfElements());
assertEquals(9, queue.getNumberOfNodes());
queue.removeNodeEntry(queue.getNodeEntry("/a/b/c/0"));
for (int i = 2; i < 10; i++)
{
ne = queue.getNodeEntry("/a/b/c/" + Integer.toString(i));
assertEquals(i, ne.getNumberOfElements());
queue.removeNodeEntry(ne);
}
assertEquals(0, queue.getNumberOfNodes());
assertEquals(0, queue.getNumberOfElements());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/NullEvictionPolicyTest.java 0000644 0001750 0001750 00000006760 11131613416 031511 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.internals.EvictionWatcher;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.util.TestingUtil;
@Test(groups = {"functional"}, sequential = true, testName = "eviction.NullEvictionPolicyTest")
public class NullEvictionPolicyTest extends EvictionTestsBase
{
CacheSPI cache;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
cache = null;
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
/**
* Builds a cache was null eviction by default and in "/test" region,
* LRU in "/lru" region. Does a mix of puts/reads/removes, wakes for
* eviction thread to kick in, checks that nothing was evicted from the
* null policy regions but was from lru region.
*/
public void testEviction() throws InterruptedException
{
Configuration config = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
EvictionConfig evConfig = new EvictionConfig(new EvictionRegionConfig(Fqn.ROOT, new NullEvictionAlgorithmConfig(), 200000), 200);
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/test"), new NullEvictionAlgorithmConfig()));
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/lru"), new LRUAlgorithmConfig(1000, 10000)));
config.setEvictionConfig(evConfig);
config.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
config.setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache = (CacheSPI) new UnitTestCacheFactory().createCache(config, getClass());
String dfltRootStr = "/a/";
String testRootStr = "/test/";
String lruRootStr = "/lru/";
List toBeEvicted = new ArrayList();
for (int i = 0; i < 20; i++) toBeEvicted.add(Fqn.fromString(lruRootStr + i));
EvictionWatcher watcher = new EvictionWatcher(cache, toBeEvicted);
for (int i = 0; i < 20; i++)
{
Fqn dflt = Fqn.fromString(dfltRootStr + i);
Fqn test = Fqn.fromString(testRootStr + i);
Fqn lru = Fqn.fromString(lruRootStr + i);
cache.put(dflt, "key", "value");
cache.put(test, "key", "value");
cache.put(lru, "key", "value");
}
assert watcher.waitForEviction(30, TimeUnit.SECONDS);
for (int i = 0; i < 20; i++)
{
Fqn dflt = Fqn.fromString(dfltRootStr + i);
Fqn test = Fqn.fromString(testRootStr + i);
Fqn lru = Fqn.fromString(lruRootStr + i);
assertEquals("value", cache.get(dflt, "key"));
assertEquals("value", cache.get(test, "key"));
assertNull(cache.get(lru, "key"));
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LFUQueueTest.java 0000644 0001750 0001750 00000015230 11111047320 027332 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.List;
import java.util.Set;
import org.testng.annotations.AfterMethod;
/**
* Unit tests for LFUQueue.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.LFUQueueTest")
public class LFUQueueTest
{
private LFUQueue queue;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
queue = new LFUQueue();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
queue = null;
}
public void testQueue() throws Exception
{
NodeEntry ne;
for (int i = 0; i < 500; i++)
{
ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
queue.addNodeEntry(ne);
}
queue.resortEvictionQueue();
assertEquals(500, queue.getNumberOfNodes());
assertTrue(queue.containsNodeEntry(new NodeEntry("/a/b/c/250")));
NodeEntry ne275 = queue.getNodeEntry("/a/b/c/275");
assertEquals("/a/b/c/275", ne275.getFqn().toString());
int k = 0;
for (NodeEntry entry : queue)
{
assertEquals("/a/b/c/" + Integer.toString(k), entry.getFqn().toString());
if (k % 2 == 0)
{
entry.setNumberOfNodeVisits(entry.getNumberOfNodeVisits() + 1);
}
k++;
}
queue.resortEvictionQueue();
assertEquals("/a/b/c/1", queue.getFirstNodeEntry().getFqn().toString());
// now check the sort order.
k = 0;
for (NodeEntry entry : queue)
{
if (k < 250)
{
assertEquals(0, entry.getNumberOfNodeVisits());
}
else
{
assertEquals(1, entry.getNumberOfNodeVisits());
}
k++;
}
k = 0;
while ((ne = queue.getFirstNodeEntry()) != null)
{
if (k == 250)
{
break;
}
queue.removeNodeEntry(ne);
k++;
}
assertEquals(250, queue.getNumberOfNodes());
assertFalse(queue.containsNodeEntry(new NodeEntry("/a/b/c/275")));
assertNull(queue.getNodeEntry("/a/b/c/275"));
for (int i = 0; i < 500; i++)
{
if (i % 2 == 0)
{
ne = queue.getNodeEntry("/a/b/c/" + Integer.toString(i));
assertEquals(1, ne.getNumberOfNodeVisits());
if (i > 250)
{
ne.setNumberOfNodeVisits(ne.getNumberOfNodeVisits() + 1);
}
}
}
queue.resortEvictionQueue();
assertEquals(250, queue.getNumberOfNodes());
k = 0;
for (NodeEntry entry : queue)
{
if (k <= 125)
{
assertEquals(1, entry.getNumberOfNodeVisits());
}
else
{
assertEquals(2, entry.getNumberOfNodeVisits());
}
k++;
}
}
public void testPrune() throws Exception
{
for (int i = 0; i < 500; i++)
{
queue.addNodeEntry(new NodeEntry("/a/b/c/" + Integer.toString(i)));
}
int i = 0;
for (NodeEntry ne : queue)
{
if (i % 2 == 0)
{
queue.removeNodeEntry(ne);
}
i++;
}
assertEquals(250, queue.getNumberOfNodes());
Set removalQueue = queue.getRemovalQueue();
List evictionList = queue.getEvictionList();
assertEquals(250, removalQueue.size());
for (NodeEntry ne : removalQueue)
{
int currentIndex = Integer.parseInt((String) ne.getFqn().get(3));
assertEquals(0, currentIndex % 2);
assertFalse(queue.containsNodeEntry(ne));
assertNull(queue.getNodeEntry(ne.getFqn()));
assertTrue(evictionList.contains(ne));
}
assertEquals(500, evictionList.size());
queue.prune();
assertEquals(0, removalQueue.size());
assertEquals(250, evictionList.size());
}
public void testGetFirstNodeEntry() throws Exception
{
for (int i = 0; i < 500; i++)
{
NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
queue.addNodeEntry(ne);
if (i % 2 == 0)
{
ne.setNumberOfNodeVisits(2);
}
}
queue.resortEvictionQueue();
NodeEntry ne;
int count = 0;
while ((ne = queue.getFirstNodeEntry()) != null)
{
if (count < 250)
{
assertEquals(0, ne.getNumberOfNodeVisits());
}
else
{
assertEquals(2, ne.getNumberOfNodeVisits());
}
queue.removeNodeEntry(ne);
count++;
}
assertEquals(0, queue.getNumberOfNodes());
}
public void testNumElements() throws Exception
{
LFUQueue queue = new LFUQueue();
NodeEntry ne = new NodeEntry("/a/b/c");
ne.setNumberOfElements(50);
queue.addNodeEntry(ne);
assertEquals(50, queue.getNumberOfElements());
assertEquals(1, queue.getNumberOfNodes());
queue.removeNodeEntry(ne);
assertEquals(0, queue.getNumberOfElements());
for (int i = 0; i < 10; i++)
{
ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
ne.setNumberOfElements(i);
queue.addNodeEntry(ne);
}
assertEquals(45, queue.getNumberOfElements());
assertEquals(10, queue.getNumberOfNodes());
ne = queue.getNodeEntry("/a/b/c/0");
assertNotNull(ne);
assertEquals(0, ne.getNumberOfElements());
ne.setNumberOfElements(500);
assertEquals(545, queue.getNumberOfElements());
ne = queue.getNodeEntry("/a/b/c/0");
assertEquals(500, ne.getNumberOfElements());
queue.resortEvictionQueue();
ne = queue.getNodeEntry("/a/b/c/1");
assertNotNull(ne);
assertEquals(1, ne.getNumberOfElements());
queue.resortEvictionQueue();
ne.setNumberOfElements(2);
queue.resortEvictionQueue();
assertEquals(546, queue.getNumberOfElements());
queue.removeNodeEntry(ne);
assertEquals(544, queue.getNumberOfElements());
assertEquals(9, queue.getNumberOfNodes());
queue.removeNodeEntry(queue.getNodeEntry("/a/b/c/0"));
for (int i = 2; i < 10; i++)
{
ne = queue.getNodeEntry("/a/b/c/" + Integer.toString(i));
assertEquals(i, ne.getNumberOfElements());
queue.removeNodeEntry(ne);
}
assertEquals(0, queue.getNumberOfNodes());
assertEquals(0, queue.getNumberOfElements());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/DisabledEvictionThreadTest.java 0000644 0001750 0001750 00000003550 11131613416 032250 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.Cache;
import org.jboss.cache.RegionManager;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.factories.ComponentRegistry;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.util.TestingUtil;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "eviction.DisabledEvictionThreadTest")
public class DisabledEvictionThreadTest
{
public void testDisabledEvictionTimer()
{
Cache c = null;
try
{
Configuration cfg = UnitTestConfigurationFactory.createConfiguration(CacheMode.LOCAL, true);
cfg.getEvictionConfig().setWakeupInterval(0);
c = new UnitTestCacheFactory().createCache(cfg, getClass());
ComponentRegistry cr = TestingUtil.extractComponentRegistry(c);
RegionManager rm = cr.getComponent(RegionManager.class);
EvictionTimerTask ett = rm.getEvictionTimerTask();
assert ett.scheduledExecutor == null;
}
finally
{
TestingUtil.killCaches(c);
}
}
public void testControl()
{
Cache c = null;
try
{
Configuration cfg = UnitTestConfigurationFactory.createConfiguration(CacheMode.LOCAL, true);
cfg.getEvictionConfig().setWakeupInterval(10);
c = new UnitTestCacheFactory().createCache(cfg, getClass());
ComponentRegistry cr = TestingUtil.extractComponentRegistry(c);
RegionManager rm = cr.getComponent(RegionManager.class);
EvictionTimerTask ett = rm.getEvictionTimerTask();
assert ett.scheduledExecutor != null;
}
finally
{
TestingUtil.killCaches(c);
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/NullEvictionConfigTest.java 0000644 0001750 0001750 00000002507 11111047320 031443 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.parsing.element.EvictionElementParser;
import org.testng.annotations.Test;
import org.w3c.dom.Element;
/**
* Unit tests for NullEvictionPolicyConfig.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = "unit", sequential = false, testName = "eviction.NullEvictionConfigTest")
public class NullEvictionConfigTest
{
/**
* Creates a bunch of region elements with LRU configs and confirms
* that NullEvictionPolicyConfig doesn't barf.
*
* @throws Exception
*/
public void testXMLParsing() throws Exception
{
String xml =
"\n" +
"";
testConfigBlock(xml);
xml = "\n";
testConfigBlock(xml);
}
private void testConfigBlock(String xml) throws Exception
{
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
NullEvictionAlgorithmConfig config = new NullEvictionAlgorithmConfig();
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ExpirationPolicyTest.java 0000755 0001750 0001750 00000010232 11364010163 031206 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.concurrent.TimeUnit;
/**
* Unit tests for {@link org.jboss.cache.eviction.ExpirationAlgorithm}.
*
* @author Elias Ross
* @version $Revision: 8393 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.ExpirationPolicyTest")
public class ExpirationPolicyTest extends EvictionTestsBase
{
private static final Log log = LogFactory.getLog(ExpirationPolicyTest.class);
private CacheSPI cache;
private EvictionController ec;
Fqn fqn1 = Fqn.fromString("/node/1");
Fqn fqn2 = Fqn.fromString("/node/2");
Fqn fqn3 = Fqn.fromString("/node/3");
Fqn fqn4 = Fqn.fromString("/node/4");
Long future;
Long past;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
Configuration conf = new Configuration();
ExpirationAlgorithmConfig eAC = new ExpirationAlgorithmConfig();
EvictionRegionConfig eRC = new EvictionRegionConfig(Fqn.ROOT, eAC);
EvictionConfig econf = new EvictionConfig(eRC);
econf.setWakeupInterval(0);
conf.setEvictionConfig(econf);
cache = (CacheSPI) new UnitTestCacheFactory().createCache(conf, false, getClass());
cache.start();
ec = new EvictionController(cache);
future = System.currentTimeMillis() + 1500;
past = System.currentTimeMillis() - 1500;
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
public void testEviction() throws Exception
{
cache.put(fqn1, ExpirationAlgorithmConfig.EXPIRATION_KEY, future);
cache.put(fqn2, ExpirationAlgorithmConfig.EXPIRATION_KEY, past);
cache.put(fqn3, ExpirationAlgorithmConfig.EXPIRATION_KEY, future);
cache.put(fqn4, "foo", "bar");
ec.startEviction();
assertNotNull(cache.getNode(fqn1));
assertNull(cache.getNode(fqn2));
assertNotNull(cache.getNode(fqn3));
assertNotNull(cache.getNode(fqn4));
Thread.sleep(2000);
ec.startEviction();
log.info("should remove 1 and 3 now");
assertNull(cache.getNode(fqn1));
assertNull(cache.getNode(fqn3));
}
public void testAddRemoveEviction() throws Exception
{
cache.put(fqn4, "foo", "bar");
cache.removeNode(fqn4);
cache.put(fqn1, ExpirationAlgorithmConfig.EXPIRATION_KEY, future);
cache.put(fqn2, ExpirationAlgorithmConfig.EXPIRATION_KEY, past);
cache.put(fqn3, ExpirationAlgorithmConfig.EXPIRATION_KEY, future);
ec.startEviction();
assertNotNull(cache.getNode(fqn1));
assertNull(cache.getNode(fqn2));
assertNotNull(cache.getNode(fqn3));
assertNull(cache.getNode(fqn4));
Thread.sleep(2000);
ec.startEviction();
log.info("should remove 1 and 3 now");
assertNull(cache.getNode(fqn1));
assertNull(cache.getNode(fqn3));
}
public void testUpdate() throws Exception
{
try
{
log.info("update 1 from future to past");
cache.put(fqn1, ExpirationAlgorithmConfig.EXPIRATION_KEY, future);
new EvictionController(cache).startEviction();
assertNotNull(cache.getNode(fqn1));
cache.put(fqn1, ExpirationAlgorithmConfig.EXPIRATION_KEY, past);
new EvictionController(cache).startEviction();
assertNull(cache.getNode(fqn1));
}
finally
{
cache.removeNode(Fqn.ROOT);
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ElementSizePolicyTest.java 0000644 0001750 0001750 00000013641 11131613416 031316 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.*;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
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.List;
/**
* @author Daniel Huang
* @version $Revison: $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.ElementSizePolicyTest")
public class ElementSizePolicyTest extends EvictionTestsBase
{
CacheSPI cache;
long wakeupIntervalMillis = 0;
final String ROOT_STR = "/test";
Throwable t1_ex, t2_ex;
final long DURATION = 10000;
boolean isTrue;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
initCaches();
wakeupIntervalMillis = cache.getConfiguration().getEvictionConfig().getWakeupInterval();
t1_ex = t2_ex = null;
isTrue = true;
}
void initCaches() throws Exception
{
Configuration conf = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
EvictionConfig evConfig = new EvictionConfig(new EvictionRegionConfig(Fqn.ROOT, new ElementSizeAlgorithmConfig(5000, 100), 200000), -1);
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/org/jboss/data"), new ElementSizeAlgorithmConfig(10, 20)));
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/org/jboss/test/data"), new ElementSizeAlgorithmConfig(-1, 5)));
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/test/"), new ElementSizeAlgorithmConfig(5000, 1)));
conf.setEvictionConfig(evConfig);
cache = (CacheSPI) new UnitTestCacheFactory().createCache(conf, false, getClass());
cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache.getConfiguration().setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache.start();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
public void testEviction() throws Exception
{
String rootStr = "/org/jboss/test/data/";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
try
{
cache.put(fqn, str, str);
if (i % 2 == 0)
{
for (int k = 0; k < i; k++)
{
cache.put(fqn, k, Integer.toString(k));
}
}
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
EvictionController evController = new EvictionController(cache);
evController.startEviction();
TestingUtil.sleepThread(200); // small grace period
for (int i = 0; i < 10; i++)
{
String f = "/org/jboss/test/data/" + i;
Node node = cache.getNode(f);
if (i % 2 == 0)
{
if (i < 6)
{
int numElements = ((NodeSPI) node).getDataDirect().size();
assertEquals(i + 1, numElements);
}
else
{
assertNull(node);
}
}
else
{
assertEquals(1, ((NodeSPI) node).getDataDirect().size());
}
}
}
public void testEviction2() throws Exception
{
List fqnsThatShouldBeEvicted = new ArrayList();
for (int i = 10; i < 20; i++) fqnsThatShouldBeEvicted.add(Fqn.fromString("/org/jboss/data/" + i));
EvictionController evictionController = new EvictionController(cache);
String rootStr = "/org/jboss/data/";
for (int i = 0; i < 20; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);//"/org/jboss/data/i";
cache.put(fqn, i, str);
for (int k = 0; k < i; k++)
{
cache.put(fqn, k, str);
}
}
evictionController.startEviction();
for (int i = 0; i < 20; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
Node node = cache.getNode(fqn);
if (i > 9)
{
assertNull("Testing at " + i, node);
}
else
{
assertEquals(1 + i, node.getData().size());
}
}
for (int i = 0; i < 17; i++)
{
cache.put("/org/jboss/data/3", 100 + i, "value");
}
Node node = cache.getNode("/org/jboss/data/3");
assertEquals(21, node.getData().size());
evictionController.startEviction();
TestingUtil.sleepThread(200); // small grace period
assertNull(cache.getNode("/org/jboss/data/3"));
}
class MyPutter extends Thread
{
public MyPutter(String name)
{
super(name);
}
public void run()
{
int i = 0;
final String myName = ROOT_STR + "/test1/node" + getName();
while (isTrue)
{
try
{
cache.put(myName + i++, "value", i);
}
catch (Throwable e)
{
e.printStackTrace();
if (t1_ex == null)
{
t1_ex = e;
}
}
}
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LFUPolicyTest.java 0000644 0001750 0001750 00000023330 11132110773 027513 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit tests for LFU Policy.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7439 $
*/
@Test(groups = {"functional"}, testName = "eviction.LFUPolicyTest")
public class LFUPolicyTest extends EvictionTestsBase
{
CacheSPI cache;
final String ROOT_STR = "/test";
volatile Throwable t1_ex, t2_ex;
volatile boolean isTrue;
int maxNodesDefault = 500, minNodesDefault = 10, maxNodesR1 = 200, minNodesR1 = 100, maxNodesR2 = -1, minNodesR2 = 5;
private EvictionController evController;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
initCaches();
t1_ex = t2_ex = null;
isTrue = true;
}
void initCaches() throws Exception
{
Configuration config = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
EvictionConfig evConfig = new EvictionConfig(new EvictionRegionConfig(Fqn.ROOT, new LFUAlgorithmConfig(maxNodesDefault, minNodesDefault), 200000), 0);
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/org/jboss/data"), new LFUAlgorithmConfig(maxNodesR1, minNodesR1)));
evConfig.addEvictionRegionConfig(new EvictionRegionConfig(Fqn.fromString("/org/jboss/test/data"), new LFUAlgorithmConfig(maxNodesR2, minNodesR2)));
config.setEvictionConfig(evConfig);
config.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
config.setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache = (CacheSPI) new UnitTestCacheFactory().createCache(config, true, getClass());
evController = new EvictionController(cache);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
/* THIS TEST NEEDS REWRITING
public void testEviction() throws Exception
{
int numNodes = (int) ((maxNodesR1 * 2.6) - 1);
String rootStr = "/org/jboss/data/";
List fqns = new ArrayList();
for (int i = 0; i < numNodes; i += 2) fqns.add(Fqn.fromString(rootStr + i));
EvictionWatcher ew = new EvictionWatcher(cache, fqns);
List toRevisit = new ArrayList();
for (int i = 0; i < numNodes; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
try
{
cache.put(fqn, str, str);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
// visit odd numbered nodes an extra time to make them get evicted last.
if (i % 2 != 0) toRevisit.add(fqn);
revisit(toRevisit);
}
assert ew.waitForEviction(30, TimeUnit.SECONDS);
for (int i = 0; i < numNodes; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
if (i % 2 == 0)
{
assertNull(cache.get(fqn, str));
}
else
{
assertNotNull(cache.get(fqn, str));
}
}
}
private void revisit(List fqns)
{
for (Fqn fqn : fqns) cache.getNode(fqn);
}*/
public void testNodeVisited() throws InterruptedException
{
String rootStr = "/org/jboss/test/data/";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
try
{
cache.put(fqn, str, str);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
evController.startEviction();
try
{
for (int i = 0; i < 5; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
assertNull("Fqn " + fqn + " should be null", cache.get(fqn, str));
}
for (int i = 5; i < 10; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
assertNotNull(cache.get(fqn, str));
}
// since min is 5 the cache won't deplete past 5 nodes left in the cache.
for (int i = 5; i < 10; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
assertNotNull(cache.get(fqn, str));
}
// now we add some more nodes and we selectively visit some older nodes but not all. they should not get
// evicted when the thread next runs.
for (int i = 5; i < 7; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
cache.get(fqn, str);
}
// add 2 more to push the limit to 5 so we cause the old unvisited nodes to get evicted.
for (int i = 10; i < 13; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
// now bring up their hit count for LFU purposes (cache hit count based eviction).
for (int k = 0; k < 10; k++)
{
cache.get(fqn, str);
}
}
evController.startEviction();
// now make sure we still only have 5 nodes and they are the ones we expect based on LFU
for (int i = 5; i < 7; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
assertNotNull(cache.get(fqn, str));
}
for (int i = 7; i < 10; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
assertNull(cache.get(fqn, str));
}
for (int i = 10; i < 13; i++)
{
String str = rootStr + Integer.toString(i);
Fqn fqn = Fqn.fromString(str);
assertNotNull(cache.get(fqn, str));
}
}
catch (Exception e)
{
e.printStackTrace();
fail("Failed to evict" + e);
}
}
public void testNodeRemoved() throws Exception
{
String rootStr = "/org/jboss/data/";
for (int i = 0; i < maxNodesR1; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
try
{
cache.put(fqn, str, str);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
evController.startEviction();
for (int i = 0; i < (maxNodesR1 - minNodesR1); i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
assertNull(cache.get(fqn, str));
}
for (int i = (maxNodesR1 - minNodesR1); i < maxNodesR1; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
assertNotNull(cache.get(fqn, str));
}
for (int i = (maxNodesR1 - minNodesR1); i < maxNodesR1; i++)
{
if (i % 2 == 0)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
cache.removeNode(fqn);
}
}
evController.startEviction();
for (int i = (maxNodesR1 - minNodesR1); i < maxNodesR1; i++)
{
if (i % 2 == 0)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
assertNull(cache.getNode(fqn));
}
}
}
class MyPutter extends Thread
{
public MyPutter(String name)
{
super(name);
}
public void run()
{
int i = 0;
final String myName = ROOT_STR + "/test1/node" + getName();
while (isTrue)
{
try
{
cache.put(myName + i++, "value", i);
sleep(1);
}
catch (Throwable e)
{
// e.printStackTrace();
System.out.println("Got exception:" + e);
if (t1_ex == null)
{
isTrue = false;
t1_ex = e;
}
}
}
}
}
//todo mmarkus create a test profile to use greater values for thread count below
public void testConcurrentPutAndEvict() throws Exception
{
cache.stop();
cache.destroy();
cache.getConfiguration().setIsolationLevel(IsolationLevel.REPEATABLE_READ);
cache.start();
cache.put(ROOT_STR + "/concurrentPutAndEvict", "value", 1);
for (int i = 0; i < 5; i++)
{
new MyPutter("LFUPolicyTestPutter" + i).start();
}
int counter = 0;
while (true)
{
counter++;
if (t1_ex != null)
{
isTrue = false;
fail("Exception generated in put() " + t1_ex);
}
TestingUtil.sleepThread(250);
if (counter > 5)
{// run for 5 seconds
isTrue = false;
break;
}
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LRUQueueTest.java 0000644 0001750 0001750 00000015773 11111047320 027362 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertNull;
import static org.testng.AssertJUnit.assertTrue;
import java.util.Iterator;
import org.jboss.cache.Fqn;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit tests for LRUQueue.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.LRUQueueTest")
public class LRUQueueTest
{
private LRUQueue queue;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
queue = new LRUQueue();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
queue = null;
}
public void testQueue() throws Exception
{
for (int i = 0; i < 500; i++)
{
NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
queue.addNodeEntry(ne);
}
assertEquals(500, queue.getNumberOfNodes());
for (int i = 0; i < 500; i++)
{
Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i));
if ((i < 100) || (i >= 300 && i < 400))
{
// visit the nodes from 0-99 and the nodes from 300 - 399
queue.reorderByLRU(fqn);
}
}
// visiting the nodes should have no affect ont he maxAgeQueue.
Iterator maxAgeIt = queue.iterateMaxAgeQueue();
int count = 0;
long lastTs = 0;
while (maxAgeIt.hasNext())
{
NodeEntry ne = (NodeEntry) maxAgeIt.next();
assertTrue(lastTs <= ne.getCreationTimeStamp());
lastTs = ne.getCreationTimeStamp();
count++;
}
assertEquals(500, count);
Iterator lruIt = queue.iterateLRUQueue();
count = 0;
while (lruIt.hasNext())
{
NodeEntry ne = (NodeEntry) lruIt.next();
int nodeIndex = Integer.parseInt((String) ne.getFqn().get(3));
// the last 200 in the list should be the visisted LRU ones.
if (count >= 300 && count < 400)
{
int expectedNodeIndex = count - 300;
assertEquals(expectedNodeIndex, nodeIndex);
}
else if (count >= 400 && count < 500)
{
int expectedNodeIndex = count - 100;
assertEquals(expectedNodeIndex, nodeIndex);
}
else if (count < 200)
{
int expectedNodeIndex = count + 100;
assertEquals(expectedNodeIndex, nodeIndex);
}
else if (count >= 200 && count < 300)
{
int expectedNodeIndex = count + 200;
assertEquals(expectedNodeIndex, nodeIndex);
}
count++;
}
assertEquals(500, count);
NodeEntry ne = queue.getFirstMaxAgeNodeEntry();
queue.removeNodeEntry(ne);
assertEquals(499, queue.getNumberOfNodes());
assertFalse(queue.containsNodeEntry(ne));
ne = queue.getFirstLRUNodeEntry();
queue.removeNodeEntry(ne);
assertEquals(498, queue.getNumberOfNodes());
assertFalse(queue.containsNodeEntry(ne));
}
public void testGetFirstLRUNodeEntry() throws Exception
{
for (int i = 0; i < 100; i++)
{
NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
queue.addNodeEntry(ne);
}
for (int i = 0; i < 100; i++)
{
// this should move all the even numbered NodeEntries to the bottom of the lruQueue.
// maxAgeQueue should be unaffected.
if (i % 2 == 0)
{
Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i));
queue.reorderByLRU(fqn);
}
}
assertEquals(100, queue.getNumberOfNodes());
NodeEntry ne;
int count = 0;
while ((ne = queue.getFirstLRUNodeEntry()) != null)
{
int nodeIndex = Integer.parseInt((String) ne.getFqn().get(3));
if (count < 50)
{
// the top 50 should be all odds in the lruQueue/
assertTrue(nodeIndex % 2 != 0);
}
else
{
// the bottom fifty should all be even #'s (and 0)
assertTrue(nodeIndex % 2 == 0);
}
queue.removeNodeEntry(ne);
count++;
}
assertEquals(0, queue.getNumberOfNodes());
}
public void testGetFirstMaxAgeNodeEntriy() throws Exception
{
for (int i = 0; i < 100; i++)
{
NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
queue.addNodeEntry(ne);
}
for (int i = 0; i < 100; i++)
{
// this should move all the even numbered NodeEntries to the bottom of the lruQueue.
// maxAgeQueue should be unaffected.
if (i % 2 == 0)
{
Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i));
queue.reorderByLRU(fqn);
}
}
assertEquals(100, queue.getNumberOfNodes());
NodeEntry ne;
int count = 0;
while ((ne = queue.getFirstMaxAgeNodeEntry()) != null)
{
int nodeIndex = Integer.parseInt((String) ne.getFqn().get(3));
assertEquals(count, nodeIndex);
queue.removeNodeEntry(ne);
count++;
}
assertEquals(0, queue.getNumberOfNodes());
}
public void testNumElements() throws Exception
{
LRUQueue queue = new LRUQueue();
NodeEntry ne = new NodeEntry("/a/b/c");
ne.setNumberOfElements(50);
queue.addNodeEntry(ne);
assertEquals(50, queue.getNumberOfElements());
assertEquals(1, queue.getNumberOfNodes());
queue.removeNodeEntry(ne);
assertEquals(0, queue.getNumberOfElements());
for(int i = 0; i < 10; i++)
{
ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
ne.setNumberOfElements(i);
queue.addNodeEntry(ne);
}
assertEquals(45, queue.getNumberOfElements());
assertEquals(10, queue.getNumberOfNodes());
ne = queue.getNodeEntry("/a/b/c/0");
assertNotNull(ne);
assertEquals(0, ne.getNumberOfElements());
ne.setNumberOfElements(500);
assertEquals(545, queue.getNumberOfElements());
ne = queue.getNodeEntry("/a/b/c/0");
assertEquals(500, ne.getNumberOfElements());
queue.removeNodeEntry(ne);
assertEquals(45, queue.getNumberOfElements());
assertEquals(9, queue.getNumberOfNodes());
for(int i = 1; i < 10; i++)
{
ne = queue.getNodeEntry("/a/b/c/" + Integer.toString(i));
assertEquals(i, ne.getNumberOfElements());
queue.removeNodeEntry(ne);
}
assertEquals(0, queue.getNumberOfNodes());
assertEquals(0, queue.getNumberOfElements());
assertNull(queue.getNodeEntry("/a/b/c/0"));
assertNull(queue.getFirstNodeEntry());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/EvictionConfigurationTest.java 0000644 0001750 0001750 00000026452 11120431615 032223 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.*;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.Test;
/**
* Unit test to test Eviction configuration types.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7314 $
*/
@Test(groups = "unit", sequential = false, testName = "eviction.EvictionConfigurationTest")
public class EvictionConfigurationTest
{
public void testPolicyPerRegion() throws Exception
{
CacheSPI cache = null;
RegionManager regionManager = null;
try
{
cache = setupCache("configs/policyPerRegion-eviction.xml");
regionManager = cache.getRegionManager();
assertEquals(5000, cache.getConfiguration().getEvictionConfig().getWakeupInterval());
Region region = regionManager.getRegion("/org/jboss/data", true);
EvictionRegionConfig evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/org/jboss/data"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LFUAlgorithmConfig);
assertEquals(5000, ((LFUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(1000, ((LFUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMinNodes());
region = regionManager.getRegion("/org/jboss/test/data", true);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/org/jboss/test/data"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof FIFOAlgorithmConfig);
assertEquals(5, ((FIFOAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
region = regionManager.getRegion("/test", true);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/test"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof MRUAlgorithmConfig);
assertEquals(10000, ((MRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
region = regionManager.getRegion("/maxAgeTest", true);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/maxAgeTest"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(10000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(8000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
assertEquals(10000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxAge());
// test the default region. use a region name that isn't defined explicitly in conf file.
region = regionManager.getRegion("/a/b/c", false);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.ROOT, region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(5000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(1000000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
assertEquals(-1, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxAge());
}
finally
{
TestingUtil.killCaches(cache);
}
}
public void testMixedPolicies() throws Exception
{
CacheSPI cache = null;
RegionManager regionManager = null;
try
{
cache = setupCache("configs/mixedPolicy-eviction.xml");
regionManager = cache.getRegionManager();
assertEquals(5000, cache.getConfiguration().getEvictionConfig().getWakeupInterval());
Region region = regionManager.getRegion("/org/jboss/data", true);
EvictionRegionConfig evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/org/jboss/data/"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof FIFOAlgorithmConfig);
assertEquals(5000, ((FIFOAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
region = regionManager.getRegion("/test", true);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/test/"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof MRUAlgorithmConfig);
assertEquals(10000, ((MRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
// test the default region. use a region name that isn't defined explicitly in conf file.
region = regionManager.getRegion("/a/b/c", false);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.ROOT, region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(5000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(1000000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
assertEquals(-1, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxAge());
region = regionManager.getRegion("/maxAgeTest", false);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/maxAgeTest/"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(10000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(8000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
assertEquals(10000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxAge());
}
finally
{
TestingUtil.killCaches(cache);
}
}
public void testLegacyPolicyConfiguration() throws Exception
{
CacheSPI cache = null;
RegionManager regionManager = null;
try
{
cache = setupCache("configs/local-lru-eviction.xml");
regionManager = cache.getRegionManager();
assertEquals(5000, cache.getConfiguration().getEvictionConfig().getWakeupInterval());
Region region = regionManager.getRegion("/org/jboss/data", false);
EvictionRegionConfig evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/org/jboss/data/"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(5000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(1000000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
region = regionManager.getRegion("/org/jboss/test/data", false);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/org/jboss/test/data/"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(5, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(4000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
region = regionManager.getRegion("/test", true);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/test/"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(10000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(4000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
region = regionManager.getRegion("/maxAgeTest", true);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.fromString("/maxAgeTest/"), region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(10000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(8000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
assertEquals(10000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxAge());
// test the default region. use a region name that isn't defined explicitly in conf file.
region = regionManager.getRegion("/a/b/c", false);
evictionRegionConfig = region.getEvictionRegionConfig();
assertEquals(Fqn.ROOT, region.getFqn());
assertTrue(evictionRegionConfig.getEvictionAlgorithmConfig() instanceof LRUAlgorithmConfig);
assertEquals(5000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxNodes());
assertEquals(1000000, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getTimeToLive());
assertEquals(-1, ((LRUAlgorithmConfig) evictionRegionConfig.getEvictionAlgorithmConfig()).getMaxAge());
}
finally
{
TestingUtil.killCaches(cache);
}
}
public void testTwoCacheInstanceConfiguration() throws Exception
{
this.setupCache("configs/local-lru-eviction.xml");
this.setupCache("configs/local-lru-eviction.xml");
}
public void testNoEviction() throws Exception
{
CacheSPI cache = null;
RegionManager regionManager = null;
try
{
cache = (CacheSPI) new UnitTestCacheFactory().createCache(getClass());
regionManager = cache.getRegionManager();
assertEquals(0, regionManager.getAllRegions(Region.Type.ANY).size());
}
finally
{
TestingUtil.killCaches(cache);
}
}
private CacheSPI setupCache(String configurationName)
{
UnitTestCacheFactory testCacheFactory = new UnitTestCacheFactory();
Configuration config = testCacheFactory.getConfigurationFromFile(configurationName);
config.setCacheMode(Configuration.CacheMode.LOCAL);
config.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
config.setIsolationLevel(IsolationLevel.SERIALIZABLE);
return (CacheSPI) testCacheFactory.createCache(config, getClass());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/MRUQueueTest.java 0000644 0001750 0001750 00000007173 11111047320 027356 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertNull;
import static org.testng.AssertJUnit.assertTrue;
import org.jboss.cache.Fqn;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit tests for MRUQueue.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.MRUQueueTest")
public class MRUQueueTest
{
private MRUQueue queue;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
queue = new MRUQueue();
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
queue.clear();
}
public void testQueue() throws Exception
{
for (int i = 0; i < 100; i++)
{
NodeEntry ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
ne.setModifiedTimeStamp(0);
queue.addNodeEntry(ne);
}
assertEquals(queue.nodeMap.size(), queue.list.size());
for (int i = 0; i < 100; i++)
{
if (i % 2 == 0)
{
Fqn fqn = Fqn.fromString("/a/b/c/" + Integer.toString(i));
NodeEntry ne = queue.getNodeEntry(fqn);
ne.setModifiedTimeStamp(System.currentTimeMillis());
queue.moveToTopOfStack(fqn);
}
}
assertEquals(queue.nodeMap.size(), queue.list.size());
NodeEntry ne;
int count = 0;
while ((ne = queue.getFirstNodeEntry()) != null)
{
if (count < 50)
{
assertTrue(ne.getModifiedTimeStamp() > 0);
assertEquals(100 - count, queue.getNumberOfNodes());
}
else
{
assertEquals(0, ne.getModifiedTimeStamp());
}
queue.removeNodeEntry(ne);
count++;
}
assertEquals(queue.nodeMap.size(), queue.list.size());
}
public void testNumElements() throws Exception
{
MRUQueue queue = new MRUQueue();
NodeEntry ne = new NodeEntry("/a/b/c");
ne.setNumberOfElements(50);
queue.addNodeEntry(ne);
assertEquals(50, queue.getNumberOfElements());
assertEquals(1, queue.getNumberOfNodes());
queue.removeNodeEntry(ne);
assertEquals(0, queue.getNumberOfElements());
for(int i = 0; i < 10; i++)
{
ne = new NodeEntry("/a/b/c/" + Integer.toString(i));
ne.setNumberOfElements(i);
queue.addNodeEntry(ne);
}
assertEquals(45, queue.getNumberOfElements());
assertEquals(10, queue.getNumberOfNodes());
ne = queue.getNodeEntry("/a/b/c/0");
assertNotNull(ne);
assertEquals(0, ne.getNumberOfElements());
ne.setNumberOfElements(500);
assertEquals(545, queue.getNumberOfElements());
ne = queue.getNodeEntry("/a/b/c/0");
assertEquals(500, ne.getNumberOfElements());
queue.removeNodeEntry(ne);
assertEquals(45, queue.getNumberOfElements());
assertEquals(9, queue.getNumberOfNodes());
for(int i = 1; i < 10; i++)
{
ne = queue.getNodeEntry("/a/b/c/" + Integer.toString(i));
assertEquals(i, ne.getNumberOfElements());
queue.removeNodeEntry(ne);
}
assertEquals(0, queue.getNumberOfNodes());
assertEquals(0, queue.getNumberOfElements());
assertNull(queue.getNodeEntry("/a/b/c/0"));
assertNull(queue.getFirstNodeEntry());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/FIFOConfigurationTest.java 0000644 0001750 0001750 00000004302 11111047320 031150 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.config.ConfigurationException;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.parsing.element.EvictionElementParser;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.Test;
import org.w3c.dom.Element;
/**
* Unit test for FIFOConfiguration.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = "unit", sequential = false, testName = "eviction.FIFOConfigurationTest")
public class FIFOConfigurationTest
{
public void testXMLParse() throws Exception
{
FIFOAlgorithmConfig config = new FIFOAlgorithmConfig();
String xml = "" +
"" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(1000, config.getMaxNodes());
}
public void testXMLParse2() throws Exception
{
FIFOAlgorithmConfig config = new FIFOAlgorithmConfig();
String xml = "" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assert config.getMaxNodes() == -1;
assert config.getMinTimeToLive() == -1;
}
public void testXMLParse3() throws Exception
{
FIFOAlgorithmConfig config = new FIFOAlgorithmConfig();
String xml = "" +
"" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
try
{
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
}
catch (ConfigurationException ce)
{
assertTrue("Configure Exception properly thrown", true);
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/RecursiveRootEvictionTest.java 0000644 0001750 0001750 00000006662 11155772024 032242 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.loader.testloaders.DummyInMemoryCacheLoader;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.TestingUtil;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.io.IOException;
@Test(groups = { "functional" }, testName = "eviction.RecursiveRootEvictionTest")
public class RecursiveRootEvictionTest
{
private CacheSPI cache;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
UnitTestCacheFactory factory = new UnitTestCacheFactory();
Configuration conf = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
conf.setEvictionConfig(new EvictionConfig(new EvictionRegionConfig(Fqn.ROOT, new LRUAlgorithmConfig(1000000, 5000)), 200));
conf.setCacheLoaderConfig(buildCacheLoaderConfig());
conf.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
cache = (CacheSPI) factory.createCache(conf, true, getClass());
}
private CacheLoaderConfig buildCacheLoaderConfig() throws IOException
{
CacheLoaderConfig cacheLoaderConfig = new CacheLoaderConfig();
CacheLoaderConfig.IndividualCacheLoaderConfig iclc = new CacheLoaderConfig.IndividualCacheLoaderConfig();
iclc.setClassName(DummyInMemoryCacheLoader.class.getName());
cacheLoaderConfig.addIndividualCacheLoaderConfig(iclc);
return cacheLoaderConfig;
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
}
public void testNonrecursiveRootEviction()
{
cache.put(Fqn.fromElements("a", "a"), "x", "x");
cache.put(Fqn.fromElements("a", "b"), "x", "x");
cache.put(Fqn.fromElements("a", "c"), "x", "x");
assert cache.getNumberOfNodes() == 4;
cache.evict(Fqn.fromElements("a", "a"), false);
assert cache.getNumberOfNodes() == 3;
cache.evict(Fqn.fromElements("a", "b"), false);
assert cache.getNumberOfNodes() == 2;
cache.evict(Fqn.fromElements("a", "c"), false);
assert cache.getNumberOfNodes() == 1;
cache.evict(Fqn.fromElements("a"), false);
assert cache.getNumberOfNodes() == 0;
}
public void testRecursiveNonRootEviction()
{
cache.put(Fqn.fromElements("a", "a"), "x", "x");
cache.put(Fqn.fromElements("a", "b"), "x", "x");
cache.put(Fqn.fromElements("a", "c"), "x", "x");
cache.evict(Fqn.fromElements("a"), true);
assert cache.getNumberOfNodes() == 0;
}
public void testRecursiveRootEviction()
{
cache.put(Fqn.fromElements("a", "a"), "x", "x");
cache.put(Fqn.fromElements("a", "b"), "x", "x");
cache.put(Fqn.fromElements("a", "c"), "x", "x");
cache.evict(Fqn.ROOT, true);
assert cache.getNumberOfNodes() == 0;
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ElementSizeConfigurationTest.java 0000644 0001750 0001750 00000004352 11111047320 032656 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.parsing.element.EvictionElementParser;
import static org.testng.AssertJUnit.assertEquals;
import org.testng.annotations.Test;
import org.w3c.dom.Element;
/**
* @author Daniel Huang
* @version $Revision: 7168 $
*/
@Test(groups = "unit", sequential = false, testName = "eviction.ElementSizeConfigurationTest")
public class ElementSizeConfigurationTest
{
public void testXMLParse1() throws Exception
{
ElementSizeAlgorithmConfig config = new ElementSizeAlgorithmConfig();
String xml = "" +
"" +
"" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(100, config.getMaxElementsPerNode());
assertEquals(1000, config.getMaxNodes());
}
public void testXMLParse2() throws Exception
{
ElementSizeAlgorithmConfig config = new ElementSizeAlgorithmConfig();
String xml = "" +
"" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assert config.getMaxElementsPerNode() == -1;
}
public void testXMLParse3() throws Exception
{
ElementSizeAlgorithmConfig config = new ElementSizeAlgorithmConfig();
String xml = "" +
"" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(100, config.getMaxElementsPerNode());
assertEquals(-1, config.getMaxNodes());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/RegionManagerTest.java 0000755 0001750 0001750 00000013116 11245232602 030430 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import org.jboss.cache.RegionRegistry;
import org.jboss.cache.config.EvictionRegionConfig;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.Test;
import java.util.List;
/**
* Region Manager unit tests.
*
* @author Ben Wang, Feb 11, 2004
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 8208 $
*/
@Test(groups = "functional", testName = "eviction.RegionManagerTest")
public class RegionManagerTest
{
private final Fqn DEFAULT_REGION = Fqn.ROOT;
Fqn A_B_C = Fqn.fromString("/a/b/c");
Fqn A_B = Fqn.fromString("/a/b");
Fqn A_BC = Fqn.fromString("/a/bc");
Fqn AOP = Fqn.fromString("/aop");
EvictionRegionConfig config = new EvictionRegionConfig(null, new NullEvictionAlgorithmConfig());
public void testCreateRegion()
{
RegionManager regionManager = new RegionManagerImpl();
RegionRegistry rr = new RegionRegistry();
((RegionManagerImpl) regionManager).injectDependencies(null, null, null, null, null, rr);
regionManager.setUsingEvictions(true);
regionManager.getRegion(DEFAULT_REGION, true).setEvictionRegionConfig(config);
regionManager.getRegion(A_B_C, true).setEvictionRegionConfig(config);
regionManager.getRegion(A_B, true).setEvictionRegionConfig(config);
regionManager.getRegion(AOP, true).setEvictionRegionConfig(config);
List regions = regionManager.getAllRegions(Region.Type.ANY);
System.out.println("RegionRegistry: " + rr);
assertEquals("Region size ", 4, regions.size());
}
public void testCreateRegion2()
{
RegionManager regionManager = new RegionManagerImpl();
((RegionManagerImpl) regionManager).injectDependencies(null, null, null, null, null, new RegionRegistry());
regionManager.setUsingEvictions(true);
regionManager.getRegion(A_B_C, true).setEvictionRegionConfig(config);
regionManager.getRegion(A_B, true).setEvictionRegionConfig(config);
regionManager.getRegion(DEFAULT_REGION, true).setEvictionRegionConfig(config);
List regions = regionManager.getAllRegions(Region.Type.ANY);
assertEquals("Region size ", 3, regions.size());
assertEquals("Region 0", DEFAULT_REGION, regions.get(0).getFqn());
assertEquals("Region 1 ", A_B, regions.get(1).getFqn());
assertEquals("Region 2 ", A_B_C, regions.get(2).getFqn());
Region region = regionManager.getRegion("/a/b/c/d", false);
assertNotNull("Region ", region);
assertEquals("Region ", A_B_C, region.getFqn());
region = regionManager.getRegion(A_B, false);
assertNotNull("Region ", region);
assertEquals("Region ", A_B, region.getFqn());
region = regionManager.getRegion("/a", false);
// Should be default.
assertNotNull("Region ", region);
assertEquals("Region ", DEFAULT_REGION, region.getFqn());
}
public void testNoDefaultRegion()
{
RegionManager regionManager = new RegionManagerImpl();
((RegionManagerImpl) regionManager).injectDependencies(null, null, null, null, null, new RegionRegistry());
regionManager.setUsingEvictions(true);
regionManager.getRegion(A_B_C, true).setEvictionRegionConfig(config);
regionManager.getRegion(A_B, true).setEvictionRegionConfig(config);
regionManager.getRegion(Fqn.fromString("/a"), Region.Type.EVICTION, false);
}
public void testGetRegion()
{
RegionManager regionManager = new RegionManagerImpl();
((RegionManagerImpl) regionManager).injectDependencies(null, null, null, null, null, new RegionRegistry());
regionManager.setUsingEvictions(true);
regionManager.getRegion(DEFAULT_REGION, true).setEvictionRegionConfig(config);
regionManager.getRegion(A_BC, true).setEvictionRegionConfig(config);
regionManager.getRegion(A_B, true).setEvictionRegionConfig(config);
Region region = regionManager.getRegion(A_BC, true);
assertNotSame("Region ", DEFAULT_REGION, region.getFqn());
}
public void testRegionOrdering() throws Exception
{
Fqn A_B_C_D_E = Fqn.fromString("/a/b/c/d/e/");
Fqn A_B_C_D = Fqn.fromString("/a/b/c/d/");
RegionManager rm = new RegionManagerImpl();
((RegionManagerImpl) rm).injectDependencies(null, null, null, null, null, new RegionRegistry());
rm.setUsingEvictions(true);
rm.getRegion(DEFAULT_REGION, true).setEvictionRegionConfig(config);
rm.getRegion(A_B_C_D_E, true).setEvictionRegionConfig(config);
rm.getRegion(A_B_C_D, true).setEvictionRegionConfig(config);
rm.getRegion(A_B_C, true).setEvictionRegionConfig(config);
Region region = rm.getRegion("/a/b/c/d/e/f", false);
Region region2 = rm.getRegion("/e/f/g", false);
assertEquals(A_B_C_D_E, region.getFqn());
assertEquals(DEFAULT_REGION, region2.getFqn());
List regions = rm.getAllRegions(Region.Type.ANY);
for (int i = 0; i < regions.size(); i++)
{
switch (i)
{
case 0:
assertEquals(DEFAULT_REGION, regions.get(i).getFqn());
break;
case 1:
assertEquals(A_B_C, regions.get(i).getFqn());
break;
case 2:
assertEquals(A_B_C_D, regions.get(i).getFqn());
break;
case 3:
assertEquals(A_B_C_D_E, regions.get(i).getFqn());
break;
default:
fail("This error condition should never be reached");
break;
}
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LFUConfigurationTest.java 0000644 0001750 0001750 00000004445 11111047320 031063 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.parsing.element.EvictionElementParser;
import static org.testng.AssertJUnit.assertEquals;
import org.testng.annotations.Test;
import org.w3c.dom.Element;
/**
* LFU Configuration test.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = "unit", sequential = false, testName = "eviction.LFUConfigurationTest")
public class LFUConfigurationTest
{
public void testXMLParsing() throws Exception
{
LFUAlgorithmConfig config = new LFUAlgorithmConfig();
String xml =
"" +
"" +
"" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(10, config.getMinNodes());
assertEquals(20, config.getMaxNodes());
}
public void testXMLParsing2() throws Exception
{
LFUAlgorithmConfig config = new LFUAlgorithmConfig();
String xml =
"" +
"" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(10, config.getMinNodes());
assertEquals(-1, config.getMaxNodes());
}
public void testXMLParsing3() throws Exception
{
LFUAlgorithmConfig config = new LFUAlgorithmConfig();
String xml =
"" +
"" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(-1, config.getMinNodes());
assertEquals(20, config.getMaxNodes());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LRUPolicyTest.java 0000755 0001750 0001750 00000026320 11132110773 027534 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.Node;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
import org.jboss.cache.util.internals.EvictionWatcher;
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.List;
import java.util.concurrent.TimeUnit;
import org.jboss.cache.UnitTestCacheFactory;
/**
* Unit tests for LRU Policy.
*
* @author Ben Wang, Feb 11, 2004
* @author Daniel Huang - dhuang@jboss.org
* @version $Revision: 7439 $
*/
@Test(groups = "functional", testName = "eviction.LRUPolicyTest")
public class LRUPolicyTest extends EvictionTestsBase
{
CacheSPI cache;
long wakeupIntervalMillis = 1000;
long dataRegionTTLMillis = 1000;
long testRegionTTLMillis = 1000;
private int baseRegionMaxNodes = 10;
private int baseRegionTTLMillis = 1000;
final String ROOT_STR = "/test";
volatile Throwable t1_ex, t2_ex;
volatile boolean isTrue;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
Configuration conf = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.LOCAL, true);
EvictionConfig evConfig = conf.getEvictionConfig();
evConfig.setWakeupInterval(wakeupIntervalMillis);
List regionConfigs = new ArrayList();
regionConfigs.add(new EvictionRegionConfig(Fqn.fromString("/org/jboss/test/data"), new LRUAlgorithmConfig(dataRegionTTLMillis, -1, 5)));
regionConfigs.add(new EvictionRegionConfig(Fqn.fromString("/test"), new LRUAlgorithmConfig(testRegionTTLMillis, 10000)));
regionConfigs.add(new EvictionRegionConfig(Fqn.fromString("/base"), new LRUAlgorithmConfig(baseRegionTTLMillis, -1, baseRegionMaxNodes)));
evConfig.setEvictionRegionConfigs(regionConfigs);
conf.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
conf.setIsolationLevel(IsolationLevel.SERIALIZABLE);
cache = (CacheSPI) new UnitTestCacheFactory().createCache(conf, getClass());
wakeupIntervalMillis = cache.getConfiguration().getEvictionConfig().getWakeupInterval();
if (wakeupIntervalMillis < 0)
{
fail("testEviction(): eviction thread wake up interval is illegal " + wakeupIntervalMillis);
}
t1_ex = t2_ex = null;
isTrue = true;
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
TestingUtil.killCaches(cache);
cache = null;
}
public void testInUseEviction() throws Exception
{
String rootStr = "/org/jboss/test/data/inuse/";
Fqn fqn;
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
}
cache.getRegionManager().getRegion(Fqn.fromString(rootStr + 5), false).markNodeCurrentlyInUse(Fqn.fromString(rootStr + 5), 0);
for (int i = 10; i < 15; i++)
{
String str = rootStr + i;
fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
}
new EvictionController(cache).startEviction();
for (int i = 0; i < 5; i++)
{
Fqn f = Fqn.fromString(rootStr + i);
assert null == cache.getNode(f) : f + " should be null";
}
assertNotNull(cache.getNode(Fqn.fromString(rootStr + 5)));
for (int i = 6; i < 11; i++)
{
Fqn f = Fqn.fromString(rootStr + i);
assert null == cache.getNode(f) : f + " should be null";
}
for (int i = 11; i < 15; i++)
{
Fqn f = Fqn.fromString(rootStr + i);
assert null != cache.getNode(f) : f + " should not be null";
}
}
public void testEviction()
{
String rootStr = "/org/jboss/test/data/";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
try
{
cache.put(fqn, str, str);
}
catch (Exception e)
{
fail("Failed to insert data" + e);
e.printStackTrace();
}
}
TestingUtil.sleepThread(wakeupIntervalMillis + 500);
String val = (String) cache.get(rootStr + "3", rootStr + "3");
assertNull("Node should be empty ", val);
}
public void testNodeVisited() throws InterruptedException
{
String rootStr = "/org/jboss/test/data/";
final Fqn fqn7 = Fqn.fromString(rootStr + "7");
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
// playing favourites here:
cache.getNode(fqn7);// just to keep it fresh
}
Thread retrieverThread = new Thread()
{
@Override
public void run()
{
try
{
while (true)
{
cache.getNode(fqn7);// just to keep it fresh
sleep(50);
}
}
catch (Exception ie)
{
}
}
};
retrieverThread.setDaemon(true);
retrieverThread.start();
assert waitForEviction(cache, 30, TimeUnit.SECONDS, Fqn.fromString(rootStr + 3));
String val = (String) cache.get(rootStr + "3", rootStr + "3");
assertNull("Node should be empty ", val);
Node n = cache.getNode(fqn7);
assert n != null;
val = (String) n.get(rootStr + "7");
assertNotNull("Node should not be empty ", val);
retrieverThread.interrupt();
retrieverThread.join();
new EvictionController(cache).startEviction(true);
assert waitForEviction(cache, 30, TimeUnit.SECONDS, Fqn.fromString(rootStr + 7));
val = (String) cache.get(rootStr + "7", rootStr + "7");
assertNull("Node should be empty ", val);
}
public void testNodeRemoved()
{
String rootStr = "/org/jboss/test/data/";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i + "/" + i;
Fqn fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
}
String str1 = rootStr + "7";
Fqn fqn1 = Fqn.fromString(str1);
String str2 = rootStr + "7/7";
Fqn fqn2 = Fqn.fromString(str2);
cache.get(fqn1, str1);// just to keep it fresh
cache.get(fqn2, str2);// just to keep it fresh
new EvictionController(cache).startEviction();
cache.get(fqn1, str1);// just to keep it fresh
cache.get(fqn2, str2);// just to keep it fresh
new EvictionController(cache).startEviction();
String val = (String) cache.get(rootStr + "7/7", rootStr + "7/7");
assertNotNull("Node should not be empty ", val);
cache.removeNode(fqn1);
TestingUtil.sleepThread(wakeupIntervalMillis + 500);
new EvictionController(cache).startEviction();
val = (String) cache.get(rootStr + "7/7", rootStr + "7/7");
assertNull("Node should be empty ", val);
}
public void testCompleteRemoval() throws Exception
{
String rootStr = "/test/";
// Add a parent, then a child. LRU will evict the parent,
// then the child, leaving behind an empty parent
Fqn parent = Fqn.fromString(rootStr + "parent");
cache.put(parent, "key", "value");
cache.put(Fqn.fromRelativeElements(parent, "child"), "key", "value");
// Give eviction time to run a few times, then confirm parent
// is completely gone
long period = (wakeupIntervalMillis + testRegionTTLMillis) * 2;
TestingUtil.sleepThread(period);
assertFalse("Parent not completely removed", cache.getRoot().hasChild(parent));
}
class MyPutter extends Thread
{
public MyPutter(String name)
{
super(name);
}
public void run()
{
int i = 0;
final String myName = ROOT_STR + "/test1/node" + getName();
while (isTrue)
{
try
{
cache.put(myName + i++, "value", i);
sleep(1);
}
catch (IllegalStateException ise)
{
// this will happen since some threads are bound to continue running while the test stops.
// do nothing.
}
catch (Throwable e)
{
System.out.println("Got exception: " + e);
if (t1_ex == null)
{
isTrue = false;
t1_ex = e;
}
}
}
}
}
public void testConcurrentPutAndEvict() throws Exception
{
cache.stop();
cache.destroy();
cache.getConfiguration().setIsolationLevel(IsolationLevel.REPEATABLE_READ);
cache.create();
cache.start();
cache.put(ROOT_STR + "/concurrentPutAndEvict", "value", 1);
for (int i = 0; i < 10; i++)
{
new MyPutter("LRUPolicyTestPutter" + i).start();
}
int counter = 0;
while (true)
{
counter++;
if (t1_ex != null)
{
isTrue = false;
fail("Exception generated in put() " + t1_ex);
}
TestingUtil.sleepThread(1000);
if (counter > 5)
{// run for 5 seconds
isTrue = false;
break;
}
}
}
public void testForEvictionInternalError()
{
String rootStr = "/test/testdata";
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
}
// wait for an eviction
TestingUtil.sleepThread(2 * (wakeupIntervalMillis + testRegionTTLMillis));
String val = (String) cache.get(rootStr + "3", rootStr + "3");
assertNull("Node should be empty ", val);
// reinsert the elements
for (int i = 0; i < 10; i++)
{
String str = rootStr + i;
Fqn fqn = Fqn.fromString(str);
cache.put(fqn, str, str);
}
// clear the root
cache.removeNode(Fqn.ROOT);
// wait for an eviction
TestingUtil.sleepThread(2 * wakeupIntervalMillis + 1000);
val = (String) cache.get(rootStr + "3", rootStr + "3");
assertNull("Node should be empty ", val);
}
public void testOvereviction() throws Exception
{
Node node = cache.getRoot().addChild(Fqn.fromString("/base/"));
node.setResident(true);
cache.getRoot().setResident(true);
EvictionWatcher ew = new EvictionWatcher(cache, Fqn.fromString("/base/1"));
for (int i = 1; i < baseRegionMaxNodes + 2; i++)
{
Fqn f = Fqn.fromString("/base/" + i);
cache.put(f, "key", "base" + i);
}
new EvictionController(cache).startEviction();
assert ew.waitForEviction(30, TimeUnit.SECONDS);
assertEquals(baseRegionMaxNodes, cache.getRoot().getChild(Fqn.fromString("/base")).getChildren().size());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/RegionTest.java 0000755 0001750 0001750 00000010075 11120421353 027131 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.RegionImpl;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import org.jboss.cache.RegionRegistry;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.concurrent.TimeUnit;
import org.testng.annotations.AfterMethod;
/**
* @author Ben Wang, Feb 11, 2004
* @author Daniel Huang (dhuang@jboss.org)
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.RegionTest")
public class RegionTest
{
RegionManager regionManager;
EvictionAlgorithm algorithm;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
algorithm = new LRUAlgorithm();
regionManager = new RegionManagerImpl();
((RegionManagerImpl) regionManager).injectDependencies(null, null, null, null, null, new RegionRegistry());
Region r = regionManager.getRegion("/a/b", true);//.setEvictionPolicy(new DummyEvictionConfiguration());
r.setEvictionRegionConfig(new EvictionRegionConfig(r.getFqn(), new LRUAlgorithmConfig()));
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws Exception
{
algorithm = null;
regionManager = null;
}
public void testAddedQueue() throws InterruptedException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
Region region = regionManager.getRegion("/a/b", true);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.ADD_NODE_EVENT);
assertEquals("queue size ", 3, getQueueSize((RegionImpl) region));
EvictionEvent node = takeLastEvent((RegionImpl) region);
Fqn fqn = node.getFqn();
assertEquals("DataNode retrieved should be FILO ", fqn, fqn1);
assertEquals("AddedNode queue size ", 2, getQueueSize((RegionImpl) region));
fqn = takeLastEvent((RegionImpl) region).getFqn();
fqn = takeLastEvent((RegionImpl) region).getFqn();
node = takeLastEvent((RegionImpl) region);
assertNull("DataNode should be null", node);
}
public void testEventQueue() throws InterruptedException
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
Region region = regionManager.getRegion("/a/b", true);
region.registerEvictionEvent(fqn1, EvictionEvent.Type.REMOVE_NODE_EVENT);
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, EvictionEvent.Type.VISIT_NODE_EVENT);
assertEquals("RemovedNode queue size ", 3, getQueueSize((RegionImpl) region));
EvictionEvent.Type event = takeLastEvent((RegionImpl) region).getEventType();
assertEquals("DataNode retrieved should be: ", EvictionEvent.Type.REMOVE_NODE_EVENT, event);
takeLastEvent((RegionImpl) region);
takeLastEvent((RegionImpl) region);
EvictionEvent node = takeLastEvent((RegionImpl) region);
assertNull("DataNode should be null", node);
}
public void testMassivePutOnQueue()
{
Fqn fqn2 = Fqn.fromString("/a/b/d");
Region region = regionManager.getRegion("/a/b", true);
// This should succeed, alhtough it will produce warning over the threshold.
for (int i = 0; i < EvictionConfig.EVENT_QUEUE_SIZE_DEFAULT - 1; i++)
{
region.registerEvictionEvent(fqn2, EvictionEvent.Type.ADD_NODE_EVENT);
}
}
EvictionEvent takeLastEvent(RegionImpl r) throws InterruptedException
{
return r.getEvictionEventQueue().poll(0, TimeUnit.MILLISECONDS);
}
int getQueueSize(RegionImpl r)
{
return r.getEvictionEventQueue().size();
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/legacy/ 0000755 0001750 0001750 00000000000 11675221317 025456 5 ustar moeller moeller ././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/legacy/BackwardCompatibilityTest.java jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/legacy/BackwardCompatibilityTest.jav0000644 0001750 0001750 00000022305 11135607632 033271 0 ustar moeller moeller package org.jboss.cache.eviction.legacy;
import org.jboss.cache.Cache;
import org.jboss.cache.Fqn;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionPolicyConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.config.UnsupportedEvictionImplException;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.parsing.XmlConfigurationParser;
import org.jboss.cache.config.parsing.XmlConfigurationParser2x;
import org.jboss.cache.eviction.BaseEvictionPolicy;
import org.jboss.cache.eviction.DefaultEvictionActionPolicy;
import org.jboss.cache.eviction.EvictionAlgorithm;
import org.jboss.cache.eviction.EvictionPolicyConfigBase;
import org.jboss.cache.eviction.FIFOAlgorithm;
import org.jboss.cache.eviction.FIFOAlgorithmConfig;
import org.jboss.cache.eviction.FIFOConfiguration;
import org.jboss.cache.eviction.FIFOPolicy;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.List;
@Test(groups = "functional", testName = "eviction.legacy.BackwardCompatibilityTest")
public class BackwardCompatibilityTest
{
private EvictionRegionConfig createEvictionRegionConfig(String regionName, int maxNodes, EvictionPolicyConfigBase cfg)
{
EvictionRegionConfig ercDefault = new EvictionRegionConfig();
ercDefault.setRegionName(regionName);
if (maxNodes >= 0) cfg.setMaxNodes(maxNodes);
ercDefault.setEvictionPolicyConfig(cfg);
return ercDefault;
}
public void testUsingEvictionPolicy()
{
Configuration c = new Configuration();
c.setEvictionConfig(new EvictionConfig());
EvictionConfig evConfig = c.getEvictionConfig();
evConfig.setDefaultEventQueueSize(20000);
evConfig.setDefaultEvictionPolicyClass(FIFOPolicy.class.getName());
List erConfigs = new ArrayList();
erConfigs.add(createEvictionRegionConfig("/_default_", 2, new FIFOConfiguration()));
evConfig.setEvictionRegionConfigs(erConfigs);
doTest(c);
}
public void testUsingEvictionPolicyXml() throws Exception
{
String xml = "\n" +
" \n" +
" 2\n" +
" \n" +
" org.jboss.cache.eviction.FIFOPolicy\n" +
"\n" +
" \n" +
" \n" +
" 2\n" +
" \n" +
" \n" +
" ";
doTest(xml, true);
}
public void testUsingCustomEvictionPolicy()
{
try
{
Configuration c = new Configuration();
c.setEvictionConfig(new EvictionConfig());
EvictionConfig evConfig = c.getEvictionConfig();
evConfig.setDefaultEventQueueSize(20000);
evConfig.setDefaultEvictionPolicyClass(MyPolicy.class.getName());
List erConfigs = new ArrayList();
erConfigs.add(createEvictionRegionConfig("/_default_", 2, new MyPolicyConfig()));
evConfig.setEvictionRegionConfigs(erConfigs);
doTest(c);
assert false : "Should throw exception";
}
catch (UnsupportedEvictionImplException ce)
{
// expected
}
}
public void testUsingCustomEvictionPolicyXml() throws Exception
{
String xml = "\n" +
" \n" +
" 2\n" +
" \n" +
" " + MyPolicy.class.getName() + "\n" +
"\n" +
" \n" +
" \n" +
" 2\n" +
" \n" +
" \n" +
" ";
try
{
doTest(xml, true);
assert false : "Should throw exception";
}
catch (UnsupportedEvictionImplException ce)
{
// expected
}
}
public void testUsingCustomEvictionPolicyNonDefault()
{
try
{
Configuration c = new Configuration();
c.setEvictionConfig(new EvictionConfig());
EvictionConfig evConfig = c.getEvictionConfig();
evConfig.setDefaultEventQueueSize(20000);
evConfig.setDefaultEvictionPolicyClass(FIFOPolicy.class.getName());
List erConfigs = new ArrayList();
erConfigs.add(createEvictionRegionConfig("/_default_", 2, new FIFOConfiguration()));
erConfigs.add(createEvictionRegionConfig("/a/b/c", 2, new MyPolicyConfig()));
evConfig.setEvictionRegionConfigs(erConfigs);
doTest(c);
assert false : "Should throw exception";
}
catch (UnsupportedEvictionImplException ce)
{
// expected
}
}
public void testUsingCustomEvictionPolicyNonDefaultXml() throws Exception
{
String xml = "\n" +
" \n" +
" 2\n" +
" \n" +
" " + FIFOPolicy.class.getName() + "\n" +
"\n" +
" \n" +
" \n" +
" 2\n" +
" \n" +
" " +
" 2\n" +
" \n" +
" \n" +
" ";
try
{
doTest(xml, true);
assert false : "Should throw exception";
}
catch (UnsupportedEvictionImplException ce)
{
// expected
}
}
public void testControl()
{
Configuration c = new Configuration();
c.setEvictionConfig(new EvictionConfig());
EvictionRegionConfig defaultRegion = c.getEvictionConfig().getDefaultEvictionRegionConfig();
defaultRegion.setEvictionAlgorithmConfig(new FIFOAlgorithmConfig(2));
doTest(c);
}
public void testControlXml() throws Exception
{
String xml = "" +
"" +
"" +
"" +
"";
doTest(xml, false);
}
private void doTest(String xml, boolean legacy) throws Exception
{
if (legacy)
{
EvictionConfig ec = XmlConfigurationParser2x.parseEvictionConfig(XmlConfigHelper.stringToElementInCoreNS(xml));
Configuration c = new Configuration();
c.setEvictionConfig(ec);
doTest(c);
}
else
{
doTest(new XmlConfigurationParser().parseElement(XmlConfigHelper.stringToElementInCoreNS(xml)));
}
}
private void doTest(Configuration c)
{
Cache cache = null;
try
{
c.getEvictionConfig().setWakeupInterval(0);
cache = new UnitTestCacheFactory().createCache(c, getClass());
EvictionRegionConfig erc = cache.getRegion(Fqn.ROOT, false).getEvictionRegionConfig();
assert erc.getEvictionAlgorithmConfig() instanceof FIFOAlgorithmConfig;
assert erc.getEvictionActionPolicyClassName().equals(DefaultEvictionActionPolicy.class.getName());
cache.put("/a/b/1", "a", "b");
cache.put("/a/b/2", "a", "b");
cache.put("/a/b/3", "a", "b");
new EvictionController(cache).startEviction();
assert cache.getNode("/a/b/1") == null;
assert cache.getNode("/a/b/2") != null;
assert cache.getNode("/a/b/3") != null;
}
finally
{
TestingUtil.killCaches(cache);
}
}
public static class MyPolicy extends BaseEvictionPolicy
{
public EvictionAlgorithm getEvictionAlgorithm()
{
return null;
}
public Class getEvictionConfigurationClass()
{
return null;
}
}
public class MyPolicyConfig extends EvictionPolicyConfigBase
{
protected void setEvictionPolicyClassName()
{
this.setEvictionPolicyClass(MyPolicy.class.getName());
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/minttl/ 0000755 0001750 0001750 00000000000 11675221322 025515 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/minttl/MinTTLTestBase.java 0000644 0001750 0001750 00000007510 11135370315 031123 0 ustar moeller moeller package org.jboss.cache.eviction.minttl;
import org.jboss.cache.Cache;
import org.jboss.cache.Fqn;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.eviction.EvictionAlgorithmConfigBase;
import org.jboss.cache.eviction.EvictionTestsBase;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* This test exercises the minimum time to live for any element in the cache
*
* @author Manik Surtani
* @since 2.1.0
*/
@Test(groups = {"functional"}, sequential = true)
public abstract class MinTTLTestBase extends EvictionTestsBase
{
// this should ideally be in an eviction test base class so all eviction policies can be tested
protected Cache cache;
protected Fqn region = Fqn.fromString("/test-region");
protected Fqn fqn = Fqn.fromRelativeElements(region, "a");
// allows the test methods to notify any support threads in subclasses that data is in the cache and the test is about to begin
protected volatile CountDownLatch cacheInitialisedLatch;
protected abstract EvictionAlgorithmConfigBase getEvictionAlgorithmConfig();
@BeforeMethod
public void setUp()
{
cacheInitialisedLatch = new CountDownLatch(1);
// the LRU policy cfg
EvictionAlgorithmConfigBase cfg = getEvictionAlgorithmConfig();
// the region configuration
EvictionRegionConfig regionCfg = new EvictionRegionConfig();
regionCfg.setRegionFqn(region);
regionCfg.setRegionName(region.toString());
regionCfg.setEvictionAlgorithmConfig(cfg);
// cache-wide
EvictionConfig ec = new EvictionConfig();
ec.setWakeupInterval(200);
ec.addEvictionRegionConfig(regionCfg);
cache = new UnitTestCacheFactory().createCache(false, getClass());
cache.getConfiguration().setEvictionConfig(ec);
}
@AfterMethod
public void tearDown()
{
TestingUtil.killCaches(cache);
cache = null;
}
@Test(invocationCount = 5, successPercentage = 80)
public void testNoMinimumTTL() throws InterruptedException
{
cache.start();
cache.put(fqn, "k", "v");
// in case any waiting threads in subclasses are waiting for the cache to be initialised
cacheInitialisedLatch.countDown();
assert cache.get(fqn, "k") != null : "Node should be in the cache";
assert waitForEviction(cache, 10, TimeUnit.SECONDS, fqn);
assert cache.get(fqn, "k") == null : "Node should have been evicted";
}
public void testWithMinimumTTL() throws InterruptedException
{
((EvictionAlgorithmConfigBase) cache.getConfiguration().getEvictionConfig().getEvictionRegionConfigs().get(0).getEvictionAlgorithmConfig()).setMinTimeToLive(500);
cache.start();
cache.put(fqn, "k", "v");
// in case any waiting threads in subclasses are waiting for the cache to be initialised
cacheInitialisedLatch.countDown();
assert cache.get(fqn, "k") != null : "Node should be in the cache";
new EvictionController(cache).startEviction();
assert cache.get(fqn, "k") != null : "Node should still be in cache due to a minTTL of 3 secs";
// the last cache.get() would have updated the last modified tstamp so we need to wait at least 3 secs (+1 sec maybe for the eviction thread)
// to make sure this is evicted.
new EvictionController(cache).startEviction(true);
assert waitForEviction(cache, 5, TimeUnit.SECONDS, fqn);
assert cache.get(fqn, "k") == null : "Node should have been evicted";
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/minttl/LRUMinTTLTest.java 0000644 0001750 0001750 00000001144 11111047320 030677 0 ustar moeller moeller package org.jboss.cache.eviction.minttl;
import org.jboss.cache.eviction.EvictionAlgorithmConfigBase;
import org.jboss.cache.eviction.LRUAlgorithmConfig;
import org.testng.annotations.Test;
/**
* @author Manik Surtani
* @since 2.1.0
*/
@Test(groups = {"functional"}, testName = "eviction.minttl.LRUMinTTLTest")
public class LRUMinTTLTest extends MinTTLTestBase
{
@Override
protected EvictionAlgorithmConfigBase getEvictionAlgorithmConfig()
{
LRUAlgorithmConfig cfg = new LRUAlgorithmConfig();
cfg.setTimeToLive(200);
return cfg;
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/minttl/FIFOMinTTLTest.java 0000644 0001750 0001750 00000003566 11120421353 030774 0 ustar moeller moeller package org.jboss.cache.eviction.minttl;
import org.jboss.cache.Fqn;
import org.jboss.cache.eviction.EvictionAlgorithmConfigBase;
import org.jboss.cache.eviction.FIFOAlgorithmConfig;
import org.jboss.cache.util.TestingUtil;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
/**
* @author Manik Surtani
* @since 2.1.0
*/
@Test(groups = {"functional"}, testName = "eviction.minttl.FIFOMinTTLTest")
public class FIFOMinTTLTest extends MinTTLTestBase
{
private Fqn fqn2 = Fqn.fromRelativeElements(region, "b");
private Thread busyThread;
private volatile boolean busyThreadRunning = true;
@Override
protected EvictionAlgorithmConfigBase getEvictionAlgorithmConfig()
{
startBusyThread();
FIFOAlgorithmConfig cfg = new FIFOAlgorithmConfig();
cfg.setMaxNodes(1);
return cfg;
}
@AfterMethod
public void stopBusyThread()
{
busyThreadRunning = false;
try
{
busyThread.interrupt();
busyThread.join();
}
catch (InterruptedException e)
{
}
}
private void startBusyThread()
{
// start a thread to constantly put another node in the cache to make sure the maxNodes is exceeded.
// this should only happen AFTER the main node is entered to guarantee FIFO.
busyThreadRunning = true;
busyThread = new Thread("BusyThread")
{
public void run()
{
try
{
cacheInitialisedLatch.await();
}
catch (InterruptedException e)
{
// do nothing
}
while (busyThreadRunning)
{
cache.put(fqn2, "k", "v");
TestingUtil.sleepRandom(150);
}
}
};
busyThread.setDaemon(true);
busyThread.start();
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/minttl/MRUMinTTLTest.java 0000644 0001750 0001750 00000003174 11111047320 030705 0 ustar moeller moeller package org.jboss.cache.eviction.minttl;
import org.jboss.cache.CacheStatus;
import org.jboss.cache.Fqn;
import org.jboss.cache.eviction.EvictionAlgorithmConfigBase;
import org.jboss.cache.eviction.MRUAlgorithmConfig;
import org.jboss.cache.util.TestingUtil;
import org.testng.annotations.Test;
/**
* @author Manik Surtani
* @since 2.1.0
*/
@Test(groups = {"functional"}, testName = "eviction.minttl.MRUMinTTLTest")
public class MRUMinTTLTest extends MinTTLTestBase
{
private Fqn fqn2 = Fqn.fromRelativeElements(region, "b");
@Override
protected EvictionAlgorithmConfigBase getEvictionAlgorithmConfig()
{
MRUAlgorithmConfig cfg = new MRUAlgorithmConfig();
cfg.setMaxNodes(1);
startBusyThread();
return cfg;
}
private void startBusyThread()
{
// start a thread to constantly put another node in the cache to make sure the maxNodes is exceeded.
// this should only happen AFTER the main node is entered to guarantee FIFO.
Thread busyThread = new Thread()
{
public void run()
{
while (true)
{
if (cache != null)
{
if (cache.getCacheStatus() == CacheStatus.STARTED)
{
if (cache.getRoot().hasChild(fqn))
{
cache.put(fqn2, "k", "v");
break;
}
}
}
TestingUtil.sleepRandom(50);
}
}
};
busyThread.setDaemon(true);
busyThread.start();
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/minttl/LFUMinTTLTest.java 0000644 0001750 0001750 00000001042 11111047320 030660 0 ustar moeller moeller package org.jboss.cache.eviction.minttl;
import org.jboss.cache.eviction.EvictionAlgorithmConfigBase;
import org.jboss.cache.eviction.LFUAlgorithmConfig;
import org.testng.annotations.Test;
/**
* @author Manik Surtani
* @since 2.1.0
*/
@Test(groups = {"functional"}, testName = "eviction.minttl.LFUMinTTLTest")
public class LFUMinTTLTest extends MinTTLTestBase
{
@Override
protected EvictionAlgorithmConfigBase getEvictionAlgorithmConfig()
{
return new LFUAlgorithmConfig();
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LRUConfigurationTest.java 0000644 0001750 0001750 00000005553 11111047320 031100 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.config.ConfigurationException;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.parsing.element.EvictionElementParser;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.Test;
import org.w3c.dom.Element;
/**
* Unit tests for LRUConfiguration.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = "unit", sequential = false, testName = "eviction.LRUConfigurationTest")
public class LRUConfigurationTest
{
public void testXMLParsing() throws Exception
{
LRUAlgorithmConfig config = new LRUAlgorithmConfig();
String xml =
"\n" +
"\n" +
"\n" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(5000, config.getMaxNodes());
assertEquals(1000, config.getTimeToLive());
}
public void testXMLParsing2() throws Exception
{
LRUAlgorithmConfig config = new LRUAlgorithmConfig();
String xml = "\n" +
"\n" +
"\n" +
"\n" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(10000, config.getMaxNodes());
assertEquals(1000, config.getTimeToLive());
assertEquals(10, config.getMaxAge());
}
public void testXMLParsing3() throws Exception
{
String xml = "\n" +
"\n" +
"\n" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
boolean caught = false;
try
{
EvictionConfig ec = new EvictionElementParser().parseEvictionElement(element);
ec.getEvictionRegionConfigs().get(0).validate();
}
catch (ConfigurationException ce)
{
caught = true;
}
assertTrue("Configure exception should have been caught", caught);
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/FIFOAlgorithmTest.java 0000644 0001750 0001750 00000010155 11111047320 030272 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.Fqn;
import org.jboss.cache.RegionImpl;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import org.jboss.cache.RegionRegistry;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit tests for FIFOAlgorithm.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.FIFOAlgorithmTest")
public class FIFOAlgorithmTest extends EvictionTestsBase
{
RegionManager regionManager;
FIFOAlgorithm algo;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
regionManager = new RegionManagerImpl();
((RegionManagerImpl) regionManager).injectDependencies(null, null, null, null, null, new RegionRegistry());
FIFOAlgorithmConfig config = new FIFOAlgorithmConfig();
config.setMaxNodes(0);
algo = (FIFOAlgorithm) createAndAssignToRegion("/a/b", regionManager, config);
}
public void testMaxNodes1() throws Exception
{
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
FIFOAlgorithmConfig config = (FIFOAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(5);
for (int i = 0; i < 8; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
}
algo.process(region.getEvictionEventQueue());
FIFOQueue queue = (FIFOQueue) algo.evictionQueue;
assertEquals(5, algo.getEvictionQueue().getNumberOfNodes());
// now verify the order.
int index = 3;
for (NodeEntry ne : queue)
{
String fqn = ne.getFqn().toString();
assertTrue(fqn.endsWith("/" + Integer.toString(index)));
index++;
}
// now verify the same order still exists after visiting the nodes.
for (int i = 3; i < 8; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.VISIT_NODE_EVENT);
}
for (int i = 3; i < 5; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.VISIT_NODE_EVENT);
}
algo.process(region.getEvictionEventQueue());
assertEquals(5, algo.getEvictionQueue().getNumberOfNodes());
index = 3;
for (NodeEntry ne : queue)
{
String fqn = ne.getFqn().toString();
assertTrue(fqn.endsWith("/" + Integer.toString(index)));
index++;
}
}
public void testMaxNodes2() throws Exception
{
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
FIFOAlgorithmConfig config = (FIFOAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(500);
for (int i = 0; i < 500; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
}
algo.process(region.getEvictionEventQueue());
FIFOQueue queue = (FIFOQueue) algo.evictionQueue;
assertEquals(500, algo.getEvictionQueue().getNumberOfNodes());
int index = 0;
for (NodeEntry ne : queue)
{
assertTrue(ne.getFqn().toString().endsWith("/" + Integer.toString(index)));
index++;
}
for (int i = 500; i < 600; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
}
algo.process(region.getEvictionEventQueue());
index = 100;
for (NodeEntry ne : queue)
{
assertTrue(ne.getFqn().toString().endsWith("/" + Integer.toString(index)));
index++;
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/MRUConfigurationTest.java 0000644 0001750 0001750 00000005021 11111047320 031067 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.config.parsing.XmlConfigHelper;
import org.jboss.cache.config.parsing.element.EvictionElementParser;
import static org.testng.AssertJUnit.assertEquals;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import org.w3c.dom.Element;
/**
* Unit tests for MRUConfiguration.
*
* @author Daniel Huang (dhuang@jboss.org)
* @version $Revision: 7168 $
*/
@Test(groups = "unit", sequential = true, testName = "eviction.MRUConfigurationTest")
public class MRUConfigurationTest
{
MRUAlgorithmConfig config = null;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
config = new MRUAlgorithmConfig();
}
@AfterMethod(alwaysRun = true)
public void tearDown()
{
config = null;
}
public void testXMLParsing() throws Exception
{
String xml =
"\n" +
"\n" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(5000, config.getMaxNodes());
}
public void testXMLParsing2() throws Exception
{
String xml = "\n" +
"\n" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(10000, config.getMaxNodes());
}
public void testXMLParsing3() throws Exception
{
String xml = "\n" +
"";
Element element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assert config.getMaxNodes() == -1;
xml = "\n" +
"\n" +
"";
element = XmlConfigHelper.stringToElementInCoreNS(xml);
EvictionElementParser.parseEvictionPolicyConfig(element, config);
config.validate();
assertEquals(10000, config.getMaxNodes());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/ElementSizeAlgorithmTest.java 0000644 0001750 0001750 00000007251 11120421353 032000 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.jboss.cache.Fqn;
import org.jboss.cache.RegionImpl;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import static org.testng.AssertJUnit.assertEquals;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* @author Daniel Huang
* @version $Revision: 7289 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.ElementSizeAlgorithmTest")
public class ElementSizeAlgorithmTest extends EvictionTestsBase
{
RegionManager regionManager;
ElementSizeAlgorithm algo;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
regionManager = new RegionManagerImpl();
ElementSizeAlgorithmConfig config = new ElementSizeAlgorithmConfig();
config.setMaxElementsPerNode(0);
algo = (ElementSizeAlgorithm) createAndAssignToRegion("/a/b", regionManager, config);
}
public void testMaxElements() throws Exception
{
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
ElementSizeAlgorithmConfig config = (ElementSizeAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(10);
config.setMaxElementsPerNode(6);
for (int i = 0; i < 10; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
if (i % 2 == 0)
{
for (int k = 0; k < i; k++)
{
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_ELEMENT_EVENT);
}
}
}
algo.process(region.getEvictionEventQueue());
ElementSizeQueue queue = (ElementSizeQueue) algo.evictionQueue;
assertEquals(9, algo.getEvictionQueue().getNumberOfNodes());
assertEquals(12, algo.getEvictionQueue().getNumberOfElements());
// now verify the order.
int count = 6;
for (NodeEntry ne : queue)
{
if (count > 0)
{
assertEquals(count, ne.getNumberOfElements());
}
else
{
assertEquals(0, ne.getNumberOfElements());
}
count -= 2;
}
for (int i = 0; i < 7; i++)
{
region.registerEvictionEvent(Fqn.fromString("/a/b/9"), EvictionEvent.Type.ADD_ELEMENT_EVENT);
region.registerEvictionEvent(Fqn.fromString("/a/b/7"), EvictionEvent.Type.ADD_ELEMENT_EVENT);
}
algo.process(region.getEvictionEventQueue());
assertEquals(7, queue.getNumberOfNodes());
}
public void testMaxNodesAndMaxElements() throws Exception
{
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
ElementSizeAlgorithmConfig config = (ElementSizeAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(10);
config.setMaxElementsPerNode(100);
for (int i = 0; i < 20; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_NODE_EVENT);
for (int k = 0; k < i; k++)
{
region.registerEvictionEvent(fqn, EvictionEvent.Type.ADD_ELEMENT_EVENT);
}
}
algo.process(region.getEvictionEventQueue());
ElementSizeQueue queue = (ElementSizeQueue) algo.evictionQueue;
assertEquals(10, algo.getEvictionQueue().getNumberOfNodes());
assertEquals(45, algo.getEvictionQueue().getNumberOfElements());
// now verify the order.
int num = 9;
for (NodeEntry ne : queue)
{
assertEquals(num, ne.getNumberOfElements());
num--;
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/LFUAlgorithmTest.java 0000644 0001750 0001750 00000031607 11120421353 030204 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.eviction;
import org.jboss.cache.Fqn;
import org.jboss.cache.RegionImpl;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import org.jboss.cache.config.EvictionRegionConfig;
import org.testng.annotations.AfterMethod;
import static org.jboss.cache.eviction.EvictionEvent.Type.*;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Unit test for LFUAlgorithm.
*
* @author Daniel Huang - dhuang@jboss.org - 10/2005
* @version $Revision: 7289 $
*/
@Test(groups = {"functional"}, sequential = true, testName = "eviction.LFUAlgorithmTest")
public class LFUAlgorithmTest extends EvictionTestsBase
{
RegionManager regionManager;
LFUAlgorithm algo;
LFUAlgorithmConfig config;
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception
{
regionManager = new RegionManagerImpl();
config = new LFUAlgorithmConfig();
algo = (LFUAlgorithm) createAndAssignToRegion("/a/b", regionManager, config);
}
@AfterMethod(alwaysRun = true)
public void tearDown()
{
regionManager = null;
config = null;
algo = null;
}
public void testMaxNode1()
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(-1);
config.setMinNodes(20);
region.registerEvictionEvent(fqn1, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, ADD_NODE_EVENT);
try
{
algo.process(region.getEvictionEventQueue());
}
catch (EvictionException e)
{
fail("testMaxNode: process failed " + e);
e.printStackTrace();
}
assertEquals("Queue size should be ", 2, algo.getEvictionQueue().getNumberOfNodes());
}
public void testMaxNode2()
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
Fqn fqn3 = Fqn.fromString("/a/b/e");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
config.setMaxNodes(1);
config.setMinNodes(20);
region.registerEvictionEvent(fqn1, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, ADD_NODE_EVENT);
try
{
algo.process(region.getEvictionEventQueue());
}
catch (EvictionException e)
{
fail("testMaxNode: process failed " + e);
e.printStackTrace();
}
assertEquals("Queue size should be ", 1, algo.getEvictionQueue().getNumberOfNodes());
region.registerEvictionEvent(fqn2, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, ADD_NODE_EVENT);
try
{
algo.process(region.getEvictionEventQueue());
}
catch (EvictionException e)
{
fail("testMaxNode: process failed " + e);
e.printStackTrace();
}
assertEquals("Queue size should be ", 1, algo.getEvictionQueue().getNumberOfNodes());
}
public void testMinNode1() throws Exception
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/c/d");
Fqn fqn3 = Fqn.fromString("/a/b/c/d/e");
Fqn fqn4 = Fqn.fromString("/a/b/c/d/e/f");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
LFUAlgorithmConfig config = (LFUAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(-1);
config.setMinNodes(2);
region.registerEvictionEvent(fqn1, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn4, ADD_NODE_EVENT);
algo.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 2, algo.getEvictionQueue().getNumberOfNodes());
}
public void testMinNode2() throws Exception
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
LFUAlgorithmConfig config = (LFUAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(-1);
config.setMinNodes(-1);
region.registerEvictionEvent(fqn1, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, ADD_NODE_EVENT);
algo.process(region.getEvictionEventQueue());
assertEquals("Queue size should be ", 0, algo.getEvictionQueue().getNumberOfNodes());
}
public void testEvictionQueueSortOrder1() throws Exception
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/c/d");
Fqn fqn3 = Fqn.fromString("/a/b/c/d/e");
Fqn fqn4 = Fqn.fromString("/a/b/c/d/e/f");
Fqn fqn5 = Fqn.fromString("/a/b/c/d/e/f/g/h");
Fqn fqn6 = Fqn.fromString("/a/b/c/d/e/f/g/h/i");
Fqn fqn7 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j");
Fqn fqn8 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k");
Fqn fqn9 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k/l");
Fqn fqn10 = Fqn.fromString("/a/b/c/d/e/f/g/h/i/j/k/l/m");
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
LFUAlgorithmConfig config = (LFUAlgorithmConfig) region.getEvictionRegionConfig().getEvictionAlgorithmConfig();
config.setMaxNodes(-1);
config.setMinNodes(100);
region.registerEvictionEvent(fqn1, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn2, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn3, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn4, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn5, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn6, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn7, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn8, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn9, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn10, ADD_NODE_EVENT);
algo.process(region.getEvictionEventQueue());
LFUQueue queue = (LFUQueue) algo.evictionQueue;
assertEquals(10, algo.getEvictionQueue().getNumberOfNodes());
for (NodeEntry ne : queue)
{
assertEquals(1, ne.getNumberOfNodeVisits());
}
// fqn1 visited 4 additional times.
region.registerEvictionEvent(fqn1, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn1, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn1, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn1, VISIT_NODE_EVENT);
// fqn2 visited 3 additional times.
region.registerEvictionEvent(fqn2, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn2, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn2, VISIT_NODE_EVENT);
// fqn3 visited 1 additional time.
region.registerEvictionEvent(fqn3, VISIT_NODE_EVENT);
// fqn4 visited 2 additional times.
region.registerEvictionEvent(fqn4, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn4, VISIT_NODE_EVENT);
// fqn9 visited 1 additional time.
region.registerEvictionEvent(fqn9, VISIT_NODE_EVENT);
// fqn10 visited 2 additional times.
region.registerEvictionEvent(fqn10, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn10, VISIT_NODE_EVENT);
algo.process(region.getEvictionEventQueue());
int count = 0;
for (NodeEntry ne : queue)
{
count++;
if (count == 5 || count == 6)
{
assertEquals(2, ne.getNumberOfNodeVisits());
}
else if (count == 7 || count == 8)
{
assertEquals(3, ne.getNumberOfNodeVisits());
}
else if (count == 9)
{
assertEquals(4, ne.getNumberOfNodeVisits());
}
else if (count == 10)
{
assertEquals(5, ne.getNumberOfNodeVisits());
}
else
{
assertEquals(1, ne.getNumberOfNodeVisits());
}
}
assertEquals(10, algo.getEvictionQueue().getNumberOfNodes());
Fqn fqn11 = Fqn.fromString("/a");
Fqn fqn12 = Fqn.fromString("/a/b");
region.registerEvictionEvent(fqn11, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn12, ADD_NODE_EVENT);
algo.process(region.getEvictionEventQueue());
count = 0;
for (NodeEntry ne : queue)
{
count++;
if (count == 7 || count == 8)
{
assertEquals(2, ne.getNumberOfNodeVisits());
}
else if (count == 9 || count == 10)
{
assertEquals(3, ne.getNumberOfNodeVisits());
}
else if (count == 11)
{
assertEquals(4, ne.getNumberOfNodeVisits());
}
else if (count == 12)
{
assertEquals(5, ne.getNumberOfNodeVisits());
}
else
{
assertEquals(1, ne.getNumberOfNodeVisits());
}
}
assertEquals(12, algo.getEvictionQueue().getNumberOfNodes());
region.registerEvictionEvent(fqn1, REMOVE_NODE_EVENT);
region.registerEvictionEvent(fqn11, REMOVE_NODE_EVENT);
region.registerEvictionEvent(fqn12, REMOVE_NODE_EVENT);
region.registerEvictionEvent(fqn10, REMOVE_NODE_EVENT);
algo.process(region.getEvictionEventQueue());
count = 0;
for (NodeEntry ne : queue)
{
count++;
if (count == 5 || count == 6)
{
assertEquals(2, ne.getNumberOfNodeVisits());
}
else if (count == 7)
{
assertEquals(3, ne.getNumberOfNodeVisits());
}
else if (count == 8)
{
assertEquals(4, ne.getNumberOfNodeVisits());
}
else
{
assertEquals(1, ne.getNumberOfNodeVisits());
}
}
assertEquals(8, algo.getEvictionQueue().getNumberOfNodes());
//test add/visit/remove combination
region.registerEvictionEvent(fqn11, ADD_NODE_EVENT);
region.registerEvictionEvent(fqn11, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn11, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn11, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn11, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn11, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn4, VISIT_NODE_EVENT);
// purposefully revisit a node that has been removed. assert that it is readded.
region.registerEvictionEvent(fqn1, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn1, VISIT_NODE_EVENT);
region.registerEvictionEvent(fqn3, REMOVE_NODE_EVENT);
algo.process(region.getEvictionEventQueue());
count = 0;
for (NodeEntry ne : queue)
{
count++;
if (count == 5 || count == 6)
{
assertEquals(2, ne.getNumberOfNodeVisits());
}
else if (count == 7 || count == 8)
{
assertEquals(4, ne.getNumberOfNodeVisits());
}
else if (count == 9)
{
assertEquals(6, ne.getNumberOfNodeVisits());
}
else
{
assertEquals(1, ne.getNumberOfNodeVisits());
}
}
assertEquals(9, algo.getEvictionQueue().getNumberOfNodes());
}
public void testEvictionQueueSortOrder2() throws Exception
{
RegionImpl region = (RegionImpl) regionManager.getRegion("/a/b", true);
EvictionRegionConfig config = region.getEvictionRegionConfig();
((LFUAlgorithmConfig) config.getEvictionAlgorithmConfig()).setMaxNodes(-1);
((LFUAlgorithmConfig) config.getEvictionAlgorithmConfig()).setMinNodes(10000);
for (int i = 0; i < 10000; i++)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, ADD_NODE_EVENT);
}
algo.process(region.getEvictionEventQueue());
LFUQueue queue = (LFUQueue) algo.evictionQueue;
long lastModifiedTimestamp = 0;
for (NodeEntry ne : queue)
{
assertTrue(lastModifiedTimestamp <= ne.getModifiedTimeStamp());
lastModifiedTimestamp = ne.getModifiedTimeStamp();
}
for (int i = 0; i < 10000; i++)
{
if ((i % 2) == 0)
{
Fqn fqn = Fqn.fromString("/a/b/" + Integer.toString(i));
region.registerEvictionEvent(fqn, VISIT_NODE_EVENT);
}
}
algo.process(region.getEvictionEventQueue());
int count = 0;
lastModifiedTimestamp = 0;
for (NodeEntry ne : queue)
{
assertTrue(lastModifiedTimestamp <= ne.getModifiedTimeStamp());
lastModifiedTimestamp = ne.getModifiedTimeStamp();
if (count < 5000)
{
assertEquals(1, ne.getNumberOfNodeVisits());
}
else
{
assertEquals(2, ne.getNumberOfNodeVisits());
}
count++;
}
assertEquals(10000, algo.getEvictionQueue().getNumberOfNodes());
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/eviction/EvictionTestsBase.java 0000644 0001750 0001750 00000004343 11111047320 030440 0 ustar moeller moeller package org.jboss.cache.eviction;
import org.easymock.EasyMock;
import org.jboss.cache.Cache;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.Region;
import org.jboss.cache.RegionManager;
import org.jboss.cache.RegionManagerImpl;
import org.jboss.cache.RegionRegistry;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionAlgorithmConfig;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionWatcher;
import java.util.concurrent.TimeUnit;
public abstract class EvictionTestsBase
{
public EvictionAlgorithm createAndAssignToRegion(String fqnString, RegionManager regionManager, EvictionAlgorithmConfig config)
{
Fqn fqn = Fqn.fromString(fqnString);
Configuration c = new Configuration();
EvictionConfig evictionConfig = new EvictionConfig();
evictionConfig.setWakeupInterval(-1);
c.setEvictionConfig(evictionConfig);
EvictionRegionConfig erc = new EvictionRegionConfig(fqn, config);
c.getEvictionConfig().addEvictionRegionConfig(erc);
CacheSPI mockCache = EasyMock.createNiceMock(CacheSPI.class);
EasyMock.replay(mockCache);
((RegionManagerImpl) regionManager).injectDependencies(mockCache, c, null, null, null, new RegionRegistry());
Region r = regionManager.getRegion(fqn, Region.Type.EVICTION, true);
r.setEvictionRegionConfig(erc);
((RegionManagerImpl) regionManager).start();
return (EvictionAlgorithm) TestingUtil.extractField(r, "evictionAlgorithm");
}
/**
* Blocks until an eviction event is seen on the given cache for the given array of Fqns. Returns true if the eviction event
* is received, false if it times out.
*
* @param cache cache to monitor
* @param timeToWait timeout
* @param unit timeout unit
* @param fqnsToEvict fqns to watch for
* @return true if evicted, false otherwise
*/
public boolean waitForEviction(Cache cache, long timeToWait, TimeUnit unit, Fqn... fqnsToEvict) throws InterruptedException
{
return new EvictionWatcher(cache, fqnsToEvict).waitForEviction(timeToWait, unit);
}
} jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/ 0000755 0001750 0001750 00000000000 11675221326 025053 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/OptSyncInvalidationTest.java 0000644 0001750 0001750 00000016074 11120571606 032521 0 ustar moeller moeller package org.jboss.cache.invalidation;
import org.jboss.cache.*;
import org.jboss.cache.optimistic.DefaultDataVersion;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.config.Configuration;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import static org.testng.AssertJUnit.assertFalse;
import org.testng.annotations.Test;
import javax.transaction.TransactionManager;
import javax.transaction.Transaction;
import javax.transaction.RollbackException;
/**
* @author Mircea.Markus@jboss.com
*/ //
@Test( groups = "functional", testName = "invalidation.OptSyncInvalidationTest")
public class OptSyncInvalidationTest extends AbstractMultipleCachesSyncInvalidationTest
{
protected void createCaches() throws Throwable
{
Configuration c = new Configuration();
c.setStateRetrievalTimeout(3000);
c.setCacheMode(Configuration.CacheMode.INVALIDATION_SYNC);
c.setNodeLockingScheme(Configuration.NodeLockingScheme.OPTIMISTIC);
c.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
cache1 = (CacheSPI) new UnitTestCacheFactory().createCache(c, true, getClass());
cache2 = (CacheSPI) new UnitTestCacheFactory().createCache(c.clone(), true, getClass());
TestingUtil.blockUntilViewReceived(cache1, 2, 10000);
registerCaches(cache1, cache2);
}
public void testOptSyncUnableToEvict() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
cache2.put(fqn, "key", "value");
assertEquals("value", cache2.get(fqn, "key"));
Node n = cache1.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n, "Should have been invalidated");
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache1.peek(fqn, true, true), "Should have been invalidated");
// start a tx that cache1 will have to send out an evict ...
TransactionManager mgr1 = cache1.getTransactionManager();
TransactionManager mgr2 = cache2.getTransactionManager();
mgr1.begin();
cache1.put(fqn, "key2", "value2");
Transaction tx1 = mgr1.suspend();
mgr2.begin();
cache2.put(fqn, "key3", "value3");
Transaction tx2 = mgr2.suspend();
mgr1.resume(tx1);
// this oughtta fail
try
{
mgr1.commit();
assertTrue("Ought to have succeeded!", true);
}
catch (RollbackException roll)
{
assertTrue("Ought to have succeeded!", false);
}
mgr2.resume(tx2);
try
{
mgr2.commit();
assertTrue("Ought to have failed!", false);
}
catch (RollbackException roll)
{
assertTrue("Ought to have failed!", true);
}
}
public void testOptimistic() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
cache1.put(fqn, "key", "value");
// test that this has NOT replicated, but rather has been invalidated:
assertEquals("value", cache1.get(fqn, "key"));
Node n2 = cache2.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n2, "Should have been invalidated");
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache2.peek(fqn, true, true), "Should have been invalidated");
// now make sure cache2 is in sync with cache1:
cache2.put(fqn, "key", "value");
Node n1 = cache1.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n1, "Should have been invalidated");
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache1.peek(fqn, true, true), "Should have been invalidated");
assertEquals("value", cache2.get(fqn, "key"));
// now test the invalidation:
cache1.put(fqn, "key2", "value2");
assertEquals("value2", cache1.get(fqn, "key2"));
n2 = cache2.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n2, "Should have been invalidated");
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache2.peek(fqn, false, false), "Should have been invalidated");
// with tx's
TransactionManager txm = cache2.getTransactionManager();
txm.begin();
cache2.put(fqn, "key", "value");
assertEquals("value", cache2.get(fqn, "key"));
assertEquals("value2", cache1.get(fqn, "key2"));
txm.commit();
n1 = cache1.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n1, "Should have been invalidated");
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache1.peek(fqn, false, false), "Should have been invalidated");
assertEquals("value", cache2.get(fqn, "key"));
// now test the invalidation again
txm = cache1.getTransactionManager();
txm.begin();
cache1.put(fqn, "key2", "value2");
assertEquals("value", cache2.get(fqn, "key"));
assertEquals("value2", cache1.get(fqn, "key2"));
txm.commit();
assertEquals("value2", cache1.get(fqn, "key2"));
n2 = cache2.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n2, "Should have been invalidated");
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache2.peek(fqn, false, false), "Should have been invalidated");
// test a rollback
txm = cache2.getTransactionManager();
txm.begin();
cache2.put(fqn, "key", "value");
assertEquals("value2", cache1.get(fqn, "key2"));
assertEquals("value", cache2.get(fqn, "key"));
txm.rollback();
assertEquals("value2", cache1.get(fqn, "key2"));
n2 = cache2.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n2, "Should have been invalidated");
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache2.peek(fqn, false, false), "Should have been invalidated");
}
public void dataInconsistency() throws Exception
{
Fqn node = Fqn.fromString("/a");
TransactionManager tm1 = cache1.getConfiguration().getRuntimeConfig().getTransactionManager();
TransactionManager tm2 = cache2.getConfiguration().getRuntimeConfig().getTransactionManager();
tm1.begin();
cache1.put(node, "k", "v-older");
Transaction t1 = tm1.suspend();
tm2.begin();
cache2.put(node, "k", "v-newer");
tm2.commit();
tm1.resume(t1);
try
{
tm1.commit();
assert false : "Should not be allowed to commit with older data!!";
}
catch (Exception good)
{
}
// the NEWER version of the data should be available, not the OLDER one.
Object val = cache1.get(node, "k");
assert val == null : "Older data should not have committed";
val = cache2.get(node, "k");
assert val.equals("v-newer");
// test node versions
NodeSPI n = ((CacheSPI) cache1).peek(node, true, true);
assert ((DefaultDataVersion) n.getVersion()).getRawVersion() == 1 : "Version should be 1";
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/PessWithCacheLoaderInvalidationTest.java jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/PessWithCacheLoaderInvalidationT0000644 0001750 0001750 00000006767 11121730272 033314 0 ustar moeller moeller package org.jboss.cache.invalidation;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.AbstractMultipleCachesTest;
import org.jboss.cache.loader.testloaders.DummySharedInMemoryCacheLoader;
import org.jboss.cache.config.Configuration;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;
import org.testng.annotations.Test;
import org.testng.annotations.BeforeMethod;
import javax.transaction.TransactionManager;
/**
* @author Mircea.Markus@jboss.com
*/
@Test(groups = "functional", testName = "invalidation.PessWithCacheLoaderInvalidationTest")
public class PessWithCacheLoaderInvalidationTest extends AbstractMultipleCachesTest
{
private CacheSPI cache1;
private CacheSPI cache2;
protected void createCaches() throws Throwable
{
Configuration c = new Configuration();
c.setStateRetrievalTimeout(3000);
c.setCacheMode(Configuration.CacheMode.INVALIDATION_SYNC);
c.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
c.setCacheLoaderConfig(CacheLoaderInvalidationTest.getCacheLoaderConfig(getClass()));
cache1 = (CacheSPI) new UnitTestCacheFactory().createCache(c, true, getClass());
cache2 = (CacheSPI) new UnitTestCacheFactory().createCache(c.clone(), true, getClass());
registerCaches(cache1, cache2);
}
@BeforeMethod
public void clearCacheLoaderBetweenTests() throws Exception
{
DummySharedInMemoryCacheLoader sharedCl = (DummySharedInMemoryCacheLoader) cache1.getCacheLoaderManager().getCacheLoader();
sharedCl.remove(Fqn.ROOT);
}
public void testPessimisticNonTransactionalWithCacheLoader() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
cache1.put(fqn, "key", "value");
assertEquals("value", cache1.get(fqn, "key"));
assertEquals("value", cache2.get(fqn, "key"));
// now make sure cache2 is in sync with cache1:
cache2.put(fqn, "key", "value");
assertEquals("value", cache2.get(fqn, "key"));
assertEquals("value", cache1.get(fqn, "key"));
// now test the invalidation:
cache1.put(fqn, "key2", "value2");
assertEquals("value2", cache1.get(fqn, "key2"));
assertEquals("value2", cache2.get(fqn, "key2"));
assertEquals("value", cache1.get(fqn, "key"));
assertEquals("value", cache2.get(fqn, "key"));
}
public void testPessimisticTransactionalWithCacheLoader() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
TransactionManager mgr = cache1.getTransactionManager();
assertNull("Should be null", cache1.get(fqn, "key"));
assertNull("Should be null", cache2.get(fqn, "key"));
mgr.begin();
cache1.put(fqn, "key", "value");
assertEquals("value", cache1.get(fqn, "key"));
mgr.commit();
assertEquals("value", cache2.get(fqn, "key"));
assertEquals("value", cache1.get(fqn, "key"));
mgr.begin();
cache1.put(fqn, "key2", "value2");
assertEquals("value2", cache1.get(fqn, "key2"));
mgr.rollback();
assertEquals("value", cache2.get(fqn, "key"));
assertEquals("value", cache1.get(fqn, "key"));
assertNull("Should be null", cache1.get(fqn, "key2"));
assertNull("Should be null", cache2.get(fqn, "key2"));
}
}
././@LongLink 0000000 0000000 0000000 00000000164 00000000000 011566 L ustar root root jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/AbstractMultipleCachesSyncInvalidationTest.java jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/AbstractMultipleCachesSyncInvali0000644 0001750 0001750 00000016007 11120571606 033362 0 ustar moeller moeller package org.jboss.cache.invalidation;
import org.jboss.cache.AbstractMultipleCachesTest;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Node;
import org.jboss.cache.Fqn;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertNull;
import static org.testng.AssertJUnit.fail;
import javax.transaction.TransactionManager;
/**
* @author Mircea.Markus@jboss.com
*/
public abstract class AbstractMultipleCachesSyncInvalidationTest extends AbstractMultipleCachesTest
{
protected CacheSPI cache1;
protected CacheSPI cache2;
public void nodeRemovalTest() throws Exception
{
Node root1 = cache1.getRoot();
Node root2 = cache2.getRoot();
// this fqn is relative, but since it is from the root it may as well be absolute
Fqn fqn = Fqn.fromString("/test/fqn");
cache1.getInvocationContext().getOptionOverrides().setCacheModeLocal(true);
cache1.put(fqn, "key", "value");
assertEquals("value", cache1.get(fqn, "key"));
cache2.getInvocationContext().getOptionOverrides().setCacheModeLocal(true);
cache2.put(fqn, "key", "value");
assertEquals("value", cache2.get(fqn, "key"));
assertEquals(true, cache1.removeNode(fqn));
assertFalse(root1.hasChild(fqn));
Node remoteNode = root2.getChild(fqn);
CacheLoaderInvalidationTest.checkRemoteNodeIsRemoved(remoteNode);
assertEquals(false, cache1.removeNode(fqn));
Fqn child = Fqn.fromString("/test/fqn/child");
cache1.getInvocationContext().getOptionOverrides().setCacheModeLocal(true);
cache1.put(child, "key", "value");
assertEquals("value", cache1.get(child, "key"));
cache2.getInvocationContext().getOptionOverrides().setCacheModeLocal(true);
cache2.put(child, "key", "value");
assertEquals("value", cache2.get(child, "key"));
assertEquals(true, cache1.removeNode(fqn));
assertFalse(root1.hasChild(fqn));
remoteNode = root2.getChild(fqn);
CacheLoaderInvalidationTest.checkRemoteNodeIsRemoved(remoteNode);
assertEquals(false, cache1.removeNode(fqn));
}
public void nodeResurrectionTest() throws Exception
{
// this fqn is relative, but since it is from the root it may as well be absolute
Fqn fqn = Fqn.fromString("/test/fqn1");
cache1.put(fqn, "key", "value");
assertEquals("value", cache1.get(fqn, "key"));
assertEquals(null, cache2.get(fqn, "key"));
// Change the value in order to increment the version if Optimistic is used
cache1.put(fqn, "key", "newValue");
assertEquals("newValue", cache1.get(fqn, "key"));
assertEquals(null, cache2.get(fqn, "key"));
assertEquals(true, cache1.removeNode(fqn));
assertEquals(null, cache1.get(fqn, "key"));
assertEquals(null, cache2.get(fqn, "key"));
// Restore locally
cache1.put(fqn, "key", "value");
assertEquals("value", cache1.get(fqn, "key"));
assertEquals(null, cache2.get(fqn, "key"));
// Repeat, but now restore the node on the remote cache
fqn = Fqn.fromString("/test/fqn2");
cache1.put(fqn, "key", "value");
assertEquals("value", cache1.get(fqn, "key"));
assertEquals(null, cache2.get(fqn, "key"));
// Change the value in order to increment the version if Optimistic is used
cache1.put(fqn, "key", "newValue");
assertEquals("newValue", cache1.get(fqn, "key"));
assertEquals(null, cache2.get(fqn, "key"));
assertEquals(true, cache1.removeNode(fqn));
assertEquals(null, cache1.get(fqn, "key"));
assertEquals(null, cache2.get(fqn, "key"));
// Restore on remote cache
cache2.put(fqn, "key", "value");
assertEquals("value", cache2.get(fqn, "key"));
assertEquals(null, cache1.get(fqn, "key"));
}
/**
* Here we model a scenario where a parent node represents
* a structural node, and then child nodes represent different
* data elements.
*
* Such data structures are set up on both caches, and then the parent node
* is removed (globally) and re-added (locally) on one cache. This
* represents an attempt to clear the region -- removing a node and
* re-adding is one of the only ways to do this.
*
* On the second cache, the fact that the structural node is missing is
* detected, and an attempt is made to re-add it locally.
*
* @param optimistic should the cache be configured for optimistic locking
* @throws Exception
*/
private void nodeResurrectionTest2() throws Exception
{
Node root1 = cache1.getRoot();
Node root2 = cache2.getRoot();
// this fqn is relative, but since it is from the root it may as well be absolute
Fqn fqn = Fqn.fromString("/test/fqn");
cache1.getInvocationContext().getOptionOverrides().setCacheModeLocal(true);
root1.addChild(fqn);
assertEquals(true, root1.hasChild(fqn));
cache2.getInvocationContext().getOptionOverrides().setCacheModeLocal(true);
root1.addChild(fqn);
assertEquals(true, root1.hasChild(fqn));
Fqn child = Fqn.fromRelativeElements(fqn, "child");
cache1.putForExternalRead(child, "key", "value");
cache2.putForExternalRead(child, "key", "value");
assertEquals("value", cache1.get(child, "key"));
assertEquals("value", cache2.get(child, "key"));
assertEquals(true, cache1.removeNode(fqn));
assertFalse(root1.hasChild(fqn));
cache1.getInvocationContext().getOptionOverrides().setCacheModeLocal(true);
root1.addChild(fqn);
assertEquals(true, root1.hasChild(fqn));
Node remoteNode = root2.getChild(fqn);
CacheLoaderInvalidationTest.checkRemoteNodeIsRemoved(remoteNode);
cache2.getInvocationContext().getOptionOverrides().setCacheModeLocal(true);
root2.addChild(fqn);
assertEquals(true, root2.hasChild(fqn));
}
public void deleteNonExistentTest() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
assertNull("Should be null", cache1.getNode(fqn));
assertNull("Should be null", cache2.getNode(fqn));
cache1.putForExternalRead(fqn, "key", "value");
assertEquals("value", cache1.getNode(fqn).get("key"));
assertNull("Should be null", cache2.getNode(fqn));
// OK, here's the real test
TransactionManager tm = cache2.getTransactionManager();
tm.begin();
try
{
// Remove a node that doesn't exist in cache2
cache2.removeNode(fqn);
tm.commit();
}
catch (Exception e)
{
String msg = "Unable to remove non-existent node " + fqn;
fail(msg + " -- " + e);
}
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache1.getNode(fqn), "Should have been invalidated");
assertNull("Should be null", cache2.getNode(fqn));
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/PessAsyncInterceptorTest.java 0000644 0001750 0001750 00000005221 11120571606 032677 0 ustar moeller moeller package org.jboss.cache.invalidation;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.*;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.Test;
import javax.transaction.TransactionManager;
import javax.transaction.Transaction;
import javax.transaction.RollbackException;
import java.util.List;
import java.util.ArrayList;
/**
* @author Mircea.Markus@jboss.com
*/
@Test (groups = "functional", testName = "invalidation.PessAsyncInterceptorTest")
public class PessAsyncInterceptorTest extends AbstractMultipleCachesTest
{
private CacheSPI cache1;
private CacheSPI cache2;
protected void createCaches() throws Throwable
{
Configuration c = new Configuration();
c.setStateRetrievalTimeout(3000);
c.setCacheMode(Configuration.CacheMode.INVALIDATION_ASYNC);
c.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
cache1 = (CacheSPI) new UnitTestCacheFactory().createCache(c, true, getClass());
cache2 = (CacheSPI) new UnitTestCacheFactory().createCache(c.clone(), true, getClass());
TestingUtil.blockUntilViewReceived(cache1, 2, 10000);
registerCaches(cache1, cache2);
}
public void testPessTxAsyncUnableToEvict() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
cache1.put("/a/b", "key", "value");
assertEquals("value", cache1.get(fqn, "key"));
assertNull(cache2.getNode(fqn));
// start a tx that cacahe1 will have to send out an evict ...
TransactionManager mgr1 = cache1.getTransactionManager();
TransactionManager mgr2 = cache2.getTransactionManager();
mgr1.begin();
cache1.put(fqn, "key2", "value2");
Transaction tx1 = mgr1.suspend();
mgr2.begin();
cache2.put(fqn, "key3", "value3");
Transaction tx2 = mgr2.suspend();
mgr1.resume(tx1);
// this oughtta fail
try
{
mgr1.commit();
assertTrue("Ought to have succeeded!", true);
}
catch (RollbackException roll)
{
assertTrue("Ought to have succeeded!", false);
}
mgr2.resume(tx2);
try
{
mgr2.commit();
assertTrue("Ought to have succeeded!", true);
}
catch (RollbackException roll)
{
assertTrue("Ought to have succeeded!", false);
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/PessSyncInvalidationTest.java 0000644 0001750 0001750 00000017045 11120571606 032670 0 ustar moeller moeller package org.jboss.cache.invalidation;
import org.jboss.cache.*;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.optimistic.DefaultDataVersion;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.Test;
import javax.transaction.RollbackException;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
/**
* @author Mircea.Markus@jboss.com
*/
@Test(groups = "functional", testName = "invalidation.PessSyncInvalidationTest")
public class PessSyncInvalidationTest extends AbstractMultipleCachesSyncInvalidationTest
{
protected void createCaches() throws Throwable
{
Configuration c = new Configuration();
c.setStateRetrievalTimeout(3000);
c.setCacheMode(Configuration.CacheMode.INVALIDATION_SYNC);
c.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
cache1 = (CacheSPI) new UnitTestCacheFactory().createCache(c, true, getClass());
cache2 = (CacheSPI) new UnitTestCacheFactory().createCache(c.clone(), true, getClass());
TestingUtil.blockUntilViewReceived(cache1, 2, 10000);
registerCaches(cache1, cache2);
}
public void testPessimisticNonTransactional() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
cache1.put(fqn, "key", "value");
// test that this has NOT replicated, but rather has been invalidated:
assertEquals("value", cache1.get(fqn, "key"));
assertNull("Should NOT have replicated!", cache2.getNode(fqn));
// now make sure cache2 is in sync with cache1:
cache2.put(fqn, "key", "value");
// since the node already exists even PL will not remove it - but will invalidate it's data
Node n = cache1.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n, "Should have been invalidated");
assertEquals("value", cache2.get(fqn, "key"));
// now test the invalidation:
cache1.put(fqn, "key2", "value2");
assertEquals("value2", cache1.get(fqn, "key2"));
n = cache2.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n, "Should have been invalidated");
}
public void testUnnecessaryEvictions() throws Exception
{
Fqn fqn1 = Fqn.fromString("/a/b/c");
Fqn fqn2 = Fqn.fromString("/a/b/d");
cache1.put(fqn1, "hello", "world");
assertEquals("world", cache1.get(fqn1, "hello"));
assertNull(cache2.get(fqn1, "hello"));
cache2.put(fqn2, "hello", "world");
assertEquals("world", cache1.get(fqn1, "hello"));
assertNull(cache2.get(fqn1, "hello"));
assertEquals("world", cache2.get(fqn2, "hello"));
assertNull(cache1.get(fqn2, "hello"));
cache2.put(fqn1, "hello", "world");
assertEquals("world", cache2.get(fqn1, "hello"));
assertEquals("world", cache2.get(fqn2, "hello"));
assertNull(cache1.get(fqn1, "hello"));
assertNull(cache1.get(fqn2, "hello"));
}
public void testPessimisticTransactional() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
cache1.put(fqn, "key", "value");
// test that this has NOT replicated, but rather has been invalidated:
assertEquals("value", cache1.get(fqn, "key"));
assertNull("Should NOT have replicated!", cache2.getNode(fqn));
// now make sure cache2 is in sync with cache1:
// make sure this is in a tx
TransactionManager txm = cache2.getTransactionManager();
assertEquals("value", cache1.get(fqn, "key"));
txm.begin();
cache2.put(fqn, "key", "value");
assertEquals("value", cache2.get(fqn, "key"));
txm.commit();
// since the node already exists even PL will not remove it - but will invalidate it's data
Node n = cache1.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n, "Should have been invalidated");
assertEquals("value", cache2.get(fqn, "key"));
// now test the invalidation again
txm = cache1.getTransactionManager();
assertEquals("value", cache2.get(fqn, "key"));
txm.begin();
cache1.put(fqn, "key2", "value2");
assertEquals("value2", cache1.get(fqn, "key2"));
txm.commit();
assertEquals("value2", cache1.get(fqn, "key2"));
// since the node already exists even PL will not remove it - but will invalidate it's data
n = cache2.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n, "Should have been invalidated");
// test a rollback
txm = cache2.getTransactionManager();
assertEquals("value2", cache1.get(fqn, "key2"));
txm.begin();
cache2.put(fqn, "key", "value");
assertEquals("value", cache2.get(fqn, "key"));
txm.rollback();
assertEquals("value2", cache1.get(fqn, "key2"));
n = cache2.getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n, "Should have been invalidated");
}
public void testPessTxSyncUnableToEvict() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
cache1.put("/a/b", "key", "value");
assertEquals("value", cache1.get(fqn, "key"));
assertNull(cache2.getNode(fqn));
// start a tx that cacahe1 will have to send out an evict ...
TransactionManager mgr1 = cache1.getTransactionManager();
TransactionManager mgr2 = cache2.getTransactionManager();
mgr1.begin();
cache1.put(fqn, "key2", "value2");
Transaction tx1 = mgr1.suspend();
mgr2.begin();
cache2.put(fqn, "key3", "value3");
Transaction tx2 = mgr2.suspend();
mgr1.resume(tx1);
// this oughtta fail
try
{
mgr1.commit();
assertTrue("Ought to have failed!", false);
}
catch (RollbackException roll)
{
assertTrue("Ought to have failed!", true);
}
mgr2.resume(tx2);
try
{
mgr2.commit();
assertTrue("Ought to have succeeded!", true);
}
catch (RollbackException roll)
{
assertTrue("Ought to have succeeded!", false);
}
}
/**
* Test for JBCACHE-1298.
*
* @throws Exception
*/
public void testAddOfDeletedNonExistent() throws Exception
{
Fqn fqn = Fqn.fromString("/a/b");
assertNull("Should be null", cache1.getNode(fqn));
assertNull("Should be null", cache2.getNode(fqn));
// OK, here's the real test
TransactionManager tm = cache2.getTransactionManager();
tm.begin();
try
{
// Remove a node that doesn't exist in cache2
cache2.removeNode(fqn);
tm.commit();
}
catch (Exception e)
{
String msg = "Unable to remove non-existent node " + fqn;
fail(msg + " -- " + e);
}
// Actually, it shouldn't have been invalidated, should be null
// But, this assertion will pass if it is null, and we want
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache1.getNode(fqn), "Should have been invalidated");
assertNull("Should be null", cache2.getNode(fqn));
cache1.getInvocationContext().getOptionOverrides().setDataVersion(new DefaultDataVersion());
cache1.put(fqn, "key", "value");
assertEquals("value", cache1.getNode(fqn).get("key"));
CacheLoaderInvalidationTest.assertHasBeenInvalidated(cache2.getNode(fqn), "Should have been invalidated");
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/TombstoneEvictionTest.java 0000644 0001750 0001750 00000012267 11120571606 032233 0 ustar moeller moeller package org.jboss.cache.invalidation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.*;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.EvictionConfig;
import org.jboss.cache.config.EvictionRegionConfig;
import org.jboss.cache.eviction.FIFOAlgorithmConfig;
import org.jboss.cache.transaction.DummyTransactionManagerLookup;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.EvictionController;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.List;
/**
* Make sure tombstones are evicted
*
* @author Manik Surtani
* @since 2.1.0
*/
@Test(groups = {"functional", "optimistic"}, testName = "invalidation.TombstoneEvictionTest")
public class TombstoneEvictionTest extends AbstractMultipleCachesTest
{
private CacheSPI c1, c2;
private Fqn fqn = Fqn.fromString("/data/test");
private Fqn dummy = Fqn.fromString("/data/dummy");
private EvictionController ec1;
private EvictionController ec2;
protected void createCaches() throws Throwable
{
Configuration c = new Configuration();
// the FIFO policy cfg
FIFOAlgorithmConfig cfg = new FIFOAlgorithmConfig();
cfg.setMaxNodes(1);
cfg.setMinTimeToLive(0);
// the region configuration
EvictionRegionConfig regionCfg = new EvictionRegionConfig();
regionCfg.setRegionFqn(dummy.getParent());
regionCfg.setRegionName(dummy.getParent().toString());
regionCfg.setEvictionAlgorithmConfig(cfg);
// set regions in a list
List evictionRegionConfigs = new ArrayList();
evictionRegionConfigs.add(regionCfg);
EvictionConfig ec = new EvictionConfig();
ec.setWakeupInterval(-1);
ec.setEvictionRegionConfigs(evictionRegionConfigs);
c.setCacheMode(Configuration.CacheMode.INVALIDATION_SYNC);
c.setNodeLockingScheme(Configuration.NodeLockingScheme.OPTIMISTIC);
c.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
c.setEvictionConfig(ec);
c1 = (CacheSPI) new UnitTestCacheFactory().createCache(c, false, getClass());
c2 = (CacheSPI) new UnitTestCacheFactory().createCache(c.clone(), false, getClass());
c1.start();
c2.start();
ec1 = new EvictionController(c1);
ec2 = new EvictionController(c2);
TestingUtil.blockUntilViewsReceived(60000, c1, c2);
registerCaches(c1, c2);
}
@BeforeMethod
public void clearQueues()
{
clearRegions(c1.getRegionManager().getAllRegions(Region.Type.ANY));
clearRegions(c2.getRegionManager().getAllRegions(Region.Type.ANY));
}
private void clearRegions(List regionList)
{
for (Region region : regionList)
{
region.resetEvictionQueues();
}
}
private static final Log log = LogFactory.getLog(TombstoneEvictionTest.class);
public void testControl()
{
log.trace("***** entered testControl()");
c1.put(fqn, "k", "v");
c1.put(dummy, "k", "v");
log.trace("***** nodes were added testControl()");
assert c1.peek(fqn, false, true) != null : "Node should exist";
assert c1.peek(dummy, false, true) != null : "Node should exist";
ec1.startEviction();
assert c1.peek(fqn, false, true) == null : "Should have evicted";
assert c1.peek(dummy, false, true) != null : "Node should exist";
}
public void testWithInvalidationMarkers()
{
log.trace(" **** testWithInvalidationMarkers() before put");
c1.put(fqn, "k", "v");
c1.put(dummy, "k", "v");
log.trace(" **** testWithInvalidationMarkers() after put");
assert c1.peek(fqn, false, true) != null : "Node should exist";
assert c1.peek(dummy, false, true) != null : "Node should exist";
assert c2.peek(fqn, false, true) != null : "Node should exist";
assert c2.peek(dummy, false, true) != null : "Node should exist";
ec1.startEviction();
ec2.startEviction();
assert c1.peek(fqn, false, true) == null : "Should have evicted";
assert c1.peek(dummy, false, true) != null : "Node should exist";
assert c2.peek(fqn, false, true) == null : "Should have evicted";
assert c2.peek(dummy, false, true) != null : "Node should exist";
}
public void testWithTombstones()
{
c1.put(fqn, "k", "v");
c1.removeNode(fqn);
c1.put(dummy, "k", "v");
assert c1.peek(fqn, false, true) != null : "Node should exist";
assert c1.peek(dummy, false, true) != null : "Node should exist";
assert c2.peek(fqn, false, true) != null : "Node should exist";
assert c2.peek(dummy, false, true) != null : "Node should exist";
ec1.startEviction();
ec2.startEviction();
assert c1.peek(fqn, false, true) == null : "Should have evicted";
assert c1.peek(dummy, false, true) != null : "Node should exist";
assert c2.peek(fqn, false, true) == null : "Should have evicted";
assert c2.peek(dummy, false, true) != null : "Node should exist";
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/invalidation/CacheLoaderInvalidationTest.java0000644 0001750 0001750 00000015204 11131613416 033244 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.invalidation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.Fqn;
import org.jboss.cache.Node;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.util.TestingUtil;
import static org.testng.AssertJUnit.*;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
import javax.transaction.TransactionManager;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Tests the async interceptor
*
* @author Manik Surtani (manik AT jboss DOT org)
*/
@Test(groups = {"functional", "jgroups"}, testName = "invalidation.CacheLoaderInvalidationTest")
public class CacheLoaderInvalidationTest
{
private static Log log = LogFactory.getLog(CacheLoaderInvalidationTest.class);
private CacheSPI cache1, cache2;
private Set toClean = new HashSet();
@AfterMethod
public void tearDown()
{
TestingUtil.killCaches(cache1, cache2);
for (CacheSPI c : toClean) TestingUtil.killCaches(c);
toClean.clear();
}
public void testOptimisticWithCacheLoader() throws Exception
{
List> caches = createCachesWithSharedCL(true);
cache1 = caches.get(0);
cache2 = caches.get(1);
Fqn fqn = Fqn.fromString("/a/b");
TransactionManager mgr = caches.get(0).getTransactionManager();
assertNull("Should be null", caches.get(0).get(fqn, "key"));
assertNull("Should be null", caches.get(1).get(fqn, "key"));
mgr.begin();
caches.get(0).put(fqn, "key", "value");
assertEquals("value", caches.get(0).get(fqn, "key"));
assertNull("Should be null", caches.get(1).get(fqn, "key"));
mgr.commit();
assertEquals("value", caches.get(1).get(fqn, "key"));
assertEquals("value", caches.get(0).get(fqn, "key"));
mgr.begin();
caches.get(0).put(fqn, "key2", "value2");
assertEquals("value2", caches.get(0).get(fqn, "key2"));
assertNull("Should be null", caches.get(1).get(fqn, "key2"));
mgr.rollback();
assertEquals("value", caches.get(1).get(fqn, "key"));
assertEquals("value", caches.get(0).get(fqn, "key"));
assertNull("Should be null", caches.get(0).get(fqn, "key2"));
assertNull("Should be null", caches.get(1).get(fqn, "key2"));
}
protected CacheSPI createUnstartedCache(boolean optimistic) throws Exception
{
Configuration c = new Configuration();
//c.setClusterName("MyCluster");
c.setStateRetrievalTimeout(3000);
c.setCacheMode(Configuration.CacheMode.INVALIDATION_SYNC);
if (optimistic) c.setNodeLockingScheme("OPTIMISTIC");
c.setTransactionManagerLookupClass("org.jboss.cache.transaction.DummyTransactionManagerLookup");
CacheSPI cache = (CacheSPI) new UnitTestCacheFactory().createCache(c, false, getClass());
toClean.add(cache);
return cache;
}
protected CacheSPI createCache(boolean optimistic) throws Exception
{
CacheSPI cache = createUnstartedCache(optimistic);
cache.start();
toClean.add(cache);
return cache;
}
protected List> createCachesWithSharedCL(boolean optimistic) throws Exception
{
List> caches = new ArrayList>();
caches.add(createUnstartedCache(optimistic));
caches.add(createUnstartedCache(optimistic));
caches.get(0).getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(getClass()));
caches.get(1).getConfiguration().setCacheLoaderConfig(getCacheLoaderConfig(getClass()));
caches.get(0).start();
caches.get(1).start();
toClean.addAll(caches);
return caches;
}
protected void doRegionBasedTest(boolean optimistic) throws Exception
{
List> caches = new ArrayList>();
caches.add(createUnstartedCache(false));
caches.add(createUnstartedCache(false));
cache1 = caches.get(0);
cache2 = caches.get(1);
caches.get(0).getConfiguration().setUseRegionBasedMarshalling(true);
caches.get(1).getConfiguration().setUseRegionBasedMarshalling(true);
if (optimistic)
{
caches.get(0).getConfiguration().setNodeLockingScheme("OPTIMISTIC");
caches.get(1).getConfiguration().setNodeLockingScheme("OPTIMISTIC");
}
caches.get(0).start();
caches.get(1).start();
TestingUtil.blockUntilViewsReceived(caches.toArray(new CacheSPI[0]), 5000);
Fqn fqn = Fqn.fromString("/a/b");
assertNull("Should be null", caches.get(0).getNode(fqn));
assertNull("Should be null", caches.get(1).getNode(fqn));
caches.get(0).put(fqn, "key", "value");
assertEquals("expecting value", "value", caches.get(0).get(fqn, "key"));
Node n = caches.get(1).getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n, "Should have been invalidated");
// now put in caches.get(1), should fire an eviction
caches.get(1).put(fqn, "key", "value2");
assertEquals("expecting value2", "value2", caches.get(1).get(fqn, "key"));
n = caches.get(0).getNode(fqn);
CacheLoaderInvalidationTest.assertHasBeenInvalidated(n, "Should have been invalidated");
}
static CacheLoaderConfig getCacheLoaderConfig(Class requestor) throws Exception
{
return UnitTestConfigurationFactory.buildSingleCacheLoaderConfig(false, "",
"org.jboss.cache.loader.testloaders.DummySharedInMemoryCacheLoader", "bin=" + requestor , false, false, false, false, false);
}
static void assertHasBeenInvalidated(Node n, String message)
{
// depending on how n was retrieved!
if (n == null)
{
assert true : message;
}
else
{
assert !n.isValid() : message;
}
}
static void checkRemoteNodeIsRemoved(Node remoteNode)
{
assertHasBeenInvalidated(remoteNode, "Should have been removed");
// Recursively check any children
if (remoteNode != null)
{
for (Node child : remoteNode.getChildren())
{
checkRemoteNodeIsRemoved(child);
}
}
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/cluster/ 0000755 0001750 0001750 00000000000 11675221327 024054 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/cluster/ReplicationQueueTxTest.java 0000644 0001750 0001750 00000004626 11131613416 031350 0 ustar moeller moeller package org.jboss.cache.cluster;
import org.jboss.cache.Cache;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.UnitTestConfigurationFactory;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.replicationlisteners.ReplicationListener;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import javax.transaction.TransactionManager;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.commands.write.PutKeyValueCommand;
import org.jboss.cache.commands.tx.PrepareCommand;
@Test(groups = {"functional", "transaction"}, testName = "cluster.ReplicationQueueTxTest")
public class ReplicationQueueTxTest
{
Cache cache, cache2;
TransactionManager txManager;
@BeforeMethod
public void setUp() throws CloneNotSupportedException
{
Configuration c = UnitTestConfigurationFactory.createConfiguration(Configuration.CacheMode.REPL_ASYNC);
cache = new UnitTestCacheFactory().createCache(c, false, getClass());
cache.getConfiguration().setUseReplQueue(true);
cache.getConfiguration().setReplQueueInterval(100);
cache.getConfiguration().setReplQueueMaxElements(10);
cache.start();
cache2 = new UnitTestCacheFactory().createCache(cache.getConfiguration().clone(), getClass());
TestingUtil.blockUntilViewsReceived(60000, cache, cache2);
txManager = cache.getConfiguration().getRuntimeConfig().getTransactionManager();
}
@AfterMethod
public void tearDown()
{
TestingUtil.killCaches(cache, cache2);
cache = null;
cache2 = null;
}
public void testTransactionalReplication() throws Exception
{
ReplicationListener cache1Listener = ReplicationListener.getReplicationListener(cache);
ReplicationListener cache2Listener = ReplicationListener.getReplicationListener(cache2);
cache2Listener.expect(PutKeyValueCommand.class);
// outside of tx scope
cache.put("/a", "k", "v");
cache2Listener.waitForReplicationToOccur(5000);
assert cache2.get("/a", "k").equals("v");
// now, a transactional call
cache1Listener.expect(PrepareCommand.class);
txManager.begin();
cache2.put("/a", "k", "v2");
txManager.commit();
cache1Listener.waitForReplicationToOccur(5000);
assert cache.get("/a", "k").equals("v2");
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/cluster/ReplicationQueueTest.java 0000644 0001750 0001750 00000014731 11135416456 031043 0 ustar moeller moeller package org.jboss.cache.cluster;
import org.easymock.EasyMock;
import static org.easymock.EasyMock.*;
import org.jboss.cache.AbstractMultipleCachesTest;
import org.jboss.cache.Cache;
import org.jboss.cache.RPCManager;
import org.jboss.cache.UnitTestCacheFactory;
import org.jboss.cache.commands.ReplicableCommand;
import org.jboss.cache.commands.write.PutKeyValueCommand;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.ComponentRegistry;
import org.jboss.cache.util.TestingUtil;
import org.jboss.cache.util.internals.ReplicationQueueNotifier;
import org.jboss.cache.util.internals.replicationlisteners.ReplicationListener;
import org.jgroups.Address;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
import java.util.Collections;
import java.util.Vector;
import java.util.concurrent.CountDownLatch;
@Test(groups = "functional", testName = "cluster.ReplicationQueueTest")
public class ReplicationQueueTest extends AbstractMultipleCachesTest
{
private static final int COUNT = 10;
Cache cache, cache2;
ReplicationQueue replQ;
ComponentRegistry registry;
RPCManager originalRpcManager;
private ReplicationListener replicationListener;
protected void createCaches() throws Throwable
{
Configuration c = new Configuration();
c.setCacheMode(Configuration.CacheMode.REPL_ASYNC);
c.setUseReplQueue(true);
c.setReplQueueMaxElements(COUNT);
c.setReplQueueInterval(-1);
cache = new UnitTestCacheFactory().createCache(c, false, getClass());
cache.start();
registry = TestingUtil.extractComponentRegistry(cache);
replQ = registry.getComponent(ReplicationQueue.class);
originalRpcManager = cache.getConfiguration().getRuntimeConfig().getRPCManager();
cache2 = new UnitTestCacheFactory().createCache(cache.getConfiguration().clone(), getClass());
registerCaches(cache, cache2);
TestingUtil.blockUntilViewsReceived(60000, cache, cache2);
replicationListener = ReplicationListener.getReplicationListener(cache2);
}
@AfterMethod
public void tearDown()
{
// reset the original RPCManager
injectRpcManager(originalRpcManager);
registry.rewire();
}
private void injectRpcManager(RPCManager manager)
{
registry.registerComponent(manager, RPCManager.class);
}
public void testQueueHoldAndFlush() throws Exception
{
assert replQ != null;
assert replQ.elements.size() == 0 : "expected 0, recieved " + replQ.elements.size();
// mock the RPCManager used in the cache
RPCManager mockRpcManager = EasyMock.createStrictMock(RPCManager.class);
injectRpcManager(mockRpcManager);
// expect basic cluster related calls
expect(mockRpcManager.getMembers()).andReturn(originalRpcManager.getMembers()).anyTimes();
replay(mockRpcManager);
// check that nothing on the RPCManager will be called until we hit the replication queue threshold.
for (int i = 0; i < COUNT - 1; i++) cache.put("/a/b/c/" + i, "k", "v");
assertEquals(replQ.elements.size(), COUNT - 1);
// verify that no calls have been made on the mockRpcManager
verify(mockRpcManager);
// reset the mock
reset(mockRpcManager);
// now try the last PUT which should result in the queue being flushed.
expect(mockRpcManager.getMembers()).andReturn(originalRpcManager.getMembers()).anyTimes();
expect(mockRpcManager.callRemoteMethods((Vector) anyObject(), (ReplicableCommand) anyObject(), anyBoolean(), anyLong(), anyBoolean())).andReturn(Collections.emptyList()).anyTimes();
replay(mockRpcManager);
cache.put("/a/b/c/LAST", "k", "v");
assert replQ.elements.size() == 0;
// verify that the rpc call was only made once.
verify(mockRpcManager);
}
public void testFailure() throws InterruptedException
{
for (int i = 0; i < COUNT; i++)
{
cache.put("/a/b/c" + i, "key", "value");
assertNotNull(cache.get("/a/b/c" + i, "key"));
replicationListener.expect(PutKeyValueCommand.class);
}
replicationListener.waitForReplicationToOccur();
for (int i = 0; i < COUNT; i++) assertNotNull("on get i = " + i, cache2.get("/a/b/c" + i, "key"));
}
@Test(dependsOnMethods = "testFailure") //if this method will run first then PutKeyValues might still be on wire and influence the other method
public void testFlushConcurrency() throws Exception
{
// will create multiple threads to constantly perform a cache update, and measure the number of expected invocations on the RPC manager.
final int numThreads = 5;
final int numLoopsPerThread = 200;
int totalInvocations = numThreads * numLoopsPerThread;
assert totalInvocations % COUNT == 0 : "NumThreads and NumLoopsPerThread must multiply to be a multiple of COUNT";
final CountDownLatch latch = new CountDownLatch(1);
// mock the RPCManager used in the cache
RPCManager mockRpcManager = EasyMock.createStrictMock(RPCManager.class);
injectRpcManager(mockRpcManager);
// expect basic cluster related calls
expect(mockRpcManager.getMembers()).andReturn(originalRpcManager.getMembers()).anyTimes();
expect(mockRpcManager.callRemoteMethods((Vector) anyObject(), (ReplicableCommand) anyObject(), anyBoolean(), anyLong(), anyBoolean())).andReturn(Collections.emptyList()).anyTimes();
replay(mockRpcManager);
Thread[] threads = new Thread[numThreads];
for (int i = 0; i < numThreads; i++)
{
threads[i] = new Thread()
{
public void run()
{
try
{
latch.await();
}
catch (InterruptedException e)
{
// do nothing
}
for (int j = 0; j < numLoopsPerThread; j++)
{
cache.put("/a/b/c/" + getName() + "/" + j, "k", "v");
}
}
};
threads[i].start();
}
// start the threads
latch.countDown();
// wait for threads to join
for (Thread t : threads) t.join();
// now test results
verify(mockRpcManager);
ReplicationQueueNotifier notifier = new ReplicationQueueNotifier(cache);
notifier.waitUntillAllReplicated(250);
assert replQ.elements.size() == 0;
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/demo/ 0000755 0001750 0001750 00000000000 11675221332 023313 5 ustar moeller moeller jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/demo/CacheModelDelegate.java 0000644 0001750 0001750 00000001761 11111047320 027566 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.demo;
import org.jboss.cache.Cache;
/**
* Delegate that hides cache model details for the demo GUI
*
* @author Galder Zamarreno
*/
public interface CacheModelDelegate
{
/**
* Sets the cache instance that will be used by users to interact with the real cache via the beanshell console.
*
* @param cache either PojoCache or Cache instance
*/
void setCacheShellVariable(Object cache);
/**
* Gets the cache instance that will be used by users to interact with the real cache via the beanshell console.
*
* @return either PojoCache or Cache instance
*/
Object getCacheShellVariable();
/**
* Gets the Cache instance that the GUI will use to populate the fiels in the GUI.
*
* @return returns an instance of Cache
*/
Cache getGenericCache();
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/demo/JBossCacheView.java 0000644 0001750 0001750 00000013032 11111047320 026740 0 ustar moeller moeller /*
* JBoss, the OpenSource J2EE webOS
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
* Created on March 25 2003
*/
package org.jboss.cache.demo;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.Cache;
import org.jboss.cache.CacheFactory;
import org.jboss.cache.DefaultCacheFactory;
/**
* Graphical view of a JBoss Cache instance. Think of it as a view in an MVC model. An instance of this view
* needs to be given a reference to the model ({@link CacheModelDelegate}) and needs to registers as a
* {@link org.jboss.cache.CacheListener}. Changes to the cache structure are propagated from the model to the
* view (via the CacheListener interface), changes from the GUI (e.g. by a user) are executed on the cache model
* which will delegate on the actual Cache instance (which, if clustered, will broadcast the changes to all replicas).
*
* The view itself maintains references to the nodes, but doesn't cache any of the data associated with the nodes. When
* data needs to be displayed, the underlying cache will be accessed directly.
*
* @author Manik Surtani
* @author Galder Zamarreno
* @version $Revision: 7168 $
*/
public class JBossCacheView
{
private static Log log = LogFactory.getLog(JBossCacheView.class.getName());
/**
* A reference to the Swing GUI that displays contents to the user.
*/
private JBossCacheGUI gui = null;
/**
* Whether or not to use the embedded BeanShell console.
*/
private boolean useConsole = false;
/**
* Cache configuration file.
*/
private String configurationFile = null;
/**
* The cache model.
*/
private CacheModelDelegate cacheModelDelegate;
/**
* Gets the configuration file
*
* @return String containing the path to the configuration file
*/
public String getConfigurationFile()
{
return configurationFile;
}
/**
* Sets a reference to the cache model
*
* @param cacheModelDelegate cache model instance to associate with this view
*/
public void setCacheModelDelegate(CacheModelDelegate cacheModelDelegate)
{
this.cacheModelDelegate = cacheModelDelegate;
if (gui != null) gui.setCacheModelDelegate(cacheModelDelegate);
}
/**
* Main code for the view
*
* @param args arguments passed via command line
* @throws Exception if there's any issues starting the cache demo
*/
public void doMain(String[] args) throws Exception
{
parseParameters(args);
if (configurationFile == null)
{
help();
throw new Exception("Configuration file cannot be null, please specify with the -config parameter when starting!");
}
CacheModelDelegate cacheModelDelegate = createCacheDelegate();
cacheModelDelegate.getGenericCache().start();
setCacheModelDelegate(cacheModelDelegate);
start();
}
/**
* Starts the view
*
* @throws Exception
*/
public void start() throws Exception
{
if (gui == null)
{
log.info("start(): creating the GUI");
System.out.println("start(): creating the GUI");
gui = createGUI(cacheModelDelegate, useConsole);
}
}
/**
* Stops the view
*/
public void stop()
{
if (gui != null)
{
log.info("stop(): disposing the GUI");
gui.stopGui();
gui = null;
}
}
/**
* Starts the view
*
* @param args valid arguments are: -console to enable using the embedded beanShell console, -config [path/to/config/file] to specify a config file.
*/
public static void main(String args[])
{
try
{
JBossCacheView view = new JBossCacheView();
view.doMain(args);
}
catch (Exception ex)
{
log.error("Cannot start up!!", ex);
}
}
/**
* Parses the parameters
*
* @param args arguments passed via command line
*/
protected void parseParameters(String[] args)
{
for (int i = 0; i < args.length; i++)
{
if (args[i].equals("-console"))
{
useConsole = true;
continue;
}
if (args[i].equals("-config"))
{
configurationFile = args[++i];
continue;
}
help();
return;
}
}
/**
* Factory method that creates the cache model delegate instance for this demo
*
* @return instance of CacheModelDelegate
* @throws Exception
*/
protected CacheModelDelegate createCacheDelegate() throws Exception
{
CacheFactory factory = new DefaultCacheFactory();
Cache cache = factory.createCache(configurationFile, false);
CacheModelDelegate delegate = new JBossCacheModelDelegate();
delegate.setCacheShellVariable(cache);
return delegate;
}
protected JBossCacheGUI createGUI(CacheModelDelegate delegate, boolean useConsole) throws Exception
{
return new JBossCacheGUI(delegate, useConsole);
}
private static void help()
{
System.out.println("JBossCacheView [-help] " +
"[-console] " +
"[-config ]");
System.out.println();
System.out.println("-console enables the embedded BeanShell console");
System.out.println("-config allows you to provide a path to the configuration file to use.");
System.out.println();
System.out.println();
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/demo/JBossCacheModelDelegate.java 0000644 0001750 0001750 00000001260 11111047320 030521 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.demo;
import org.jboss.cache.Cache;
/**
* Model delegate implementation for JBossCache demo
*
* @author Galder Zamarreno
*/
public class JBossCacheModelDelegate implements CacheModelDelegate
{
private Cache cache;
public void setCacheShellVariable(Object cache)
{
this.cache = (Cache) cache;
}
public Object getCacheShellVariable()
{
return cache;
}
public Cache getGenericCache()
{
return cache;
}
}
jbosscache-core-3.2.8.GA/src/test/java/org/jboss/cache/demo/JBossCacheGUI.java 0000644 0001750 0001750 00000106534 11111047320 026464 0 ustar moeller moeller /*
* JBoss, Home of Professional Open Source
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.cache.demo;
import bsh.EvalError;
import bsh.Interpreter;
import bsh.util.JConsole;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.cache.Cache;
import org.jboss.cache.Fqn;
import org.jboss.cache.Node;
import org.jboss.cache.lock.TimeoutException;
import org.jboss.cache.notifications.annotation.CacheListener;
import org.jboss.cache.notifications.annotation.NodeCreated;
import org.jboss.cache.notifications.annotation.NodeEvicted;
import org.jboss.cache.notifications.annotation.NodeLoaded;
import org.jboss.cache.notifications.annotation.NodeModified;
import org.jboss.cache.notifications.annotation.NodeRemoved;
import org.jboss.cache.notifications.annotation.ViewChanged;
import org.jboss.cache.notifications.event.NodeEvent;
import org.jboss.cache.notifications.event.NodeModifiedEvent;
import org.jboss.cache.notifications.event.ViewChangedEvent;
import org.jboss.cache.util.CachePrinter;
import org.jgroups.Address;
import javax.swing.*;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.InputEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Vector;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
/**
* JBossCache GUI for the demo
*
* @author Manik Surtani (manik AT jboss DOT org)
* @author Galder Zamarreno
*/
@CacheListener
public class JBossCacheGUI extends JFrame implements WindowListener, TreeSelectionListener, TableModelListener
{
private static final long serialVersionUID = -1242167331988194987L;
private transient CacheModelDelegate cacheModelDelegate;
private transient Cache cache;
private DefaultTreeModel tree_model = null;
private transient Log log = LogFactory.getLog(getClass());
private JTree jtree = null;
private DefaultTableModel tableModel = new DefaultTableModel();
private JTable table = new JTable(tableModel);
private JBossCacheGUI.DisplayNode myNodeRoot = new JBossCacheGUI.DisplayNode(Fqn.SEPARATOR);
private transient Node root;
private transient Node selected_node = null;
private JPanel tablePanel = null;
private JPopupMenu operationsPopup = null, dataModificationsPopup = null;
private static final int KEY_COL_WIDTH = 20;
private static final int VAL_COL_WIDTH = 300;
private TransactionManager tx_mgr = null;
private transient Transaction tx = null;
private JPanel mainPanel;
private List membership = new LinkedList();
private Address coordinator = null;
private boolean useConsole = false;
JConsole bshConsole;
/**
* Run any work that happens in this interface in a separate thread. This is good practise. Unless there's a
* resource-managemenet requirement, such as in an application server, newCachedThreadPool is a good option as it
* provides better queuing performance.
*/
private transient Executor executor;
public JBossCacheGUI(CacheModelDelegate cacheDelegate, boolean useConsole) throws Exception
{
executor = Executors.newCachedThreadPool();
addNotify();
this.useConsole = useConsole;
tree_model = new DefaultTreeModel(new JBossCacheGUI.DisplayNode(Fqn.ROOT.toString()));
jtree = new JTree(tree_model);
jtree.setDoubleBuffered(true);
jtree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
JScrollPane scroll_pane = new JScrollPane(jtree);
mainPanel = new JPanel();
mainPanel.setLayout(new BorderLayout());
mainPanel.add(scroll_pane, BorderLayout.CENTER);
addWindowListener(this);
tableModel.setColumnIdentifiers(new String[]{"Name", "Value"});
tableModel.addTableModelListener(this);
// add a mouse listener to the table model for delete and insert rows.
MouseListener dataMouseListener = new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
if (rightClick(e.getModifiers()))
{
dataModificationsPopup.show(e.getComponent(), e.getX(), e.getY());
}
}
};
setTableColumnWidths();
tablePanel = new JPanel();
tablePanel.setLayout(new BorderLayout());
tablePanel.add(table.getTableHeader(), BorderLayout.NORTH);
tablePanel.add(table, BorderLayout.CENTER);
table.addMouseListener(dataMouseListener);
mainPanel.add(tablePanel, BorderLayout.SOUTH);
JSplitPane contentPanel = null;
if (useConsole)
{
String welcomeMessage = getWelcomeMessage();
bshConsole = new JConsole();
Interpreter interpreter = new Interpreter(bshConsole);
configureInterpreter(interpreter, cacheDelegate);
interpreter.println(welcomeMessage);
interpreter.setShowResults(!interpreter.getShowResults());// show() in beanShell
System.setOut(bshConsole.getOut());
System.setErr(bshConsole.getErr());
Thread t = new Thread(interpreter);
t.start();
contentPanel = new JSplitPane(JSplitPane.VERTICAL_SPLIT, mainPanel, bshConsole);
getContentPane().add(contentPanel);
}
else
{
getContentPane().add(mainPanel);
}
jtree.addTreeSelectionListener(this);// REVISIT
MouseListener ml = new MouseAdapter()
{
public void mouseClicked(final MouseEvent e)
{
if (log.isTraceEnabled())
{
log.trace("clicked GUI");
}
final int selRow = jtree.getRowForLocation(e.getX(), e.getY());
final TreePath selPath = jtree.getPathForLocation(e.getX(), e.getY());
if (selRow != -1)
{
if (log.isTraceEnabled())
{
log.trace("clicked on node in GUI");
}
Runnable r = new Runnable()
{
public void run()
{
try
{
selected_node = getNode(selPath.getPath());
jtree.setSelectionPath(selPath);
if (rightClick(e.getModifiers()))
{
operationsPopup.show(e.getComponent(), e.getX(), e.getY());
}
}
catch (TimeoutException te)
{
String message = "Unable to update GUI due to a timeout trying to acquire lock on a node." +
"This might be due to clicking on a node which is currently locked by an ongoing " +
"transaction: ";
printAndLogStacktrace(message, te);
}
catch (Exception e)
{
printAndLogStacktrace("Updating GUI failed: ", e);
}
}
};
executor.execute(r);
}
}
};
jtree.addMouseListener(ml);
createMenus();
setLocation(50, 50);
setSize(getInsets().left + getInsets().right + 800, getInsets().top + getInsets().bottom + 800);
// make sure we set the cache BEFORE initialising this!!
setCacheModelDelegate(cacheDelegate);
init();
setVisible(true);
tree_model.setRoot(myNodeRoot);
tree_model.reload();
if (useConsole)
{
//has to be called after setVisible() otherwise no effect
contentPanel.setDividerLocation(0.65);
}
}
public void setCacheModelDelegate(final CacheModelDelegate cacheModelDelegate)
{
this.cacheModelDelegate = cacheModelDelegate;
if (this.cacheModelDelegate != null)
{
this.cache = this.cacheModelDelegate.getGenericCache();
Runtime.getRuntime().addShutdownHook(
new Thread()
{
public void run()
{
cache.stop();
}
});
cache.addCacheListener(this);
root = cache.getRoot();
setTitle("JBoss Cache GUI: Local Address=" + getLocalAddress());
tx_mgr = cache.getConfiguration().getRuntimeConfig().getTransactionManager();
populateTree();
}
else
{
setTitle("Cache undefined");
if (tree_model != null)
{
myNodeRoot = new JBossCacheGUI.DisplayNode(Fqn.SEPARATOR);
tree_model.setRoot(myNodeRoot);
tree_model.reload();
}
if (tableModel != null)
{
clearTable();
}
}
}
/**
* Checks whether a click event is considered a "right-click"
*
* @param modifiers mouse event mods
* @return true if deemed a right click
*/
private boolean rightClick(int modifiers)
{
// the simple right click case
if (modifiers == InputEvent.BUTTON3_MASK) return true;
// more complex on Mac OS X where a ctrl-click is deemed the same as a right click
return modifiers == InputEvent.BUTTON1_MASK + InputEvent.CTRL_MASK;
}
public void windowClosed(WindowEvent event)
{
}
public void windowDeiconified(WindowEvent event)
{
}
public void windowIconified(WindowEvent event)
{
}
public void windowActivated(WindowEvent event)
{
}
public void windowDeactivated(WindowEvent event)
{
}
public void windowOpened(WindowEvent event)
{
}
public void windowClosing(WindowEvent event)
{
stopGui();
}
public void tableChanged(TableModelEvent evt)
{
if (log.isTraceEnabled())
{
log.trace("table contents changed, event type is: " + evt.getType());
}
int row, col;
String key, val;
if (evt.getType() == TableModelEvent.UPDATE)
{
row = evt.getFirstRow();
col = evt.getColumn();
key = (String) tableModel.getValueAt(row, col == 0 ? 0 : col - 1);
val = (String) tableModel.getValueAt(row, col == 0 ? 1 : col);
if (key != null && val != null && !isPlaceHolder(key) && !isPlaceHolder(val))
{
try
{
if (log.isTraceEnabled())
{
log.trace("updating node: " + selected_node + " with new values [k=" + key + ",v=" + val + "]");
}
selected_node.put(key, val);
Map data = selected_node.getData();
populateTable(data);
}
catch (Exception e)
{
printAndLogStacktrace("Changing table failed: ", e);
}
}
}
}
public void valueChanged(final TreeSelectionEvent evt)
{
if (log.isTraceEnabled())
{
log.trace("node was selected in GUI: " + evt.getPath());
}
Runnable r = new Runnable()
{
public void run()
{
try
{
Map data;
selected_node = getNode(evt.getPath().getPath());
if (selected_node != null)
{
data = selected_node.getData();
if (data != null)
{
mainPanel.add(tablePanel, BorderLayout.SOUTH);
populateTable(data);
validate();
}
else
{
clearTable();
mainPanel.remove(tablePanel);
validate();
}
}
}
catch (TimeoutException te)
{
String message = "Unable to update GUI due to a timeout trying to acquire lock on a node." +
"This might be due to clicking on a node which is currently locked by an ongoing " +
"transaction: ";
printAndLogStacktrace(message, te);
}
catch (Exception e)
{
printAndLogStacktrace("Updating GUI failed: ", e);
}
}
};
executor.execute(r);
}
protected DefaultTableModel getTableModel()
{
return tableModel;
}
protected String getWelcomeMessage()
{
return "Welcome to the BeanShell console.\n\n" +
"This console gives you a direct shell interface to the GUI above and allows you to manipulate the cache directly. " +
"Some of the variables initialised in this shell session are:\n\n" +
"// an instance of org.jboss.cache\n" +
" Cache cache;\n" +
"// a reference to the root node\n" +
" Node root;\n" +
"// the transaction manager registered with the cache\n" +
" TransactionManager transactionManager;\n";
}
protected void configureInterpreter(Interpreter interpreter, CacheModelDelegate cacheDelegate) throws EvalError
{
interpreter.getNameSpace().importPackage("org.jboss.cache");
interpreter.getNameSpace().importPackage("org.jboss.cache.transaction");
interpreter.set("cache", cacheDelegate.getGenericCache());
interpreter.set("root", cacheDelegate.getGenericCache().getRoot());
interpreter.set("transactionManager", cacheDelegate.getGenericCache().getConfiguration().getRuntimeConfig().getTransactionManager());
}
/* ------------------ CacheListener interface ------------ */
@NodeCreated
@NodeLoaded
public void nodeCreated(NodeEvent e)
{
/* Updating the GUI upon node creation should be done sequentially to avoid concurrency issues when
adding multiple nodes at the same time, for example for PojoCache, where attaching a pojo creates several nodes.
Creating several visual nodes in paralell and trying to scroll to them is not a thread safe operation */
if (e.isPre())
{
JBossCacheGUI.DisplayNode n;
n = myNodeRoot.add(e.getFqn());
if (n != null)
{
tree_model.setRoot(myNodeRoot);
tree_model.reload();
jtree.scrollPathToVisible(new TreePath(n.getPath()));
}
}
}
@NodeModified
public void nodeModified(final NodeModifiedEvent e)
{
Runnable r = new Runnable()
{
public void run()
{
if (e.isPre() && selected_node != null && selected_node.getFqn().equals(e.getFqn()))//&& !isLocal)
{
clearTable();
Node n = root.getChild(e.getFqn());
if (n != null)
{
populateTable(n.getData());
}
}
}
};
executor.execute(r);
}
@NodeRemoved
@NodeEvicted
public void nodeRemoved(final NodeEvent e)
{
if (log.isTraceEnabled())
{
log.trace("node removed, updating GUI");
}
Runnable r = new Runnable()
{
public void run()
{
if (e.isPre())
{
JBossCacheGUI.DisplayNode n;
n = myNodeRoot.findNode(e.getFqn());
if (n != null)
{
n.removeAllChildren();
n.removeFromParent();
tree_model.setRoot(myNodeRoot);
tree_model.reload();
}
}
}
};
executor.execute(r);
}
@ViewChanged
public void viewChange(final ViewChangedEvent e)
{
Runnable r = new Runnable()
{
public void run()
{
List