Google Git
Sign in
apache/wicket/a434345d9e47b913d7b8c34a31450ec8fe8ad256
commit
a434345d9e47b913d7b8c34a31450ec8fe8ad256
[log]
author
Emond Papegaaij <papegaaij@apache.org>
Mon Aug 24 09:09:43 2026 +0200
committer
Emond Papegaaij <papegaaij@apache.org>
Mon Aug 24 09:09:43 2026 +0200
tree
a98f4dc35362f56e96b3f28a9d61a6bc187be550
parent
1a3e0e498b47a04ceb4920b812967c91154d362f [diff]
Add JaCoCo coverage measurement and Codecov reporting

The 'coverage' profile produced no data at all. maven-surefire-plugin's
pluginManagement set a literal <argLine> for the --add-opens flags, which
overrode the argLine property that jacoco:prepare-agent sets, so the agent
never attached to the forked test JVMs.

Surefire now consumes @{jacoco.argLine}, substituted at fork time. That
placeholder property must stay declared even though it is empty: surefire
only substitutes @{x} for properties that exist, and would otherwise hand
the literal token to the JVM and break every test module whenever the
profile is inactive.

Per-module reports would have been misleading too, because most tests live
in a module other than the code they exercise: wicket-core has no tests of
its own, and wicket-core-tests has no production classes. The new
wicket-coverage module aggregates the reactor with jacoco:report-aggregate
instead, using dependency scope to say what belongs in the report -- compile
contributes classes and sources, test contributes execution data only. The
per-module 'report' execution is dropped.

Coverage is measured on the JDK 21 leg of the existing build and uploaded to
Codecov for every push and pull request. It is reported, never enforced:
codecov.yml marks both status checks informational, so neither can fail a
build or block a merge.

check-coverage-report.py guards the measurement itself. Should a future
<argLine> override drop the placeholder, or a dependency scope change,
coverage would silently fall to zero rather than fail; the script asserts
the module set and non-zero coverage for the three cross-module cases, but
never a percentage.

Current aggregate: 67.5% of instructions, 67.4% of lines.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
6 files changed
tree: a98f4dc35362f56e96b3f28a9d61a6bc187be550
  1. .github/
  2. archetypes/
  3. licenses/
  4. testing/
  5. wicket/
  6. wicket-auth-roles/
  7. wicket-bean-validation/
  8. wicket-cdi/
  9. wicket-cdi-tests/
  10. wicket-core/
  11. wicket-core-tests/
  12. wicket-coverage/
  13. wicket-devutils/
  14. wicket-eclipse-settings/
  15. wicket-examples/
  16. wicket-experimental/
  17. wicket-extensions/
  18. wicket-extensions-tester/
  19. wicket-guice/
  20. wicket-ioc/
  21. wicket-jmx/
  22. wicket-migration/
  23. wicket-native-websocket/
  24. wicket-objectsizeof-agent/
  25. wicket-request/
  26. wicket-spring/
  27. wicket-tester/
  28. wicket-user-guide/
  29. wicket-util/
  30. wicket-velocity/
  31. .asf.yaml
  32. .gitignore
  33. build-changelog.sh
  34. build-versions.py
  35. CHANGELOG-10.x
  36. codecov.yml
  37. LICENSE
  38. NOTICE
  39. pom.xml
  40. README.md
  41. release.sh
  42. SECURITY.md
  43. wicket-assembly-all.xml
README.md

What is Apache Wicket?

Apache Wicket is an open source, java, component based, web application framework. With proper mark-up/logic separation, a POJO data model, and a refreshing lack of XML, Apache Wicket makes developing web-apps simple and enjoyable again. Swap the boilerplate, complex debugging and brittle code for powerful, reusable components written with plain Java and HTML.

Apache Wicket can be found at https://wicket.apache.org and is licensed under the Apache Software Foundation license, version 2.0.

Getting started

The Wicket project has several resources and projects where you can learn from, and get started quickly:

What does Wicket's download package contain?

You can download Wicket's source package here: https://wicket.apache.org/start/wicket-10.x.html . It contains the source code and the jars of the core projects of Wicket. If you are just starting out, you probably only need to include wicket-util-x.jar, wicket-request-x.jar and wicket-core-x.jar, where x stands for the version. As a rule, use just the jars you need.

You will find the source code here:

|-- apidocs
|   |-- org
|   `-- resources
|-- lib
|-- licenses
`-- src
    |-- archetypes
    |-- testing
    |-- wicket
    |-- wicket-auth-roles
    |-- wicket-bean-validation
    |-- wicket-cdi
    |-- wicket-cdi-tests
    |-- wicket-core
    |-- wicket-tester
    |-- wicket-core-tests
    |-- wicket-devutils
    |-- wicket-eclipse-settings
    |-- wicket-examples
    |-- wicket-experimental
    |   |-- wicket-metrics
    |   |-- wicket-http2
    |-- wicket-extensions
    |-- wicket-guice
    |-- wicket-ioc
    |-- wicket-jmx
    |-- wicket-native-websocket
    |-- wicket-objectssizeof-agent
    |-- wicket-request
    |-- wicket-spring
    |-- wicket-util
    |-- wicket-user-guide
    `-- wicket-velocity

Here is a list of projects in the distribution and what they do.

  • wicket-core: the core project, includes the framework and basic components;
  • wicket-tester: contains common classes for unit testing
  • wicket-core-tests: contains test cases for wicket-core module
  • wicket-extensions: contains utilities and more specialized components;
  • wicket-auth-roles: a basic authorization package based on roles;
  • wicket-jmx: registers JMX beans for managing things like your Wicket configuration and markup cache;
  • wicket-objectssizeof-agent: utility for making better estimates of object sizes in the JVM - most people probably never need this;
  • wicket-ioc: base project for IoC (aka DI) implementations such as Spring and Guice;
  • wicket-spring: support project for using Spring with Wicket and including Spring managed dependencies through using @SpringBean annotations;
  • wicket-guice: support project for using Google Guice with Wicket;
  • wicket-velocity: contains special components for rendering Velocity templates using Wicket components - most people probably don't need this, but it can be neat when you want to do CMS-like things;
  • wicket-examples: contains a basic component reference and many examples of how to use Wicket and Wicket components, including examples for subprojects such as wicket-spring, wicket-velocity and wicket-auth-roles.
  • wicket-devutils: provides small utilities which can help in development phase and during debugging
  • wicket-bean-validation: validates beans with annotation based on javax.validation;
  • wicket-cdi: the context and dependency injection of the jee standard for wicket;
  • wicket-experimental: experimental implementations for wicket;
  • wicket-native-websocket: wicket's native web sockets integration for several servers;
  • wicket-request: lightweight project which contains all classes dealing with request handlers and so on;
  • wicket-util: the util project for wicket;
  • wicket-eclipse-settings: specifies Eclipse settings for a uniform development environment. Most notably the formatting rules;
  • wicket-user-guide: the user guide of wicket
  • wicket-metrics: collects data of a running wicket application
  • wicket-http2: http/2 push support

Dependencies

The easiest way of getting the dependencies of your Wicket based projects right is to use Apache Maven (https://maven.apache.org) with your projects and include the wicket dependencies you want as outlined in the wicket-quickstart. Maven will then take care of including the appropriate dependencies.

If you do not want to use Maven, here is a break-down of the dependencies you need. For the complete and precise reference see the wicket-parent pom.xml in the root folder.

Building Wicket from source

Wicket's source distribution (download package mentioned above) contains also the binaries (jar files) for each of its modules (subprojects). You can use these directly in your applications. The Wicket project uploads the source and JavaDoc jars to the Maven repository used by the Maven build tool as well. So there is actually no specific need to build Wicket yourself from the distribution.

When building using Maven 3, execute one of the following in the root folder:

  • mvn package

    creates wicket-(subproject)-x.y.z.jar(s) in according target subdirectories.

  • mvn install

    creates wicket-(subproject)-x.y.z.jar(s) in according target subdirectories and installs the jar files into your local Maven repository for use in other projects.

Code coverage

Coverage is measured with JaCoCo and aggregated into a single report, because most Wicket tests live in a module other than the code they exercise (the tests for wicket-core are in wicket-core-tests, for example). To produce it:

  • mvn clean verify -Pcoverage

    writes the aggregated report to wicket-coverage/target/site/jacoco-aggregate/index.html

To build only the modules that feed the report, which is considerably faster:

  • mvn clean verify -Pcoverage -pl wicket-coverage -am

Note that a build without “clean” merges the previous run's data into the new report, because the JaCoCo agent appends by default.

Every push and pull request also uploads this report to https://app.codecov.io/gh/apache/wicket. Coverage is reported there, never enforced: no coverage check can fail a build or block a merge.

Migrating from 9.x

This file is a copy of the migration guide available on our Wiki:

https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+10.0

Getting help

  • Read the online documentation available on our website (https://wicket.apache.org)

  • Read the migration guide above

  • Read the mailing archives available on Nabble, GMane and Apache

  • Send a complete message containing your problem, stacktrace and problem you're trying to solve to our user list (users@wicket.apache.org)

  • Ask a question on IRC at freenode.net, channel ##wicket

License

Wicket is distributed under the terms of the Apache Software Foundation license, version 2.0. The text is included in the file LICENSE in the root of the project.

Java/Application server requirements

Wicket 10 requires at least Java 17. The application server for running your web application should adhere to the Jakarta Servlet 5 specification or newer.

Cryptographic Software Notice

This distribution includes cryptographic software. The country in which you currently reside may have restrictions on the import, possession, use, and/or re-export to another country, of encryption software. BEFORE using any encryption software, please check your country's laws, regulations and policies concerning the import, possession, or use, and re-export of encryption software, to see if this is permitted. See http://www.wassenaar.org for more information.

The U.S. Government Department of Commerce, Bureau of Industry and Security (BIS), has classified this software as Export Commodity Control Number (ECCN) 5D002.C.1, which includes information security software using or performing cryptographic functions with asymmetric algorithms. The form and manner of this Apache Software Foundation distribution makes it eligible for export under the License Exception ENC Technology Software Unrestricted (TSU) exception (see the BIS Export Administration Regulations, Section 740.13) for both object code and source code.

The following provides more details on the included cryptographic software:

For encoding HTTP URL data (see org.apache.wicket.core.request.mapper.CryptoMapper) Wicket requires the Java Cryptography extensions (http://java.sun.com/javase/technologies/security/). Wicket does not include these libraries itself, but is designed to use them.