Next Development Version

Remove duplicate "property" in PropertyCacheKey.toString()
Closes gh-26237
2026-06-08 17:33:33 +00:00 · 2020-12-09 08:31:54 +00:00 · 2020-12-08 15:14:28 +01:00 · 2020-12-08 15:14:08 +01:00 · 2020-12-02 17:52:40 +01:00 · 2020-12-01 20:28:00 +00:00
7719 changed files with 355556 additions and 479857 deletions
@@ -1,10 +0,0 @@
-root = true
-
-[*.{adoc,bat,groovy,html,java,js,jsp,kt,kts,md,properties,py,rb,sh,sql,svg,txt,xml,xsd}]
-charset = utf-8
-
-[*.{groovy,java,kt,kts,xml,xsd}]
-indent_style = tab
-indent_size = 4
-continuation_indent_size = 8
-end_of_line = lf
@@ -1,17 +0,0 @@
-<!--
-!!! For Security Vulnerabilities, please go to https://pivotal.io/security !!!
-->
-**Affects:** \<Spring Framework version>
-
---
-<!--
-Thanks for taking the time to create an issue. Please read the following:
-
- Questions should be asked on Stack Overflow.
- For bugs, specify affected versions and explain what you are trying to do.
- For enhancements, provide context and describe the problem.
-
-Issue or Pull Request? Create only one, not both. GitHub treats them as the same.
-If unsure, start with an issue, and if you submit a pull request later, the
-issue will be closed as superseded.
-->
@@ -17,13 +17,9 @@ argfile*
 pom.xml
 activemq-data/

-classes/
 /build
 buildSrc/build
 /spring-*/build
-/spring-core/kotlin-coroutines/build
-/framework-bom/build
-/integration-tests/build
 /src/asciidoc/build
 target/

@@ -0,0 +1,9 @@
+#com.springsource.sts.gradle.core.preferences.GradleImportPreferences
+#Thu Aug  9 11:34:43 CEST 2012
+enableAfterTasks=true
+afterTasks=afterEclipseImport;
+enableDependendencyManagement=false
+enableBeforeTasks=true
+projects=;spring-aop;spring-aspects;spring-beans;spring-context;spring-context-support;spring-core;spring-expression;spring-instrument;spring-instrument-tomcat;spring-jdbc;spring-jms;spring-orm;spring-oxm;spring-struts;spring-test;spring-tx;spring-web;spring-webmvc;spring-webmvc-portlet;
+enableDSLD=false
+beforeTasks=cleanEclipse;eclipse;\:spring-oxm\:compileTestJava;
@@ -0,0 +1,5 @@
+#com.springsource.sts.gradle.core.preferences.GradleProjectPreferences
+#Tue Feb 21 14:38:31 CET 2012
+com.springsource.sts.gradle.classpath.enableSorting=false
+com.springsource.sts.gradle.rootprojectloc=
+com.springsource.sts.gradle.linkedresources=
@@ -0,0 +1,9 @@
+#com.springsource.sts.gradle.core.actions.GradleRefreshPreferences
+#Thu Aug  9 11:34:43 CEST 2012
+enableAfterTasks=true
+afterTasks=afterEclipseImport;
+useHierarchicalNames=false
+enableBeforeTasks=true
+addResourceFilters=false
+enableDSLD=false
+beforeTasks=cleanEclipse;eclipse;\:spring-oxm\:compileTestJava;
@@ -0,0 +1,51 @@
+= How to contribute to the reference
+
+The Spring Framework reference now uses https://asciidoctor.org/[asciidoctor]. This
+document describes how to contribute documentation updates.
+
+== Building with Gradle
+
+You can build the documentation using gradle using the `reference` task. For example, from
+the project root execute the following command:
+
+	./gradlew reference
+
+the output will be available at `spring-framework/build/reference/htmlsingle/index.html`
+
+== Live editing
+
+One of the nice features about using asciidoctor is the support for live editing.
+
+You will find a Guardfile already present at `spring-framework/src/asciidoc/Guardfile`.
+Make sure first to follow the setup instructions within the
+https://asciidoctor.org/docs/editing-asciidoc-with-live-preview/[Editing AsciiDoc with Live Preview]
+document. Once you have done that, there are additional gems to install to make it work
+(assuming that you are using http://livereload.com/[LiveReload]):
+
+	gem install guard-rspec guard-livereload
+
+When running `guard start` within the `src/asciidoc/` folder, any changes to the
+`src/asciidoc/index.adoc` file will automatically be written at
+`src/asciidoc/build/index.html`.
+
+== Troubleshooting
+
+* If you are using LiveReload, make sure to select _Allow access to file URLs_ in the
+  LiveEdit plugin options of your browser.
+* The icon used to enable _LiveReload_ can be a bit confusing. The dot is empty when it is
+  disabled and full when the plugin is active. Make sure to enable it on the tab
+  displaying the `index.html` file.
+* Ensure you are _not_ running guard start at all as two instances could not run at the
+  same time. To exit a current session in a clean way, just type e in the shell.
+
+== Documentation notes
+
+Some notes on documentation
+
+* Documentation is wrapped at 90 chars, ensure that you manually wrap your edits
+* Tabs are used for indentation, do not use spaces
+* Follow the existing style when inserting `source` blocks
+* https://asciidoctor.org/docs/asciidoc-syntax-quick-reference/[Asciidoctor Quick Reference]
+* https://asciidoctor.org/docs/user-manual/[Asciidoctor Manual]
+* https://asciidoctor.org/docs/asciidoc-writers-guide/[Asciidoctor Writers Guide]
+
@@ -1,133 +1,319 @@
-# Contributing  to the Spring Framework
+_Have something you'd like to contribute to the framework?  We welcome pull
+requests but ask that you carefully read this document first to understand how
+best to submit them; what kind of changes are likely to be accepted; and what
+to expect from the Spring team when evaluating your submission._

-First off, thank you for taking the time to contribute! :+1: :tada: 
+_Please refer back to this document as a checklist before issuing any pull
+request; this will save time for everyone!_

-### Table of Contents
+## Code of Conduct
+This project adheres to the Contributor Covenant [code of conduct](CODE_OF_CONDUCT.adoc).
+By participating, you  are expected to uphold this code. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.

-* [Code of Conduct](#code-of-conduct)
-* [How to Contribute](#how-to-contribute)
-  * [Discuss](#discuss)
-  * [Create a Ticket](#create-a-ticket)
-  * [Ticket Lifecycle](#ticket-lifecycle)
-  * [Submit a Pull Request](#submit-a-pull-request)
-* [Build from Source](#build-from-source)
-* [Source Code Style](#source-code-style)
-* [Reference Docs](#reference-docs)
+## Take Your First Steps

-### Code of Conduct
+### Understand the basics

-This project is governed by the [Spring Code of Conduct](CODE_OF_CONDUCT.adoc).
-By participating you are expected to uphold this code.
-Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
+Not sure what a pull request is, or how to submit one? Take a look at GitHub's
+excellent [help documentation][] first.

-### How to Contribute
+### Search Stack Overflow first; discuss if necessary

-#### Discuss
+If you're unsure why something isn't working or wondering if there is a better
+way of doing it please check on Stack Overflow first and if necessary start
+a discussion. This is the official list of
+[Spring project tags](https://spring.io/questions). In short the issue tracker
+should be used to report issues and make feature requests.

-If you have a question, check StackOverflow using
-[this list of tags](https://spring.io/questions), organized by Spring project.
-Find an existing discussion or start a new one if necessary.
+### Search JIRA; create an issue if necessary

-If you suspect an issue, perform a search in the
-[GitHub issue tracker](https://github.com/spring-projects/spring-framework/issues), using a few different keywords.
-When you find related issues and discussions, prior or current, it helps you to learn and
-it helps us to make a decision.
+Is there already an issue that addresses your concern? Do a bit of searching
+in our [JIRA issue tracker][] to see if you can find something similar. If you
+do not find something similar, please create a new JIRA issue before submitting
+a pull request unless the change is truly trivial -- for example: typo fixes,
+removing compiler warnings, etc.

-#### Create a Ticket
+### Sign the Individual Contributor License Agreement (ICLA)

-Reporting an issue or making a feature request is a great way to contribute. Your feedback
-and the conversations that result from it provide a continuous flow of ideas. 
+If you have not previously done so, please fill out and submit the
+[Spring ICLA form][]. You'll receive a token when this process is complete.
+Keep track of this; you may be asked for it later!

-Before you create a ticket, please take the time to [research first](#discuss).
+Note that emailing/postal mailing a signed copy is _not_ necessary. Submission
+of the web form is all that is required.

-If creating a ticket after a discussion on StackOverflow, please provide a self-sufficient description in the ticket, independent of the details on StackOverflow. We understand this is extra work but the issue tracker is an important place of record for design discussions and decisions that can often be referenced long after the fix version, for example to revisit decisions, to understand the origin of a feature, and so on.
+Once you've completed the web form, simply add the following in a comment on
+your pull request:

-When ready create a ticket in the [GitHub issue tracker](https://github.com/spring-projects/spring-framework/issues).
+    I have signed and agree to the terms of the Spring Individual Contributor
+    License Agreement.

-#### Ticket Lifecycle
+You do not need to include your token/id. Please add the above statement to all
+future pull requests as well, simply so that the Spring Framework team knows
+immediately that this process is complete.

-When an issue is first created, it is flagged `waiting-for-triage` waiting for a team
-member to triage it. Within a day or two, the issue will then be reviewed and the team
-may ask for further information if needed. Based on the findings, the issue is either
-assigned a fix version or declined.
+## Create a Branch

-When a fix is ready, the issue is closed and may still be re-opened. Once a fix is
-released, the issue can't be reopened. If necessary, you will need to create a new,
-related ticket with a fresh description.
+### Branch from `master`

-#### Submit a Pull Request
+Master currently represents work toward Spring Framework 4.0. Please submit
+all pull requests there, even bug fixes and minor improvements. Backports to
+`3.2.x` will be considered on a case-by-case basis.

-You can contribute a source code change by submitting a pull request.

-1. If you have not previously done so, please sign the
-[Contributor License Agreement](https://cla.pivotal.io/sign/spring). You will also be reminded
-automatically when you submit a pull request.
+### Use short branch names

-1. Should you create a ticket first? The answer is no. Just create the pull request and use
-the description to provide context and motivation, as you would for an issue. If you want
-to start a discussion first or have already created an issue, once a pull request is created,
-we will close the issue as superseded by the pull request, and the discussion of the issue
-will continue under the pull request.
+Branches used when submitting pull requests should preferably be named
+according to JIRA issues, e.g. 'SPR-1234'. Otherwise, use succinct, lower-case,
+dash (-) delimited names, such as 'fix-warnings', 'fix-typo', etc. In
+[fork-and-edit][] cases, the GitHub default 'patch-1' is fine as well. This is
+important, because branch names show up in the merge commits that result from
+accepting pull requests and should be as expressive and concise as possible.

-1. Always check out the `master` branch and submit pull requests against it
-(for target version see [settings.gradle](settings.gradle)).
-Backports to prior versions will be considered on a case-by-case basis and reflected as
-the fix version in the issue tracker.
+## Use Spring Framework Code Style

-1. Use short branch names, preferably based on the GitHub issue (e.g. `22276`), or
-otherwise using succinct, lower-case, dash (-) delimited names, such as `fix-warnings`.
+The complete [Spring Framework Code Style][] reference is available on the wiki, but
+here's a quick summary:

-1. Choose the granularity of your commits consciously and squash commits that represent
-multiple edits or corrections of the same logical change. See
-[Rewriting History section of Pro Git](https://git-scm.com/book/en/Git-Tools-Rewriting-History)
-for an overview of streamlining commit history.
+### Mind the whitespace

-1. Format commit messages using 55 characters for the subject line, 72 characters per line
-for the description, followed by the issue fixed, e.g. `Closes gh-22276`. See the
-[Commit Guidelines section of Pro Git](https://git-scm.com/book/en/Distributed-Git-Contributing-to-a-Project#Commit-Guidelines)
-for best practices around commit messages and use `git log` to see some examples.
+Please carefully follow the whitespace and formatting conventions already
+present in the framework.

-1. List the GitHub issue number in the PR description.
+1. Tabs, not spaces
+1. Unix (LF), not DOS (CRLF) line endings
+1. Eliminate all trailing whitespace
+1. Wrap Javadoc at 90 characters
+1. Aim to wrap code at 90 characters, but favor readability over wrapping
+1. Preserve existing formatting; i.e. do not reformat code for its own sake
+1. Search the codebase using `git grep` and other tools to discover common
+    naming conventions, etc.
+1. UTF-8 encoding for Java sources

-If accepted, your contribution may be heavily modified as needed prior to merging.
-You will likely retain author attribution for your Git commits granted that the bulk of
-your changes remain intact. You may also be asked to rework the submission.

-If asked to make corrections, simply push the changes against the same branch, and your
-pull request will be updated. In other words, you do not need to create a new pull request
-when asked to make changes.
+### Add Apache license header to all new classes

-#### Participate in Reviews
+```java
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */

-Helping to review pull requests is another great way to contribute. Your feedback
-can help to shape the implementation of new features. When reviewing pull requests,
-however, please refrain from approving or rejecting a PR unless you are a core
-committer for the Spring Framework.
+package ...;
+```

-### Build from Source
+### Update Apache license header in modified files as necessary

-See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source)
-wiki page for instructions on how to check out, build, and import the Spring Framework
-source code into your IDE.
+Always check the date range in the license header. For example, if you've
+modified a file in 2015 whose header still reads:

-### Source Code Style
+```java
+/*
+ * Copyright 2002-2011 the original author or authors.
+```

-The wiki pages
-[Code Style](https://github.com/spring-projects/spring-framework/wiki/Code-Style) and
-[IntelliJ IDEA Editor Settings](https://github.com/spring-projects/spring-framework/wiki/IntelliJ-IDEA-Editor-Settings)
-defines the source file coding standards we use along with some IDEA editor settings we customize.
+Then be sure to update it to 2016 accordingly:

-### Reference Docs
+```java
+/*
+ * Copyright 2002-2016 the original author or authors.
+```

-The reference documentation is in the [src/docs/asciidoc](src/docs/asciidoc) directory and, in
-[Asciidoctor](https://asciidoctor.org/) format. For trivial changes, you may be able to browse,
-edit source files, and submit directly from GitHub.
+### Use @since tags for newly-added public API types and methods

-When making changes locally, use `./gradlew asciidoctor` and then browse the result under
-`build/asciidoc/html5/index.html`.
+For example:

-Asciidoctor also supports live editing. For more details read
-[Editing AsciiDoc with Live Preview](https://asciidoctor.org/docs/editing-asciidoc-with-live-preview/).
-Note that if you choose the
-[System Monitor](https://asciidoctor.org/docs/editing-asciidoc-with-live-preview/#using-a-system-monitor)
-option, you can find a Guardfile under `src/docs/asciidoc`.
+```java
+/**
+ * ...
+ *
+ * @author First Last
+ * @since 4.2.3
+ * @see ...
+ */
+```
+
+## Prepare Your Commit
+
+### Submit JUnit test cases for all behavior changes
+
+Search the codebase to find related tests and add additional `@Test` methods
+as appropriate. It is also acceptable to submit test cases on a per JIRA issue
+basis, for example:
+
+```java
+package org.springframework.beans.factory.support;
+
+/**
+ * Unit tests for SPR-8954, in which a custom {@link InstantiationAwareBeanPostProcessor}
+ * forces the predicted type of a FactoryBean, effectively preventing retrieval of the
+ * bean from calls to #getBeansOfType(FactoryBean.class). The implementation of
+ * {@link AbstractBeanFactory#isFactoryBean(String, RootBeanDefinition)} now ensures
+ * that not only the predicted bean type is considered, but also the original bean
+ * definition's beanClass.
+ *
+ * @author Chris Beams
+ */
+public class Spr8954Tests {
+
+    @Test
+    public void cornerSpr8954() {
+        // ...
+    }
+}
+```
+
+
+### Squash commits
+
+Use `git rebase --interactive --autosquash`, `git add --patch`, and other tools
+to "squash" multiple commits into a single atomic commit. In addition to the man
+pages for git, there are many resources online to help you understand how these
+tools work. The [Rewriting History section of Pro Git][] provides a good overview.
+
+
+### Use real name in git commits
+
+Please configure git to use your real first and last name for any commits you
+intend to submit as pull requests. For example, this is not acceptable:
+
+    Author: Nickname <user@mail.com>
+
+Rather, please include your first and last name, properly capitalized, as
+submitted against the Spring Individual Contributor License Agreement (ICLA):
+
+    Author: First Last <user@mail.com>
+
+This helps ensure traceability against the ICLA and also goes a long way to
+ensuring useful output from tools like `git shortlog` and others.
+
+You can configure this via the account admin area in GitHub (useful for
+fork-and-edit cases); _globally_ on your machine with
+
+    git config --global user.name "First Last"
+    git config --global user.email user@mail.com
+
+or _locally_ for the `spring-framework` repository only by omitting the
+'--global' flag:
+
+    cd spring-framework
+    git config user.name "First Last"
+    git config user.email user@mail.com
+
+
+### Format commit messages
+
+Please read and follow the [Commit Guidelines section of Pro Git][].
+
+Most importantly, please format your commit messages in the following way
+(adapted from the commit template in the link above):
+
+    Short (50 chars or less) summary of changes
+
+    More detailed explanatory text, if necessary. Wrap it to about 72
+    characters or so. In some contexts, the first line is treated as the
+    subject of an email and the rest of the text as the body. The blank
+    line separating the summary from the body is critical (unless you omit
+    the body entirely); tools like rebase can get confused if you run the
+    two together.
+
+    Further paragraphs come after blank lines.
+
+     - Bullet points are okay, too
+
+     - Typically a hyphen or asterisk is used for the bullet, preceded by a
+       single space, with blank lines in between, but conventions vary here
+
+    Issue: SPR-1234, SPR-1235
+
+
+1. Use imperative statements in the subject line, e.g. "Fix broken Javadoc link".
+1. Begin the subject line with a capitalized verb, e.g. "Add, Prune, Fix,
+    Introduce, Avoid, etc."
+1. Do not end the subject line with a period.
+1. Restrict the subject line to 50 characters or less if possible.
+1. Wrap lines in the body at 72 characters or less.
+1. Mention associated JIRA issue(s) at the end of the commit comment, prefixed
+    with "Issue: " as above.
+1. In the body of the commit message, explain how things worked before this
+    commit, what has changed, and how things work now.
+
+For examples of this style, issue a `git log --author=cbeams` in the
+`spring-framework` git repository. For convenience, here are several such commits:
+
+- https://github.com/spring-projects/spring-framework/commit/08e2669b84ec0faa2f7904441fe39ac70b65b078
+- https://github.com/spring-projects/spring-framework/commit/1d9d3e6ff79ce9f0eca03b02cd1df705925575da
+- https://github.com/spring-projects/spring-framework/commit/8e0b1c3a5f957af3049cfa0438317177e16d6de6
+- https://github.com/spring-projects/spring-framework/commit/b787a68f2050df179f7036b209aa741230a02477
+
+## Run the Final Checklist
+
+### Run all tests prior to submission
+
+See the [building from source][] section of the `README` for instructions. Make
+sure that all tests pass prior to submitting your pull request.
+
+
+### Submit your pull request
+
+Subject line:
+
+Follow the same conventions for pull request subject lines as mentioned above
+for commit message subject lines.
+
+In the body:
+
+1. Explain your use case. What led you to submit this change? Why were existing
+    mechanisms in the framework insufficient? Make a case that this is a
+    general-purpose problem and that yours is a general-purpose solution, etc.
+1. Add any additional information and ask questions; start a conversation or
+    continue one from JIRA.
+1. Mention the JIRA issue ID.
+1. Also mention that you have submitted the ICLA as described above.
+
+Note that for pull requests containing a single commit, GitHub will default the
+subject line and body of the pull request to match the subject line and body of
+the commit message. This is fine, but please also include the items above in the
+body of the request.
+
+
+### Mention your pull request on the associated JIRA issue
+
+Add a comment to the associated JIRA issue(s) linking to your new pull request.
+
+
+### Expect discussion and rework
+
+The Spring team takes a very conservative approach to accepting contributions to
+the framework. This is to keep code quality and stability as high as possible,
+and to keep complexity at a minimum. Your changes, if accepted, may be heavily
+modified prior to merging. You will retain "Author:" attribution for your Git
+commits granted that the bulk of your changes remain intact. You may be asked to
+rework the submission for style (as explained above) and/or substance. Again, we
+strongly recommend discussing any serious submissions with the Spring Framework 
+team _prior_ to engaging in serious development work.
+
+Note that you can always force push (`git push -f`) reworked / rebased commits
+against the branch used to submit your pull request. In other words, you do not
+need to issue a new pull request when asked to make changes.
+
+[help documentation]: https://help.github.com/send-pull-requests
+[JIRA issue tracker]: https://jira.spring.io/browse/SPR
+[spring-framework-contrib]: https://groups.google.com/forum/#!forum/spring-framework-contrib
+[Spring ICLA form]: https://support.springsource.com/spring_committer_signup
+[fork-and-edit]: https://github.com/blog/844-forking-with-the-edit-button
+[Spring Framework Code Style]: https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Code-Style
+[Rewriting History section of Pro Git]: https://git-scm.com/book/en/Git-Tools-Rewriting-History
+[Commit Guidelines section of Pro Git]: https://git-scm.com/book/en/Distributed-Git-Contributing-to-a-Project#Commit-Guidelines
+[building from source]: https://github.com/spring-projects/spring-framework#building-from-source
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        https://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       https://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
@@ -1,30 +1,102 @@
-# <img src="src/docs/asciidoc/images/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://build.spring.io/plugins/servlet/wittified/build-status/SPR-PUBM)](https://build.spring.io/browse/SPR)
+## Spring Framework
+The Spring Framework provides a comprehensive programming and configuration
+model for modern Java-based enterprise applications -- on any kind of deployment
+platform. A key element of Spring is infrastructural support at the application
+level: Spring focuses on the "plumbing" of enterprise applications so that teams
+can focus on application-level business logic, without unnecessary ties to
+specific deployment environments.

-This is the home of the Spring Framework: the foundation for all [Spring projects](https://spring.io/projects). Collectively the Spring Framework and the family of Spring projects is often referred to simply as "Spring". 
-
-Spring provides everything required beyond the Java programming language for creating enterprise applications for a wide range of scenarios and architectures. Please read the [Overview](https://docs.spring.io/spring/docs/current/spring-framework-reference/overview.html#spring-introduction) section as reference for a more complete introduction.
+The framework also serves as the foundation for [Spring Integration][], [Spring Batch][]
+and the rest of the Spring [family of projects][]. Browse the repositories under
+the [Spring organization][] on GitHub for a full list.

 ## Code of Conduct
+This project adheres to the Contributor Covenant [code of conduct](CODE_OF_CONDUCT.adoc).
+By participating, you  are expected to uphold this code. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.

-This project is governed by the [Spring Code of Conduct](CODE_OF_CONDUCT.adoc). By participating, you are expected to uphold this code of conduct. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
-
-## Access to Binaries
-
-For access to artifacts or a distribution zip, see the [Spring Framework Artifacts](https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Artifacts) wiki page.
+## Downloading Artifacts
+See [downloading Spring artifacts][] for Maven repository information. Unable to
+use Maven or other transitive dependency management tools?
+See [building a distribution with dependencies][].

 ## Documentation
+See the current [Javadoc][] and [reference docs][].

-The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/) and [source](src/docs/asciidoc)), Github [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
-[API reference](https://docs.spring.io/spring-framework/docs/current/javadoc-api/). There are also [guides and tutorials](https://spring.io/guides) across Spring projects.
+## Getting Support
+Check out the [spring][spring tags] tags on [Stack Overflow][]. [Commercial support][]
+is available too.

-## Build from Source
+## Issue Tracking
+Report issues via the [Spring Framework JIRA][]. Understand our issue management
+process by reading about [the lifecycle of an issue][]. Think you've found a
+bug? Please consider submitting a reproduction project via the
+[spring-framework-issues][] GitHub repository. The [readme][] there provides
+simple step-by-step instructions.

-See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source) Wiki page and the [CONTRIBUTING.md](CONTRIBUTING.md) file.
+## Building from Source
+The Spring Framework uses a [Gradle][]-based build system. In the instructions
+below, [`./gradlew`][] is invoked from the root of the source tree and serves as
+a cross-platform, self-contained bootstrap mechanism for the build.

-## Stay in Touch
+### Prerequisites

-Follow [@SpringCentral](https://twitter.com/springcentral), [@SpringFramework](https://twitter.com/springframework), and its [team members](https://twitter.com/springframework/lists/team/members) on Twitter. In-depth articles can be found at [The Spring Blog](https://spring.io/blog/), and releases are announced via our [news feed](https://spring.io/blog/category/news).
+[Git][] and [JDK 8 update 20 or later][JDK8 build]
+
+Be sure that your `JAVA_HOME` environment variable points to the `jdk1.8.0` folder
+extracted from the JDK download.
+
+### Check out sources
+`git clone git@github.com:spring-projects/spring-framework.git`
+
+### Import sources into your IDE
+Run `./import-into-eclipse.sh` or read `import-into-idea.md` as appropriate.
+> **Note:** Per the prerequisites above, ensure that you have JDK 8 configured properly in your IDE.
+
+### Install all spring-\* jars into your local Maven cache
+`./gradlew install`
+
+### Compile and test; build all jars, distribution zips, and docs
+`./gradlew build`
+
+... and discover more commands with `./gradlew tasks`. See also the [Gradle
+build and release FAQ][].
+
+## Contributing
+[Pull requests][] are welcome; see the [contributor guidelines][] for details.
+
+## Staying in Touch
+Follow [@SpringCentral][] as well as [@SpringFramework][] and its [team members][]
+on Twitter. In-depth articles can be found at [The Spring Blog][], and releases
+are announced via our [news feed][].

 ## License
+The Spring Framework is released under version 2.0 of the [Apache License][].

-The Spring Framework is released under version 2.0 of the [Apache License](https://www.apache.org/licenses/LICENSE-2.0).
+[Spring Integration]: https://github.com/spring-projects/spring-integration
+[Spring Batch]: https://github.com/spring-projects/spring-batch
+[family of projects]: https://spring.io/projects
+[Spring organization]: https://github.com/spring-projects
+[downloading Spring artifacts]: https://github.com/spring-projects/spring-framework/wiki/Downloading-Spring-artifacts
+[building a distribution with dependencies]: https://github.com/spring-projects/spring-framework/wiki/Building-a-distribution-with-dependencies
+[Javadoc]: https://docs.spring.io/spring-framework/docs/current/javadoc-api/
+[reference docs]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/
+[spring tags]: https://spring.io/questions
+[Stack Overflow]: https://stackoverflow.com/faq
+[Commercial support]: https://spring.io/services
+[Spring Framework JIRA]: https://jira.spring.io/browse/SPR
+[the lifecycle of an issue]: https://github.com/spring-projects/spring-framework/wiki/The-Lifecycle-of-an-Issue
+[spring-framework-issues]: https://github.com/spring-projects/spring-framework-issues#readme
+[readme]: https://github.com/spring-projects/spring-framework-issues#readme
+[Gradle]: https://gradle.org
+[`./gradlew`]: https://vimeo.com/34436402
+[Git]: https://help.github.com/set-up-git-redirect
+[JDK8 build]: https://www.oracle.com/technetwork/java/javase/downloads
+[Gradle build and release FAQ]: https://github.com/spring-projects/spring-framework/wiki/Gradle-build-and-release-FAQ
+[Pull requests]: https://help.github.com/send-pull-requests
+[contributor guidelines]: https://github.com/spring-projects/spring-framework/blob/master/CONTRIBUTING.md
+[@SpringFramework]: https://twitter.com/springframework
+[@SpringCentral]: https://twitter.com/springcentral
+[team members]: https://twitter.com/springframework/lists/team/members
+[The Spring Blog]: https://spring.io/blog/
+[news feed]: https://spring.io/blog/category/news
+[Apache License]: https://www.apache.org/licenses/LICENSE-2.0
@@ -1,11 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Please see the
-[Spring Framework Versions](https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Versions)
-wiki page.
-
-## Reporting a Vulnerability
-
-Please see https://pivotal.io/security.
@@ -1,47 +0,0 @@
-# Spring Framework build
-
-This folder contains the custom plugins and conventions for the Spring Framework build.
-They are declared in the `build.gradle` file in this folder.
-
-## Build Conventions
-
-### Compiler conventions
-
-The `org.springframework.build.compile` applies the Java compiler conventions to the build.
-By default, the build is compiling sources with the `1.8` source and target compatibility.
-You can test a different source compatibility version on the CLI with a project property like:
-
-```
-./gradlew test -PjavaSourceVersion=11
-```
-
-## Build Plugins
-
-## Optional dependencies
-
-The `org.springframework.build.optional-dependencies` plugin creates a new `optional`
-Gradle configuration - it adds the dependencies to the project's compile and runtime classpath
-but doesn't affect the classpath of dependent projects.
-This plugin does not provide a `provided` configuration, as the native `compileOnly` and `testCompileOnly`
-configurations are preferred.
-
-## Test sources
-
-The `org.springframework.build.test-sources` updates `testCompile` dependencies to include
-the test source sets of `project()` dependencies. This plugin is used in the Spring Framework build 
-to share test utilities and fixtures amongst modules.
-
-## API Diff
-
-This plugin uses the [Gradle JApiCmp](https://github.com/melix/japicmp-gradle-plugin) plugin
-to generate API Diff reports for each Spring Framework module. This plugin is applied once on the root
-project and create tasks in each framework module. Unlike previous versions of this part of the build,
-there is no need for checking out a specific tag. The plugin will fetch the JARs we want to compare the
-current working version with. You can generate the reports for all modules or a single module:
-
-```
-./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE
-./gradlew :spring-core:apiDiff -PbaselineVersion=5.1.0.RELEASE
-```      
-
-The reports are located under `build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/`.
@@ -1,34 +0,0 @@
-plugins {
-	id 'java-gradle-plugin'
-}
-
-repositories {
-	mavenCentral()
-	gradlePluginPortal()
-}
-
-dependencies {
-	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.2.8"
-	implementation "com.google.guava:guava:18.0" // required by japicmp-gradle-plugin
-}
-
-gradlePlugin {
-	plugins {
-		apiDiffPlugin {
-			id = "org.springframework.build.api-diff"
-			implementationClass = "org.springframework.build.api.ApiDiffPlugin"
-		}
-		compileConventionsPlugin {
-			id = "org.springframework.build.compile"
-			implementationClass = "org.springframework.build.compile.CompilerConventionsPlugin"
-		}
-		optionalDependenciesPlugin {
-			id = "org.springframework.build.optional-dependencies"
-			implementationClass = "org.springframework.build.optional.OptionalDependenciesPlugin"
-		}
-		testSourcesPlugin {
-			id = "org.springframework.build.test-sources"
-			implementationClass = "org.springframework.build.testsources.TestSourcesPlugin"
-		}
-	}
-}
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.TaskAction
+
+
+/**
+ * Gradle plugin that detects identically named, non-empty packages split across multiple
+ * subprojects, e.g. "org.springframework.context.annotation" existing in both spring-core
+ * and spring-aspects. Adds a 'detectSplitPackages' task to the current project's task
+ * collection. If the project already contains a 'check' task (i.e. is a typical Gradle
+ * project with the "java" plugin applied), the 'check' task will be updated to depend on
+ * the execution of 'detectSplitPackages'.
+ *
+ * By default, all subprojects will be scanned. Use the 'projectsToScan' task property to
+ * modify this value. Example usage:
+ *
+ *     apply plugin: 'detect-split-packages // typically applied to root project
+ *
+ *     detectSplitPackages {
+ *         packagesToScan -= project(":spring-xyz") // scan every project but spring-xyz
+ *     }
+ *
+ * @author Rob Winch
+ * @author Glyn Normington
+ * @author Chris Beams
+ */
+public class DetectSplitPackagesPlugin implements Plugin<Project> {
+	public void apply(Project project) {
+		def tasks = project.tasks
+		Task detectSplitPackages = tasks.create("detectSplitPackages", DetectSplitPackagesTask.class)
+		if (tasks.asMap.containsKey("check")) {
+			tasks.getByName("check").dependsOn detectSplitPackages
+		}
+	}
+}
+
+public class DetectSplitPackagesTask extends DefaultTask {
+
+	private static final String JAVA_FILE_SUFFIX = ".java"
+	private static final String PACKAGE_SEPARATOR = "."
+	private static final String HIDDEN_DIRECTORY_PREFIX = "."
+
+	@Input
+	Set<Project> projectsToScan = project.subprojects
+
+	public DetectSplitPackagesTask() {
+		this.group = "Verification"
+		this.description = "Detects packages split across two or more subprojects."
+	}
+
+	@TaskAction
+	public void detectSplitPackages() {
+		def splitPackages = doDetectSplitPackages()
+		if (!splitPackages.isEmpty()) {
+			def message = "The following split package(s) have been detected:\n"
+			splitPackages.each { pkg, mod ->
+				message += " - ${pkg} (split across ${mod[0].name} and ${mod[1].name})\n"
+			}
+			throw new GradleException(message)
+		}
+	}
+
+	private Map<String, List<Project>> doDetectSplitPackages() {
+		def splitPackages = [:]
+		def mergedProjects = findMergedProjects()
+		def packagesByProject = mapPackagesByProject()
+
+		def projects = packagesByProject.keySet().toArray()
+		def nProjects = projects.length
+
+		for (int i = 0; i < nProjects - 1; i++) {
+			for (int j = i + 1; j < nProjects - 1; j++) {
+				def prj_i = projects[i]
+				def prj_j = projects[j]
+
+				def pkgs_i = new HashSet(packagesByProject.get(prj_i))
+				def pkgs_j = packagesByProject.get(prj_j)
+				pkgs_i.retainAll(pkgs_j)
+
+				if (!pkgs_i.isEmpty()
+						&& mergedProjects.get(prj_i) != prj_j
+						&& mergedProjects.get(prj_j) != prj_i) {
+					pkgs_i.each { pkg ->
+						def readablePkg = pkg.substring(1).replaceAll(File.separator, PACKAGE_SEPARATOR)
+						splitPackages[readablePkg] = [prj_i, prj_j]
+					}
+				}
+			}
+		}
+		return splitPackages;
+	}
+
+	private Map<Project, Set<String>> mapPackagesByProject() {
+		def packagesByProject = [:]
+		this.projectsToScan.each { Project p ->
+			def packages = new HashSet<String>()
+			p.sourceSets.main.java.srcDirs.each { File dir ->
+				findPackages(packages, dir, "")
+			}
+			if (!packages.isEmpty()) {
+				packagesByProject.put(p, packages)
+			}
+		}
+		return packagesByProject;
+	}
+
+	private Map<Project, Project> findMergedProjects() {
+		def mergedProjects = [:]
+		this.projectsToScan.findAll { p ->
+			p.plugins.findPlugin(MergePlugin)
+		}.findAll { p ->
+			p.merge.into
+		}.each { p ->
+			mergedProjects.put(p, p.merge.into)
+		}
+		return mergedProjects
+	}
+
+	private static void findPackages(Set<String> packages, File dir, String packagePath) {
+		def scanDir = new File(dir, packagePath)
+		def File[] javaFiles = scanDir.listFiles({ file ->
+			!file.isDirectory() && file.name.endsWith(JAVA_FILE_SUFFIX)
+		} as FileFilter)
+
+		if (javaFiles != null && javaFiles.length != 0) {
+			packages.add(packagePath)
+		}
+
+		scanDir.listFiles({ File file ->
+			file.isDirectory() && !file.name.startsWith(HIDDEN_DIRECTORY_PREFIX)
+		} as FileFilter).each { File subDir ->
+			findPackages(packages, dir, packagePath + File.separator + subDir.name)
+		}
+	}
+}
+
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2002-2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.*
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.ProjectDependency;
+import org.gradle.api.artifacts.maven.Conf2ScopeMapping
+import org.gradle.api.plugins.MavenPlugin
+import org.gradle.plugins.ide.eclipse.EclipsePlugin
+import org.gradle.plugins.ide.idea.IdeaPlugin
+import org.gradle.api.invocation.*
+
+/**
+ * Gradle plugin that allows projects to merged together. Primarily developed to
+ * allow Spring to support multiple incompatible versions of third-party
+ * dependencies (for example Hibernate v3 and v4).
+ * <p>
+ * The 'merge' extension should be used to define how projects are merged, for example:
+ * <pre class="code">
+ * configure(subprojects) {
+ *     apply plugin: MergePlugin
+ * }
+ *
+ * project("myproject") {
+ * }
+ *
+ * project("myproject-extra") {
+ *     merge.into = project("myproject")
+ * }
+ * </pre>
+ * <p>
+ * This plugin adds two new configurations:
+ * <ul>
+ * <li>merging - Contains the projects being merged into this project<li>
+ * <li>runtimeMerge - Contains all dependencies that are merge projects. These are used
+ * to allow an IDE to reference merge projects.</li>
+ * <ul>
+ *
+ * @author Rob Winch
+ * @author Phillip Webb
+ */
+class MergePlugin implements Plugin<Project> {
+
+	private static boolean attachedProjectsEvaluated;
+
+	public void apply(Project project) {
+		project.plugins.apply(MavenPlugin)
+		project.plugins.apply(EclipsePlugin)
+		project.plugins.apply(IdeaPlugin)
+
+		MergeModel model = project.extensions.create("merge", MergeModel)
+		project.configurations.create("merging")
+		Configuration runtimeMerge = project.configurations.create("runtimeMerge")
+
+		// Ensure the IDE can reference merged projects
+		project.eclipse.classpath.plusConfigurations += [ runtimeMerge ]
+		project.idea.module.scopes.PROVIDED.plus += [ runtimeMerge ]
+
+		// Hook to perform the actual merge logic
+		project.afterEvaluate{
+			if (it.merge.into != null) {
+				setup(it)
+			}
+		}
+
+		// Hook to build runtimeMerge dependencies
+		if (!attachedProjectsEvaluated) {
+			project.gradle.projectsEvaluated{
+				postProcessProjects(it)
+			}
+			attachedProjectsEvaluated  = true;
+		}
+	}
+
+	private void setup(Project project) {
+		project.merge.into.dependencies.add("merging", project)
+		project.dependencies.add("provided", project.merge.into.sourceSets.main.output)
+		project.dependencies.add("runtimeMerge", project.merge.into)
+		setupTaskDependencies(project)
+		setupMaven(project)
+	}
+
+	private void setupTaskDependencies(Project project) {
+		// invoking a task will invoke the task with the same name on 'into' project
+		["sourcesJar", "jar", "javadocJar", "javadoc", "install", "artifactoryPublish"].each {
+			def task = project.tasks.findByPath(it)
+			if (task) {
+				task.enabled = false
+				task.dependsOn(project.merge.into.tasks.findByPath(it))
+			}
+		}
+
+		// update 'into' project artifacts to contain the source artifact contents
+		project.merge.into.sourcesJar.from(project.sourcesJar.source)
+		project.merge.into.jar.from(project.sourceSets.main.output)
+		project.merge.into.javadoc {
+			source += project.javadoc.source
+			classpath += project.javadoc.classpath
+		}
+	}
+
+	private void setupMaven(Project project) {
+		project.configurations.each { configuration ->
+			Conf2ScopeMapping mapping = project.conf2ScopeMappings.getMapping([configuration])
+			if (mapping.scope) {
+				Configuration intoConfiguration = project.merge.into.configurations.create(
+					project.name + "-" + configuration.name)
+				configuration.excludeRules.each {
+					configuration.exclude([
+						(ExcludeRule.GROUP_KEY) : it.group,
+						(ExcludeRule.MODULE_KEY) : it.module])
+				}
+				configuration.dependencies.each {
+					def intoCompile = project.merge.into.configurations.getByName("compile")
+					// Protect against changing a compile scope dependency (SPR-10218)
+					if (!intoCompile.dependencies.contains(it)) {
+						intoConfiguration.dependencies.add(it)
+					}
+				}
+				def index = project.parent.childProjects.findIndexOf {p -> p.getValue() == project}
+				project.merge.into.install.repositories.mavenInstaller.pom.scopeMappings.addMapping(
+					mapping.priority + 100 + index, intoConfiguration, mapping.scope)
+			}
+		}
+	}
+
+	private postProcessProjects(Gradle gradle) {
+		gradle.allprojects(new Action<Project>() {
+			public void execute(Project project) {
+				project.configurations.getByName("runtime").allDependencies.withType(ProjectDependency).each{
+					Configuration dependsOnMergedFrom = it.dependencyProject.configurations.getByName("merging");
+					dependsOnMergedFrom.dependencies.each{ dep ->
+						project.dependencies.add("runtimeMerge", dep.dependencyProject)
+					}
+				}
+			}
+		});
+	}
+}
+
+class MergeModel {
+	Project into;
+}
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2002-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ProjectDependency;
+
+/**
+ * Gradle plugin that automatically updates testCompile dependencies to include
+ * the test source sets of project dependencies.
+ *
+ * @author Phillip Webb
+ */
+class TestSourceSetDependenciesPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.afterEvaluate {
+			Set<ProjectDependency> projectDependencies = new LinkedHashSet<ProjectDependency>()
+			collectProjectDependencies(projectDependencies, project)
+			projectDependencies.each {
+				project.dependencies.add("testCompile", it.dependencyProject.sourceSets.test.output)
+			}
+		}
+	}
+
+	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies, Project project) {
+		for (def configurationName in ["compile", "optional", "provided", "testCompile"]) {
+			Configuration configuration = project.getConfigurations().findByName(configurationName)
+			if (configuration) {
+				configuration.dependencies.findAll { it instanceof ProjectDependency }.each {
+					projectDependencies.add(it)
+					collectProjectDependencies(projectDependencies, it.dependencyProject)
+				}
+			}
+		}
+	}
+
+}
@@ -1,115 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.build.api;
-
-import java.io.File;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Collections;
-import java.util.List;
-
-import me.champeau.gradle.japicmp.JapicmpPlugin;
-import me.champeau.gradle.japicmp.JapicmpTask;
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
-import org.gradle.api.tasks.TaskProvider;
-import org.gradle.jvm.tasks.Jar;
-
-/**
- * {@link Plugin} that applies the {@code "japicmp-gradle-plugin"}
- * and create tasks for all subprojects, diffing the public API one by one
- * and creating the reports in {@code "build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/"}.
- * <p>{@code "./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE"} will output the
- * reports for the API diff between the baseline version and the current one for all modules.
- * You can limit the report to a single module with
- * {@code "./gradlew :spring-core:apiDiff -PbaselineVersion=5.1.0.RELEASE"}.
- *
- * @author Brian Clozel
- */
-public class ApiDiffPlugin implements Plugin<Project> {
-
-	public static final String TASK_NAME = "apiDiff";
-
-	private static final String BASELINE_VERSION_PROPERTY = "baselineVersion";
-
-	private static final List<String> PACKAGE_INCLUDES = Collections.singletonList("org.springframework.*");
-
-	@Override
-	public void apply(Project project) {
-		if (project.hasProperty(BASELINE_VERSION_PROPERTY) && project.equals(project.getRootProject())) {
-			project.getPluginManager().apply(JapicmpPlugin.class);
-			project.getPlugins().withType(JapicmpPlugin.class,
-					plugin -> applyApiDiffConventions(project));
-		}
-	}
-
-	private void applyApiDiffConventions(Project project) {
-		String baselineVersion = project.property(BASELINE_VERSION_PROPERTY).toString();
-		project.subprojects(subProject -> createApiDiffTask(baselineVersion, subProject));
-	}
-
-	private void createApiDiffTask(String baselineVersion, Project project) {
-		if (isProjectEligible(project)) {
-			JapicmpTask apiDiff = project.getTasks().create(TASK_NAME, JapicmpTask.class);
-			apiDiff.setDescription("Generates an API diff report with japicmp");
-			apiDiff.setGroup(JavaBasePlugin.DOCUMENTATION_GROUP);
-
-			apiDiff.setOldClasspath(project.files(createBaselineConfiguration(baselineVersion, project)));
-			TaskProvider<Jar> jar = project.getTasks().withType(Jar.class).named("jar");
-			apiDiff.setNewArchives(project.getLayout().files(jar.get().getArchiveFile().get().getAsFile()));
-			apiDiff.setNewClasspath(getRuntimeClassPath(project));
-			apiDiff.setPackageIncludes(PACKAGE_INCLUDES);
-			apiDiff.setOnlyModified(true);
-			apiDiff.setIgnoreMissingClasses(true);
-			// Ignore Kotlin metadata annotations since they contain
-			// illegal HTML characters and fail the report generation
-			apiDiff.setAnnotationExcludes(Collections.singletonList("@kotlin.Metadata"));
-
-			apiDiff.setHtmlOutputFile(getOutputFile(baselineVersion, project));
-
-			apiDiff.dependsOn(project.getTasks().getByName("jar"));
-		}
-	}
-
-	private boolean isProjectEligible(Project project) {
-		return project.getPlugins().hasPlugin(JavaPlugin.class)
-				&& project.getPlugins().hasPlugin(MavenPublishPlugin.class);
-	}
-
-	private Configuration createBaselineConfiguration(String baselineVersion, Project project) {
-		String baseline = String.join(":",
-				project.getGroup().toString(), project.getName(), baselineVersion);
-		Dependency baselineDependency = project.getDependencies().create(baseline + "@jar");
-		return project.getRootProject().getConfigurations().detachedConfiguration(baselineDependency);
-	}
-
-	private Configuration getRuntimeClassPath(Project project) {
-		return project.getConfigurations().getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME);
-	}
-
-	private File getOutputFile(String baseLineVersion, Project project) {
-		Path outDir = Paths.get(project.getRootProject().getBuildDir().getAbsolutePath(),
-				"reports", "api-diff",
-				baseLineVersion + "_to_" + project.getRootProject().getVersion());
-		return project.file(outDir.resolve(project.getName() + ".html").toString());
-	}
-
-}
@@ -1,102 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.compile;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.gradle.api.JavaVersion;
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginConvention;
-import org.gradle.api.tasks.compile.JavaCompile;
-
-/**
- * {@link Plugin} that applies conventions for compiling Java sources in Spring Framework.
- * <p>One can override the default Java source compatibility version
- * with a dedicated property on the CLI: {@code "./gradlew test -PjavaSourceVersion=11"}.
- *
- * @author Brian Clozel
- */
-public class CompilerConventionsPlugin implements Plugin<Project> {
-
-	/**
-	 * The project property that can be used to switch the Java source
-	 * compatibility version for building source and test classes.
-	 */
-	public static String JAVA_SOURCE_VERSION_PROPERTY = "javaSourceVersion";
-
-	public static JavaVersion DEFAULT_COMPILER_VERSION = JavaVersion.VERSION_1_8;
-
-	private static List<String> COMPILER_ARGS;
-
-	private static List<String> TEST_COMPILER_ARGS;
-
-	static {
-		List<String> commonCompilerArgs = Arrays.asList(
-				"-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
-				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
-				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options"
-		);
-		COMPILER_ARGS = new ArrayList<>();
-		COMPILER_ARGS.addAll(commonCompilerArgs);
-		COMPILER_ARGS.addAll(Arrays.asList(
-				"-Xlint:varargs", "-Xlint:fallthrough", "-Xlint:rawtypes", "-Xlint:deprecation",
-				"-Xlint:unchecked", "-Werror"
-		));
-		TEST_COMPILER_ARGS = new ArrayList<>();
-		TEST_COMPILER_ARGS.addAll(commonCompilerArgs);
-		TEST_COMPILER_ARGS.addAll(Arrays.asList("-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
-				"-Xlint:-deprecation", "-Xlint:-unchecked", "-parameters"));
-	}
-
-	@Override
-	public void apply(Project project) {
-		project.getPlugins().withType(JavaPlugin.class, javaPlugin -> applyJavaCompileConventions(project));
-	}
-
-	/**
-	 * Applies the common Java compiler options for sources and test sources.
-	 * @param project the current project
-	 */
-	private void applyJavaCompileConventions(Project project) {
-		JavaPluginConvention java = project.getConvention().getPlugin(JavaPluginConvention.class);
-		if (project.hasProperty(JAVA_SOURCE_VERSION_PROPERTY)) {
-			JavaVersion javaSourceVersion = JavaVersion.toVersion(project.property(JAVA_SOURCE_VERSION_PROPERTY));
-			java.setSourceCompatibility(javaSourceVersion);
-		}
-		else {
-			java.setSourceCompatibility(DEFAULT_COMPILER_VERSION);
-		}
-		java.setTargetCompatibility(DEFAULT_COMPILER_VERSION);
-
-		project.getTasks().withType(JavaCompile.class)
-				.matching(javaCompile -> javaCompile.getName().equals(JavaPlugin.COMPILE_JAVA_TASK_NAME))
-				.forEach(compileTask -> {
-					compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
-					compileTask.getOptions().setEncoding("UTF-8");
-				});
-		project.getTasks().withType(JavaCompile.class)
-				.matching(javaCompile -> javaCompile.getName().equals(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME))
-				.forEach(compileTask -> {
-					compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
-					compileTask.getOptions().setEncoding("UTF-8");
-				});
-	}
-}
@@ -1,64 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.optional;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginConvention;
-import org.gradle.api.tasks.SourceSetContainer;
-import org.gradle.plugins.ide.eclipse.EclipsePlugin;
-import org.gradle.plugins.ide.eclipse.model.EclipseModel;
-
-/**
- * A {@code Plugin} that adds support for Maven-style optional dependencies. Creates a new
- * {@code optional} configuration. The {@code optional} configuration is part of the
- * project's compile and runtime classpath's but does not affect the classpath of
- * dependent projects.
- *
- * @author Andy Wilkinson
- */
-public class OptionalDependenciesPlugin implements Plugin<Project> {
-
-	/**
-	 * Name of the {@code optional} configuration.
-	 */
-	public static final String OPTIONAL_CONFIGURATION_NAME = "optional";
-
-	@Override
-	public void apply(Project project) {
-		Configuration optional = project.getConfigurations().create("optional");
-		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> {
-			SourceSetContainer sourceSets = project.getConvention()
-					.getPlugin(JavaPluginConvention.class).getSourceSets();
-			sourceSets.all((sourceSet) -> {
-				sourceSet.setCompileClasspath(
-						sourceSet.getCompileClasspath().plus(optional));
-				sourceSet.setRuntimeClasspath(
-						sourceSet.getRuntimeClasspath().plus(optional));
-			});
-		});
-		project.getPlugins().withType(EclipsePlugin.class, (eclipePlugin) -> {
-			project.getExtensions().getByType(EclipseModel.class)
-					.classpath((classpath) -> {
-						classpath.getPlusConfigurations().add(optional);
-					});
-		});
-	}
-
-}
@@ -1,95 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.testsources;
-
-import java.util.Arrays;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.artifacts.ProjectDependency;
-import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginConvention;
-import org.gradle.api.tasks.SourceSet;
-import org.gradle.api.tasks.SourceSetOutput;
-
-import org.springframework.build.optional.OptionalDependenciesPlugin;
-
-/**
- * {@link Plugin} that automatically updates testCompile dependencies to include
- * the test source sets of {@code project()} dependencies.
- *
- * <p>This plugin is used in the Spring Framework build to share test utilities and fixtures
- * between projects.
- *
- * @author Phillip Webb
- * @author Brian Clozel
- */
-public class TestSourcesPlugin implements Plugin<Project> {
-
-	/**
-	 * List of configurations this plugin should look for project dependencies in.
-	 */
-	@SuppressWarnings("deprecation")
-	private static final List<String> CONFIGURATIONS = Arrays.asList(
-			JavaPlugin.COMPILE_CONFIGURATION_NAME,
-			JavaPlugin.API_CONFIGURATION_NAME,
-			JavaPlugin.IMPLEMENTATION_CONFIGURATION_NAME,
-			OptionalDependenciesPlugin.OPTIONAL_CONFIGURATION_NAME,
-			JavaPlugin.TEST_COMPILE_CONFIGURATION_NAME);
-
-	@Override
-	public void apply(Project project) {
-		project.getPlugins().withType(JavaPlugin.class, (plugin) -> addTestSourcesToProject(project));
-	}
-
-	private void addTestSourcesToProject(Project project) {
-		project.afterEvaluate(currentProject -> {
-			Set<ProjectDependency> projectDependencies = new LinkedHashSet<>();
-			collectProjectDependencies(projectDependencies, project);
-			projectDependencies.forEach(dep -> addTestSourcesFromDependency(currentProject, dep));
-		});
-	}
-
-	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies, Project project) {
-		for (String configurationName : CONFIGURATIONS) {
-			Configuration configuration = project.getConfigurations().findByName(configurationName);
-			if (configuration != null) {
-				configuration.getDependencies().forEach(dependency -> {
-					if (dependency instanceof ProjectDependency) {
-						ProjectDependency projectDependency = (ProjectDependency) dependency;
-						projectDependencies.add(projectDependency);
-						collectProjectDependencies(projectDependencies, projectDependency.getDependencyProject());
-					}
-				});
-			}
-		}
-	}
-
-	private void addTestSourcesFromDependency(final Project currentProject, ProjectDependency dependency) {
-		Project dependencyProject = dependency.getDependencyProject();
-		dependencyProject.getPlugins().withType(JavaPlugin.class, plugin -> {
-			final JavaPluginConvention javaPlugin = dependencyProject.getConvention()
-					.getPlugin(JavaPluginConvention.class);
-			SourceSetOutput test = javaPlugin.getSourceSets().findByName(SourceSet.TEST_SOURCE_SET_NAME).getOutput();
-			currentProject.getDependencies().add(JavaPlugin.TEST_COMPILE_CONFIGURATION_NAME, test);
-		});
-	}
-}
@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.DetectSplitPackagesPlugin
@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.MergePlugin
@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.TestSourceSetDependenciesPlugin
@@ -1,29 +0,0 @@
-description = "Spring Framework (Bill of Materials)"
-
-apply plugin: 'java-platform'
-apply from: "$rootDir/gradle/publications.gradle"
-
-group = "org.springframework"
-
-dependencies {
-	constraints {
-		parent.moduleProjects.sort { "$it.name" }.each {
-			api it
-		}
-	}
-}
-
-publishing {
-	publications {
-		mavenJava(MavenPublication) {
-			artifactId = 'spring-framework-bom'
-			from components.javaPlatform
-			// remove scope information from published BOM
-			pom.withXml {
-				asNode().dependencyManagement.first().dependencies.first().each {
-					it.remove(it.scope.first())
-				}
-			}
-		}
-	}
-}
@@ -1,4 +1 @@
-version=5.2.0.RELEASE
-org.gradle.jvmargs=-Xmx1536M
-org.gradle.caching=false
-org.gradle.parallel=true
+version=4.3.31.BUILD-SNAPSHOT
@@ -1,90 +0,0 @@
-tagOs()
-tagIde()
-tagCiOrLocal()
-addCiMetadata()
-addGitMetadata()
-addTestTaskMetadata()
-
-void tagOs() {
-	buildScan.tag System.getProperty('os.name')
-}
-
-void tagIde() {
-	if (System.getProperty('idea.version')) {
-		buildScan.tag 'IntelliJ IDEA'
-	} else if (System.getProperty('eclipse.buildId')) {
-		buildScan.tag 'Eclipse'
-	}
-}
-
-void tagCiOrLocal() {
-	buildScan.tag(isCi() ? 'CI' : 'LOCAL')
-}
-
-void addGitMetadata() {
-	buildScan.background {
-		def gitCommitId = execAndGetStdout('git', 'rev-parse', '--short=8', '--verify', 'HEAD')
-		def gitBranchName = execAndGetStdout('git', 'rev-parse', '--abbrev-ref', 'HEAD')
-		def gitStatus = execAndGetStdout('git', 'status', '--porcelain')
-
-		if(gitCommitId) {
-			def commitIdLabel = 'Git Commit ID'
-			value commitIdLabel, gitCommitId
-			link 'Git commit build scans', customValueSearchUrl([(commitIdLabel): gitCommitId])
-		}
-		if (gitBranchName) {
-			tag gitBranchName
-			value 'Git branch', gitBranchName
-		}
-		if (gitStatus) {
-			tag 'dirty'
-			value 'Git status', gitStatus
-		}
-	}
-}
-
-void addCiMetadata() {
-	def ciBuild = 'CI BUILD'
-	if (isBamboo()) {
-		buildScan.link ciBuild, System.getenv('bamboo_resultsUrl')
-	}
-}
-
-void addTestTaskMetadata() {
-	allprojects {
-		tasks.withType(Test) { test ->
-			doFirst {
-				buildScan.value "Test#maxParallelForks[${test.path}]", test.maxParallelForks.toString()
-			}
-		}
-	}
-}
-
-boolean isCi() {
-	isBamboo()
-}
-
-boolean isBamboo() {
-	System.getenv('bamboo_resultsUrl')
-}
-
-String execAndGetStdout(String... args) {
-	def stdout = new ByteArrayOutputStream()
-	exec {
-		commandLine(args)
-		standardOutput = stdout
-	}
-	return stdout.toString().trim()
-}
-
-String customValueSearchUrl(Map<String, String> search) {
-	def query = search.collect { name, value ->
-		"search.names=${encodeURL(name)}&search.values=${encodeURL(value)}"
-	}.join('&')
-
-	"$buildScan.server/scans?$query"
-}
-
-String encodeURL(String url) {
-	URLEncoder.encode(url, 'UTF-8')
-}
@@ -1,237 +0,0 @@
-/**
- * Produce Javadoc for all Spring Framework modules in "build/docs/javadoc"
- */
-task api(type: Javadoc) {
-	group = "Documentation"
-	description = "Generates aggregated Javadoc API documentation."
-	title = "${rootProject.description} ${version} API"
-
-	dependsOn {
-		moduleProjects.collect {
-			it.tasks.getByName("jar")
-		}
-	}
-	doFirst {
-		classpath = files(
-				// ensure the javadoc process can resolve types compiled from .aj sources
-				project(":spring-aspects").sourceSets.main.output
-		)
-		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
-	}
-
-	options {
-		encoding = "UTF-8"
-		memberLevel = JavadocMemberLevel.PROTECTED
-		author = true
-		header = rootProject.description
-		use = true
-		overview = "src/docs/api/overview.html"
-		stylesheetFile = file("src/docs/api/stylesheet.css")
-		splitIndex = true
-		links(project.ext.javadocLinks)
-		addStringOption('Xdoclint:none', '-quiet')
-		if(JavaVersion.current().isJava9Compatible()) {
-			addBooleanOption('html5', true)
-		}
-	}
-	source moduleProjects.collect { project ->
-		project.sourceSets.main.allJava
-	}
-	maxMemory = "1024m"
-	destinationDir = file("$buildDir/docs/javadoc")
-}
-
-/**
- * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
- */
-dokka {
-	dependsOn {
-		tasks.getByName("api")
-	}
-	doFirst {
-		classpath = moduleProjects.collect { project -> project.jar.outputs.files.getFiles() }.flatten()
-		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
-		sourceDirs = files(moduleProjects
-				.findAll {
-					it.pluginManager.hasPlugin("kotlin")
-				}
-				.collect { project ->
-					def kotlinDirs = project.sourceSets.main.kotlin.srcDirs.collect()
-					kotlinDirs -= project.sourceSets.main.java.srcDirs
-				})
-	}
-	moduleName = "spring-framework"
-	outputFormat = "html"
-	outputDirectory = "$buildDir/docs/kdoc"
-
-	externalDocumentationLink {
-		url = new URL("https://docs.spring.io/spring-framework/docs/$version/javadoc-api/")
-		packageListUrl = new File(buildDir, "docs/javadoc/package-list").toURI().toURL()
-	}
-	externalDocumentationLink {
-		url = new URL("https://projectreactor.io/docs/core/release/api/")
-	}
-	externalDocumentationLink {
-		url = new URL("https://www.reactive-streams.org/reactive-streams-1.0.1-javadoc/")
-	}
-	externalDocumentationLink {
-		url = new URL("https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/")
-	}
-}
-
-task downloadResources(type: Download) {
-	def version = "0.1.3.RELEASE"
-	src "https://repo.spring.io/release/io/spring/docresources/" +
-			"spring-doc-resources/$version/spring-doc-resources-${version}.zip"
-	dest project.file("$buildDir/docs/spring-doc-resources.zip")
-	onlyIfModified true
-	useETag "all"
-}
-
-task extractDocResources(type: Copy, dependsOn: downloadResources) {
-	from project.zipTree(downloadResources.dest);
-	into "$buildDir/docs/spring-docs-resources/"
-}
-
-/**
- * Produce the Spring Framework Reference documentation
- * from "src/docs/asciidoc" into  "build/asciidoc/html5"
- */
-asciidoctor {
-	sources {
-		include '*.adoc'
-	}
-	outputDir "$buildDir/docs/ref-docs/"
-	resources {
-		from(sourceDir) {
-			include 'images/*', 'css/**', 'js/**'
-		}
-		from "$buildDir/docs/spring-docs-resources/"
-	}
-	logDocuments = true
-	backends = ["html5"]
-	// only ouput PDF documentation for non-SNAPSHOT builds
-	if(!project.getVersion().toString().contains("BUILD-SNAPSHOT")) {
-		backends += "pdf"
-	}
-	options doctype: 'book', eruby: 'erubis'
-	attributes  'icons': 'font',
-			'idprefix': '',
-			'idseparator': '-',
-			'docinfo': 'shared',
-			'revnumber': project.version,
-			'sectanchors': '',
-			'sectnums': '',
-			'source-highlighter=highlight.js',
-			'highlightjsdir=js/highlight',
-			'highlightjs-theme=github',
-			stylesdir: "css/",
-			stylesheet: 'stylesheet.css',
-			'spring-version': project.version
-
-}
-
-asciidoctor.dependsOn extractDocResources
-
-/**
- * Zip all docs (API and reference) into a single archive
- */
-task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'dokka']) {
-	group = "Distribution"
-	description = "Builds -${archiveClassifier} archive containing api and reference " +
-			"for deployment at https://docs.spring.io/spring-framework/docs."
-
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("docs")
-	from("src/dist") {
-		include "changelog.txt"
-	}
-	from (api) {
-		into "javadoc-api"
-	}
-	from ("$asciidoctor.outputDir/html5") {
-		into "spring-framework-reference"
-	}
-	from ("$asciidoctor.outputDir/pdf") {
-		into "spring-framework-reference/pdf"
-	}
-	from (dokka) {
-		into "kdoc-api"
-	}
-}
-
-/**
- * Zip all Spring Framework schemas into a single archive
- */
-task schemaZip(type: Zip) {
-	group = "Distribution"
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("schema")
-	description = "Builds -${archiveClassifier} archive containing all " +
-			"XSDs for deployment at https://springframework.org/schema."
-	duplicatesStrategy DuplicatesStrategy.EXCLUDE
-	moduleProjects.each { module ->
-		def Properties schemas = new Properties();
-
-		module.sourceSets.main.resources.find {
-			it.path.endsWith("META-INF/spring.schemas")
-		}?.withInputStream { schemas.load(it) }
-
-		for (def key : schemas.keySet()) {
-			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
-			assert shortName != key
-			File xsdFile = module.sourceSets.main.resources.find {
-				it.path.endsWith(schemas.get(key))
-			}
-			assert xsdFile != null
-			into (shortName) {
-				from xsdFile.path
-			}
-		}
-	}
-}
-
-/**
- * Create a distribution zip with everything:
- * docs, schemas, jars, source jars, javadoc jars
- */
-task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
-
-	group = "Distribution"
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("dist")
-	description = "Builds -${archiveClassifier} archive, containing all jars and docs, " +
-			"suitable for community download page."
-
-	ext.baseDir = "${archiveBaseName}-${project.version}";
-
-	from("src/docs/dist") {
-		include "readme.txt"
-		include "license.txt"
-		include "notice.txt"
-		into "${baseDir}"
-		expand(copyright: new Date().format("yyyy"), version: project.version)
-	}
-
-	from(zipTree(docsZip.archivePath)) {
-		into "${baseDir}/docs"
-	}
-
-	from(zipTree(schemaZip.archivePath)) {
-		into "${baseDir}/schema"
-	}
-
-	moduleProjects.each { module ->
-		into ("${baseDir}/libs") {
-			from module.jar
-			if (module.tasks.findByPath("sourcesJar")) {
-				from module.sourcesJar
-			}
-			if (module.tasks.findByPath("javadocJar")) {
-				from module.javadocJar
-			}
-		}
-	}
-}
-
-distZip.mustRunAfter moduleProjects.check
@@ -1,7 +1,9 @@
 import org.gradle.plugins.ide.eclipse.model.ProjectDependency
 import org.gradle.plugins.ide.eclipse.model.SourceFolder

-apply plugin: "eclipse"
+
+apply plugin: "propdeps-eclipse"
+apply plugin: "propdeps-idea"

 eclipse.jdt {
 	sourceCompatibility = 1.8
@@ -11,7 +13,7 @@ eclipse.jdt {
 // Replace classpath entries with project dependencies (GRADLE-1116)
 // https://issues.gradle.org/browse/GRADLE-1116
 eclipse.classpath.file.whenMerged { classpath ->
-	def regexp = /.*?\/([^\/]+)\/build\/([^\/]+\/)+(?:main|test)/ // only match those that end in main or test (avoids removing necessary entries like build/classes/jaxb)
+	def regexp = /.*?\/([^\/]+)\/build\/[^\/]+\/(?:main|test)/ // only match those that end in main or test (avoids removing necessary entries like build/classes/jaxb)
 	def projectOutputDependencies = classpath.entries.findAll { entry -> entry.path =~ regexp }
 	projectOutputDependencies.each { entry ->
 		def matcher = (entry.path =~ regexp)
@@ -89,14 +91,6 @@ task cleanEclipseJdtUi(type: Delete) {
 	delete project.file(".settings/org.eclipse.wst.common.project.facet.core.xml")
 }

-task eclipseBuildship(type: Copy) {
-	from rootProject.files(
-		"src/eclipse/org.eclipse.jdt.ui.prefs",
-		"src/eclipse/org.eclipse.jdt.core.prefs")
-	into project.file('.settings/')
-	outputs.upToDateWhen { false }
-}
-
 tasks["eclipseJdt"].dependsOn(eclipseJdtPrepare)
 tasks["cleanEclipse"].dependsOn(cleanEclipseJdtUi)
 tasks["eclipse"].dependsOn(eclipseSettings, eclipseWstComponent)
@@ -0,0 +1,75 @@
+/**
+ * Generate a JDiff report between the current version and an older version.
+ *
+ * Usage:
+ *  gradle jdiff -D OLD_VERSION=3.1.3.RELEASE -D OLD_VERSION_ROOT=/path/to/3.1.3.RELEASE
+ *
+ * View generated report at:
+ *  build/reports/jdiff/changes.html
+ *
+ * @param OLD_VERSION required
+ * @param OLD_VERSION_ROOT required, typically pointing to a separate git clone dir
+ */
+task jdiff {
+	description = "Generates a JDiff report"
+	group = "Documentation"
+
+	def jdiffHome = "${rootProject.rootDir}/gradle/jdiff"
+
+	ant.taskdef(
+			name: "jdiff",
+			classname: "jdiff.JDiffAntTask",
+			classpath: "${jdiffHome}/antjdiff.jar")
+
+	def currentVersion = rootProject.version
+	def currentVersionRoot = rootProject.rootDir
+
+	def oldVersion = System.getProperty("OLD_VERSION")
+	def oldVersionRoot = System.getProperty("OLD_VERSION_ROOT")
+
+	def outputDir = "${rootProject.buildDir}/reports/jdiff/${oldVersion}_to_${currentVersion}"
+
+	doLast {
+		if (oldVersion == null)
+			throw new IllegalArgumentException(
+				"Set OLD_VERSION property to indicate older of the two versions being compared")
+		if (oldVersionRoot == null)
+			throw new IllegalArgumentException(
+				"Set OLD_VERSION_ROOT property to indicate the root directory for ${oldVersion}")
+
+		oldVersionRoot = new File(oldVersionRoot)
+
+		ant.property(name: "JDIFF_HOME", value: jdiffHome)
+		ant.mkdir(dir: outputDir)
+		ant.jdiff(
+				destdir: outputDir,
+				verbose: "off",
+				stats: "on",
+				docchanges: "off") {
+			old(name: "Spring Framework ${oldVersion}") {
+				oldVersionRoot.eachDirMatch( {
+						def candidate = new File(it)
+						candidate.name.matches("org.springframework.*") ||
+						candidate.name.matches("spring-.*") }) { match ->
+					match.eachDirRecurse { subdir ->
+						if (subdir.path ==~ '.*/src/main/java$') {
+							dirset(dir: subdir.path, includes: "org/**")
+						}
+					}
+				}
+			}
+			"new"(name: "Spring Framework ${currentVersion}") {
+				currentVersionRoot.eachDirMatch( {
+						def candidate = new File(it)
+						candidate.name.matches("org.springframework.*") ||
+						candidate.name.matches("spring-.*") }) { match ->
+					match.eachDirRecurse { subdir ->
+						if (subdir.path ==~ '.*/src/main/java$') {
+							dirset(dir: subdir.path, includes: "org/**")
+						}
+					}
+				}
+			}
+		}
+	}
+}
@@ -0,0 +1,506 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library 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 of the License, or (at your option) any later version.
+
+    This library 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 library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
+
+
@@ -0,0 +1,9 @@
+/**
+ * This class is used only as a "null" argument for Javadoc when comparing
+ * two API files. Javadoc has to have a package, .java or .class file as an
+ * argument, even though JDiff doesn't use it.
+ */
+public class Null {
+    public Null() {
+    }
+}
@@ -0,0 +1,6 @@
+This distribution of JDiff 1.1.1 is included in the Spring Framework build
+because JDiff has a hard requirement on a JDIFF_HOME directory containing
+jdiff.jar and xerces.jar as well as other presentation resources.
+
+The actual generation of JDiff reports is driven by the `jdiff` task declared
+in build.gradle in the project root.
@@ -0,0 +1,59 @@
+
+                           JDiff Doclet
+                           ------------
+
+                           Matthew Doar
+                          mdoar@pobox.com
+
+
+The JDiff doclet is used to generate a report describing the
+difference between two public Java APIs. 
+
+The file jdiff.html contains the reference page for JDiff.  The latest
+version of JDiff can be downloaded at:
+https://sourceforge.net/projects/javadiff
+
+To use the Ant task on your own project, see example.xml. More examples
+of using JDiff to compare the public APIs of J2SE1.3 and J2SE1.4 can
+be seen at http://www.jdiff.org
+
+For an example with the source distribution, run "ant" and
+look at the HTML output in ./build/reports/example/changes.html 
+The page at ./build/reports/example/changes/com.acme.sp.SPImpl.html
+shows what a typical page of changes looks like. 
+
+System Requirements
+-------------------
+
+JDiff has been tested with all releases of Java since J2SE1.2 but
+releases of JDiff after 1.10.0 focus on JDK1.5.
+
+License
+-------
+
+JDiff is licensed under the Lesser GNU General Public License (LGPL).
+See the file LICENSE.txt.
+
+Acknowledgements
+----------------
+
+JDiff uses Stuart D. Gathman's Java translation of Gene Myers' O(ND) 
+difference algorithm.
+
+JDiff uses Xerces 1.4.2 from https://www.apache.org.
+
+JDiff also includes a script to use the classdoc application from
+http://classdoc.sourceforge.net or http://www.jensgulden.de, by Jens
+Gulden, (mail@jensgulden.de), to call a doclet such as jdiff on a .jar
+file rather than on source.
+
+Many thanks to the reviewers at Sun and Vitria who gave feedback on early
+versions of JDiff output, and also to the distillers of Laphroaig, and to
+Arturo Fuente for his consistently fine cigars which helped inspire
+much of this work.
+
+
+Footnote:
+
+If you are looking for a generalized diff tool for XML, try diffmk from
+https://wwws.sun.com/software/xml/developers/diffmk/
@@ -1,55 +0,0 @@
-apply plugin: "maven-publish"
-apply plugin: 'com.jfrog.artifactory'
-
-publishing {
-	publications {
-		mavenJava(MavenPublication) {
-			pom {
-				afterEvaluate {
-					name = project.description
-					description = project.description
-				}
-				url = "https://github.com/spring-projects/spring-framework"
-				organization {
-					name = "Spring IO"
-					url = "https://spring.io/projects/spring-framework"
-				}
-				licenses {
-					license {
-						name = "Apache License, Version 2.0"
-						url = "https://www.apache.org/licenses/LICENSE-2.0"
-						distribution = "repo"
-					}
-				}
-				scm {
-					url = "https://github.com/spring-projects/spring-framework"
-					connection = "scm:git:git://github.com/spring-projects/spring-framework"
-					developerConnection = "scm:git:git://github.com/spring-projects/spring-framework"
-				}
-				developers {
-					developer {
-						id = "jhoeller"
-						name = "Juergen Hoeller"
-						email = "jhoeller@pivotal.io"
-					}
-				}
-				issueManagement {
-					system = "GitHub"
-					url = "https://github.com/spring-projects/spring-framework/issues"
-				}
-			}
-			versionMapping {
-				usage('java-api') {
-					fromResolutionResult()
-				}
-				usage('java-runtime') {
-					fromResolutionResult()
-				}
-			}
-		}
-	}
-}
-
-artifactoryPublish {
-	publications(publishing.publications.mavenJava)
-}
@@ -0,0 +1,55 @@
+apply plugin: "propdeps-maven"
+
+install {
+	repositories.mavenInstaller {
+		customizePom(pom, project)
+	}
+}
+
+def customizePom(pom, gradleProject) {
+	pom.whenConfigured { generatedPom ->
+		// eliminate test-scoped dependencies (no need in maven central poms)
+		generatedPom.dependencies.removeAll { dep ->
+			dep.scope == "test"
+		}
+
+		// sort to make pom dependencies order consistent to ease comparison of older poms
+		generatedPom.dependencies = generatedPom.dependencies.sort { dep ->
+			"$dep.scope:$dep.groupId:$dep.artifactId"
+		}
+
+		// add all items necessary for maven central publication
+		generatedPom.project {
+			name = gradleProject.description
+			description = gradleProject.description
+			url = "https://github.com/spring-projects/spring-framework"
+			organization {
+				name = "Spring IO"
+				url = "https://projects.spring.io/spring-framework"
+			}
+			licenses {
+				license {
+					name "Apache License, Version 2.0"
+					url "https://www.apache.org/licenses/LICENSE-2.0"
+					distribution "repo"
+				}
+			}
+			scm {
+				url = "https://github.com/spring-projects/spring-framework"
+				connection = "scm:git:git://github.com/spring-projects/spring-framework"
+				developerConnection = "scm:git:git://github.com/spring-projects/spring-framework"
+			}
+			developers {
+				developer {
+					id = "jhoeller"
+					name = "Juergen Hoeller"
+					email = "jhoeller@pivotal.io"
+				}
+			}
+			issueManagement {
+				system = "Jira"
+				url = "https://jira.springsource.org/browse/SPR"
+			}
+		}
+	}
+}
@@ -1,58 +0,0 @@
-apply plugin: 'org.springframework.build.compile'
-apply plugin: 'org.springframework.build.optional-dependencies'
-apply plugin: 'org.springframework.build.test-sources'
-apply from: "$rootDir/gradle/publications.gradle"
-
-jar {
-	manifest.attributes["Implementation-Title"] = project.name
-	manifest.attributes["Implementation-Version"] = project.version
-	manifest.attributes["Automatic-Module-Name"] = project.name.replace('-', '.')  // for Jigsaw
-	manifest.attributes["Created-By"] =
-			"${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
-
-	from("${rootDir}/src/docs/dist") {
-		include "license.txt"
-		include "notice.txt"
-		into "META-INF"
-		expand(copyright: new Date().format("yyyy"), version: project.version)
-	}
-}
-
-javadoc {
-	description = "Generates project-level javadoc for use in -javadoc jar"
-
-	options.encoding = "UTF-8"
-	options.memberLevel = JavadocMemberLevel.PROTECTED
-	options.author = true
-	options.header = project.name
-	options.use = true
-	options.links(project.ext.javadocLinks)
-	options.addStringOption("Xdoclint:none", "-quiet")
-
-	// Suppress warnings due to cross-module @see and @link references.
-	// Note that global 'api' task does display all warnings.
-	logging.captureStandardError LogLevel.INFO
-	logging.captureStandardOutput LogLevel.INFO  // suppress "## warnings" message
-}
-
-task sourcesJar(type: Jar, dependsOn: classes) {
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-	archiveClassifier.set("sources")
-	from sourceSets.main.allSource
-	// Don't include or exclude anything explicitly by default. See SPR-12085.
-}
-
-task javadocJar(type: Jar) {
-	archiveClassifier.set("javadoc")
-	from javadoc
-}
-
-publishing {
-	publications {
-		mavenJava(MavenPublication) {
-			from components.java
-			artifact sourcesJar
-			artifact javadocJar
-		}
-	}
-}
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -1,21 +1,5 @@
 #!/usr/bin/env sh

-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
 ##############################################################################
 ##
 ##  Gradle start up script for UN*X
@@ -44,7 +28,8 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`

 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+GRADLE_OPTS="-XX:MaxMetaspaceSize=1024m -Xmx1024m $GRADLE_OPTS"
+DEFAULT_JVM_OPTS=""

 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
@@ -125,8 +110,8 @@ if $darwin; then
    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi

-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
    JAVACMD=`cygpath --unix "$JAVACMD"`
@@ -1,19 +1,3 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@@ -30,7 +14,8 @@ set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%

@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+set GRADLE_OPTS=-XX:MaxMetaspaceSize=1024m -Xmx1024m -XX:MaxHeapSize=256m %GRADLE_OPTS%
+set DEFAULT_JVM_OPTS=

@rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
@@ -0,0 +1,117 @@
+@echo off
+set STS_TEST_VERSION='2.9.2.RELEASE'
+
+set CURRENT_DIR=%~dp0
+cd %CURRENT_DIR%
+
+cls
+
+echo.
+echo -----------------------------------------------------------------------
+echo Spring Framework Eclipse/STS project import guide
+echo.
+echo This script will guide you through the process of importing the
+echo Spring Framework sources into Eclipse/STS. It is recommended that you
+echo have a recent version of the SpringSource Tool Suite (this script has
+echo been tested against STS %STS_TEST_VERSION%), but at the minimum you will
+echo need Eclipse + AJDT.
+echo.
+echo If you need to download and install STS, please do that now by
+echo visiting https://spring.io/tools/sts/all 
+echo.
+echo Otherwise, press enter and we'll begin.
+
+pause
+
+REM this command:
+REM - wipes out any existing Eclipse metadata
+REM - generates OXM test classes to avoid errors on import into Eclipse
+REM - generates metadata for all subprojects
+REM - skips metadata gen for the root project (-x :eclipse) to work
+REM   around Eclipse's inability to import hierarchical project structures
+REM SET COMMAND="./gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse"
+SET COMMAND=gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse
+
+echo.
+echo -----------------------------------------------------------------------
+echo STEP 1: Generate subproject Eclipse metadata
+echo. 
+echo The first step will be to generate Eclipse project metadata for each
+echo of the spring-* subprojects. This happens via the built-in
+echo "Gradle wrapper" script (./gradlew in this directory). If this is your
+echo first time using the Gradle wrapper, this step may take a few minutes
+echo while a Gradle distribution is downloaded for you.
+echo. 
+echo The command run will be:
+echo. 
+echo     %COMMAND%
+echo. 
+echo Press enter when ready.
+
+pause
+
+call %COMMAND%
+if not "%ERRORLEVEL%" == "0" exit /B %ERRORLEVEL%
+
+echo.
+echo -----------------------------------------------------------------------
+echo STEP 2: Import subprojects into Eclipse/STS
+echo.
+echo Within Eclipse/STS, do the following:
+echo. 
+echo File ^> Import... ^> Existing Projects into Workspace
+echo      ^> When prompted for the 'root directory', provide %CURRENT_DIR%
+echo      ^> Press enter. You will see the modules show up under "Projects"
+echo      ^> All projects should be selected/checked. Click Finish.
+echo      ^> When the project import is complete, you should have no errors.
+echo.
+echo When the above is complete, return here and press the enter key.
+
+pause
+
+set COMMAND=gradlew --no-daemon :eclipse
+
+echo.
+echo -----------------------------------------------------------------------
+echo STEP 3: generate root project Eclipse metadata
+echo. 
+echo Unfortunately, Eclipse does not allow for importing project
+echo hierarchies, so we had to skip root project metadata generation in the
+echo during step 1. In this step we simply generate root project metadata
+echo so you can import it in the next step.
+echo. 
+echo The command run will be:
+echo. 
+echo     %COMMAND%
+echo. 
+echo Press the enter key when ready.
+pause
+
+call %COMMAND%
+if not "%ERRORLEVEL%" == "0" exit /B %ERRORLEVEL%
+
+echo.
+echo -----------------------------------------------------------------------
+echo STEP 4: Import root project into Eclipse/STS
+echo. 
+echo Follow the project import steps listed in step 2 above to import the
+echo root project.
+echo. 
+echo Press enter when complete, and move on to the final step.
+
+pause
+
+echo.
+echo -----------------------------------------------------------------------
+echo STEP 5: Enable Git support for all projects
+echo. 
+echo - In the Eclipse/STS Package Explorer, select all spring* projects.
+echo - Right-click to open the context menu and select Team ^> Share Project...
+echo - In the Share Project dialog that appears, select Git and press Next
+echo - Check "Use or create repository in parent folder of project"
+echo - Click Finish
+echo. 
+echo When complete, you'll have Git support enabled for all projects.
+echo. 
+echo You're ready to code! Goodbye!
+
@@ -1,49 +0,0 @@
-# Spring Framework - Eclipse/STS Project Import Guide
-
-This document will guide you through the process of importing the Spring Framework
-projects into Eclipse or the Spring Tool Suite (STS). It is recommended that you have a
-recent version of Eclipse or STS. As a bare minimum you will need Eclipse with full Java
-8 support, the AspectJ Development Tools (AJDT), and the Groovy Compiler.
-
-The following instructions have been tested against
-[Spring Tool Suite](https://spring.io/tools) (_STS_) 3.9.4 and 4.0.0.M11 with
-[Eclipse Buildship](https://projects.eclipse.org/projects/tools.buildship) (Eclipse
-Plug-ins for Gradle). The instructions should work with the latest Eclipse distribution
-as long as you install
-[Buildship](https://marketplace.eclipse.org/content/buildship-gradle-integration). Note
-that STS 4 comes with Buildship preinstalled.
-
-## Steps
-
-_Within your locally cloned `spring-framework` working directory:_
-
-1. Precompile `spring-oxm` with `./gradlew :spring-oxm:compileTestJava`
-2. Import into Eclipse (File -> Import -> Gradle -> Existing Gradle Project -> Navigate
-   to directory -> Select Finish)
-3. If prompted, exclude the `spring-aspects` module (or after the import by closing or
-   deleting the project)
-4. In the `spring-oxm` project, add the `jaxb` folder in
-   `build/generated-sources` to the build path (right click on them and select
-   `Build Path -> Use as Source Folder`)
-5. To apply project specific settings run `./gradlew eclipseBuildship`
-7. Code away
-
-## Known Issues
-
-1. `spring-core` and `spring-oxm` should be pre-compiled due to repackaged dependencies.
-  - See `*RepackJar` tasks in the build.
-2. `spring-aspects` does not compile due to references to aspect types unknown to Eclipse.
-  - If you install [AJDT](https://www.eclipse.org/ajdt/downloads/) into Eclipse it should
-    work.
-3. While JUnit tests pass from the command line with Gradle, some may fail when run from
-   the IDE.
-  - Resolving this is a work in progress.
-  - If attempting to run all JUnit tests from within the IDE, you will likely need to set
-    the following VM options to avoid out of memory errors:
-	`-XX:MaxPermSize=2048m -Xmx2048m -XX:MaxHeapSize=2048m`
-
-## Tips
-
-In any case, please do not check in your own generated `.classpath` file, `.project`
-file, or `.settings` folder. You'll notice these files are already intentionally in
-`.gitignore`. The same policy holds for IDEA metadata.
@@ -0,0 +1,135 @@
+cd `dirname $0`
+clear
+cat <<EOM
+
+------------------------------------------------------------------------
+Spring Framework - Eclipse/STS Project Import Guide
+
+This script will guide you through the process of importing the Spring
+Framework projects into Eclipse or the Spring Tool Suite (STS). It is
+recommended that you have a recent version of Eclipse or STS. As a bare
+minimum you will need Eclipse with full Java 8 support, the AspectJ
+Development Tools (AJDT), and the Groovy Compiler.
+
+This script has been tested against:
+
+- STS:     3.6.3.RELEASE (Eclipse Luna SR1 4.4.1)
+- AJDT:    2.2.4.e44x-20141118-0700 (Luna 4.4)
+
+If you need to download and install Eclipse or STS, please do that now
+by visiting one of the following sites:
+
+- Eclipse downloads: https://download.eclipse.org/eclipse/downloads
+- STS downloads: https://spring.io/tools/sts/all
+- STS nightly builds: https://dist.springsource.com/snapshot/STS/nightly-distributions.html
+
+If you need to install a recent CI build for AJDT (i.e., so that the
+spring-aspects module properly compiles in Eclipse/STS), click on the
+"Artifacts" tab of a successful CI build and copy the link to the
+"update site" which you can then use to install or update AJDT within
+Eclipse/STS.
+
+- AJDT CI builds: https://build.spring.io/browse/AJDT-AE44
+
+Once Eclipse/STS is installed, press enter, and we'll begin.
+EOM
+
+read
+
+# this command:
+# - wipes out any existing Eclipse metadata
+# - generates OXM test classes to avoid errors on import into Eclipse
+# - generates metadata for all subprojects
+# - skips metadata gen for the root project (-x :eclipse) to work
+#   around Eclipse's inability to import hierarchical project structures
+COMMAND="./gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse"
+
+cat <<EOM
+
+------------------------------------------------------------------------
+STEP 1: Generate subproject Eclipse metadata
+
+The first step will be to generate Eclipse project metadata for each of
+the spring-* subprojects. This happens via the built-in "Gradle wrapper"
+script (./gradlew in this directory). If this is your first time using
+the Gradle wrapper, this step may take a few minutes while a Gradle
+distribution is downloaded for you.
+
+The command run will be:
+
+    $COMMAND
+
+Press enter when ready.
+EOM
+
+read
+
+$COMMAND || exit
+
+cat <<EOM
+
+------------------------------------------------------------------------
+STEP 2: Import subprojects into Eclipse/STS
+
+Within Eclipse/STS, do the following:
+
+- File > Import... > Existing Projects into Workspace
+- When prompted for the 'root directory', provide $PWD.
+- Press enter. You will see the modules show up under "Projects".
+- All projects should be selected/checked. Click Finish.
+- When the project import is complete, you should have no errors.
+
+When the above is complete, return here and press the enter key.
+EOM
+
+read
+
+COMMAND="./gradlew --no-daemon :eclipse"
+
+cat <<EOM
+
+------------------------------------------------------------------------
+STEP 3: Generate root project Eclipse metadata
+
+Unfortunately, Eclipse does not support importing project hierarchies,
+so we had to skip root project metadata generation during step 1. In
+this step we simply generate root project metadata so that you can
+import it in the next step.
+
+The command run will be:
+
+    $COMMAND
+
+Press the enter key when ready.
+EOM
+
+read
+
+$COMMAND || exit
+
+cat <<EOM
+------------------------------------------------------------------------
+STEP 4: Import root project into Eclipse/STS
+
+Follow the project import steps listed in step 2 above to import the
+root "spring" project.
+
+Press enter when complete, and move on to the final step.
+EOM
+
+read
+
+cat <<EOM
+------------------------------------------------------------------------
+STEP 5: Enable Git support for all projects
+
+- In the Eclipse/STS Package Explorer, select all spring* projects.
+- Right-click to open the context menu and select Team > Share Project...
+- In the Share Project dialog that appears, select Git and press Next.
+- Check "Use or create repository in parent folder of project".
+- Click Finish.
+
+When complete, you'll have Git support enabled for all projects.
+
+You're ready to code! Goodbye!
+EOM
@@ -1,28 +1,25 @@
-The following has been tested against IntelliJ IDEA 2016.2.2
+The following has been tested against Intellij IDEA 13.1

 ## Steps

 _Within your locally cloned spring-framework working directory:_

-1. Precompile `spring-oxm` with `./gradlew :spring-oxm:compileTestJava`
-2. Import into IntelliJ (File -> New -> Project from Existing Sources -> Navigate to directory -> Select build.gradle)
-3. When prompted exclude the `spring-aspects` module (or after the import via File-> Project Structure -> Modules)
-4. Code away
+1. Pre-compile `spring-oxm` with `./gradlew cleanIdea :spring-oxm:compileTestJava`
+2. Import into IDEA (File->import project->import from external model->Gradle)
+3. Set the Project JDK as appropriate (1.8+)
+4. Exclude the `spring-aspects` module (Go to File->Project Structure->Modules)
+5. Code away

 ## Known issues

-1. `spring-core` and `spring-oxm` should be pre-compiled due to repackaged dependencies.
-See `*RepackJar` tasks in the build and https://youtrack.jetbrains.com/issue/IDEA-160605).
-2. `spring-aspects` does not compile due to references to aspect types unknown to
-IntelliJ IDEA. See https://youtrack.jetbrains.com/issue/IDEA-64446 for details. In the meantime, the
-'spring-aspects' can be excluded from the project to avoid compilation errors.
-3. While JUnit tests pass from the command line with Gradle, some may fail when run from
-IntelliJ IDEA. Resolving this is a work in progress. If attempting to run all JUnit tests from within
-IntelliJ IDEA, you will likely need to set the following VM options to avoid out of memory errors:
+1. `spring-oxm` should be pre-compiled since it's using repackaged dependencies (see *RepackJar tasks)
+2. `spring-aspects` does not compile out of the box due to references to aspect types unknown to IDEA.
+See https://youtrack.jetbrains.com/issue/IDEA-64446 for details. In the meantime, the 'spring-aspects'
+should be excluded from the overall project to avoid compilation errors.
+3. While all JUnit tests pass from the command line with Gradle, many will fail when run from IDEA.
+Resolving this is a work in progress. If attempting to run all JUnit tests from within IDEA, you will
+likely need to set the following VM options to avoid out of memory errors:
    -XX:MaxPermSize=2048m -Xmx2048m -XX:MaxHeapSize=2048m
-4. If you invoke "Rebuild Project" in the IDE, you'll have to generate some test
-resources of the `spring-oxm` module again (`./gradlew :spring-oxm:compileTestJava`)    
-

 ## Tips

@@ -31,6 +28,6 @@ You'll notice these files are already intentionally in .gitignore. The same poli

 ## FAQ

-Q. What about IntelliJ IDEA's own [Gradle support](https://confluence.jetbrains.net/display/IDEADEV/Gradle+integration)?
+Q. What about IDEA's own [Gradle support](https://confluence.jetbrains.net/display/IDEADEV/Gradle+integration)?

 A. Keep an eye on https://youtrack.jetbrains.com/issue/IDEA-53476
@@ -1,22 +0,0 @@
-description = "Spring Integration Tests"
-
-apply plugin: "org.springframework.build.test-sources"
-
-dependencies {
-	testCompile(project(":spring-aop"))
-	testCompile(project(":spring-beans"))
-	testCompile(project(":spring-context"))
-	testCompile(project(":spring-core"))
-	testCompile(project(":spring-expression"))
-	testCompile(project(":spring-jdbc"))
-	testCompile(project(":spring-orm"))
-	testCompile(project(":spring-test"))
-	testCompile(project(":spring-tx"))
-	testCompile(project(":spring-web"))
-	testCompile("javax.inject:javax.inject")
-	testCompile("javax.resource:javax.resource-api")
-	testCompile("javax.servlet:javax.servlet-api")
-	testCompile("org.aspectj:aspectjweaver")
-	testCompile("org.hsqldb:hsqldb")
-	testCompile("org.hibernate:hibernate-core")
-}
@@ -1,137 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.aop.config;
-
-import org.junit.jupiter.api.Test;
-
-import org.springframework.aop.framework.Advised;
-import org.springframework.aop.support.AopUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.mock.web.MockHttpServletRequest;
-import org.springframework.mock.web.MockHttpSession;
-import org.springframework.test.context.junit.jupiter.web.SpringJUnitWebConfig;
-import org.springframework.tests.sample.beans.ITestBean;
-import org.springframework.tests.sample.beans.TestBean;
-import org.springframework.util.SerializationTestUtils;
-import org.springframework.web.context.request.RequestContextHolder;
-import org.springframework.web.context.request.ServletRequestAttributes;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Integration tests for scoped proxy use in conjunction with aop: namespace.
- * Deemed an integration test because .web mocks and application contexts are required.
- *
- * @author Rob Harrop
- * @author Juergen Hoeller
- * @author Chris Beams
- * @see org.springframework.aop.config.AopNamespaceHandlerTests
- */
-@SpringJUnitWebConfig
-class AopNamespaceHandlerScopeIntegrationTests {
-
-	@Autowired
-	ITestBean singletonScoped;
-
-	@Autowired
-	ITestBean requestScoped;
-
-	@Autowired
-	ITestBean sessionScoped;
-
-	@Autowired
-	ITestBean sessionScopedAlias;
-
-	@Autowired
-	ITestBean testBean;
-
-
-	@Test
-	void testSingletonScoping() throws Exception {
-		assertThat(AopUtils.isAopProxy(singletonScoped)).as("Should be AOP proxy").isTrue();
-		boolean condition = singletonScoped instanceof TestBean;
-		assertThat(condition).as("Should be target class proxy").isTrue();
-		String rob = "Rob Harrop";
-		String bram = "Bram Smeets";
-		assertThat(singletonScoped.getName()).isEqualTo(rob);
-		singletonScoped.setName(bram);
-		assertThat(singletonScoped.getName()).isEqualTo(bram);
-		ITestBean deserialized = (ITestBean) SerializationTestUtils.serializeAndDeserialize(singletonScoped);
-		assertThat(deserialized.getName()).isEqualTo(bram);
-	}
-
-	@Test
-	void testRequestScoping() throws Exception {
-		MockHttpServletRequest oldRequest = new MockHttpServletRequest();
-		MockHttpServletRequest newRequest = new MockHttpServletRequest();
-
-		RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(oldRequest));
-
-		assertThat(AopUtils.isAopProxy(requestScoped)).as("Should be AOP proxy").isTrue();
-		boolean condition = requestScoped instanceof TestBean;
-		assertThat(condition).as("Should be target class proxy").isTrue();
-
-		assertThat(AopUtils.isAopProxy(testBean)).as("Should be AOP proxy").isTrue();
-		boolean condition1 = testBean instanceof TestBean;
-		assertThat(condition1).as("Regular bean should be JDK proxy").isFalse();
-
-		String rob = "Rob Harrop";
-		String bram = "Bram Smeets";
-
-		assertThat(requestScoped.getName()).isEqualTo(rob);
-		requestScoped.setName(bram);
-		RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(newRequest));
-		assertThat(requestScoped.getName()).isEqualTo(rob);
-		RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(oldRequest));
-		assertThat(requestScoped.getName()).isEqualTo(bram);
-
-		assertThat(((Advised) requestScoped).getAdvisors().length > 0).as("Should have advisors").isTrue();
-	}
-
-	@Test
-	void testSessionScoping() throws Exception {
-		MockHttpSession oldSession = new MockHttpSession();
-		MockHttpSession newSession = new MockHttpSession();
-
-		MockHttpServletRequest request = new MockHttpServletRequest();
-		request.setSession(oldSession);
-		RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
-
-		assertThat(AopUtils.isAopProxy(sessionScoped)).as("Should be AOP proxy").isTrue();
-		boolean condition1 = sessionScoped instanceof TestBean;
-		assertThat(condition1).as("Should not be target class proxy").isFalse();
-
-		assertThat(sessionScopedAlias).isSameAs(sessionScoped);
-
-		assertThat(AopUtils.isAopProxy(testBean)).as("Should be AOP proxy").isTrue();
-		boolean condition = testBean instanceof TestBean;
-		assertThat(condition).as("Regular bean should be JDK proxy").isFalse();
-
-		String rob = "Rob Harrop";
-		String bram = "Bram Smeets";
-
-		assertThat(sessionScoped.getName()).isEqualTo(rob);
-		sessionScoped.setName(bram);
-		request.setSession(newSession);
-		assertThat(sessionScoped.getName()).isEqualTo(rob);
-		request.setSession(oldSession);
-		assertThat(sessionScoped.getName()).isEqualTo(bram);
-
-		assertThat(((Advised) sessionScoped).getAdvisors().length > 0).as("Should have advisors").isTrue();
-	}
-
-}
@@ -1,318 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.aop.framework.autoproxy;
-
-import java.io.IOException;
-import java.lang.reflect.Method;
-import java.util.List;
-
-import javax.servlet.ServletException;
-
-import org.junit.jupiter.api.Test;
-
-import org.springframework.aop.support.AopUtils;
-import org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor;
-import org.springframework.beans.factory.BeanFactory;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.context.support.ClassPathXmlApplicationContext;
-import org.springframework.lang.Nullable;
-import org.springframework.tests.aop.advice.CountingBeforeAdvice;
-import org.springframework.tests.aop.advice.MethodCounter;
-import org.springframework.tests.aop.interceptor.NopInterceptor;
-import org.springframework.tests.sample.beans.ITestBean;
-import org.springframework.tests.transaction.CallCountingTransactionManager;
-import org.springframework.transaction.NoTransactionException;
-import org.springframework.transaction.interceptor.TransactionInterceptor;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Integration tests for auto proxy creation by advisor recognition working in
- * conjunction with transaction management resources.
- *
- * @see org.springframework.aop.framework.autoproxy.AdvisorAutoProxyCreatorTests
- *
- * @author Rod Johnson
- * @author Chris Beams
- */
-class AdvisorAutoProxyCreatorIntegrationTests {
-
-	private static final Class<?> CLASS = AdvisorAutoProxyCreatorIntegrationTests.class;
-	private static final String CLASSNAME = CLASS.getSimpleName();
-
-	private static final String DEFAULT_CONTEXT = CLASSNAME + "-context.xml";
-
-	private static final String ADVISOR_APC_BEAN_NAME = "aapc";
-	private static final String TXMANAGER_BEAN_NAME = "txManager";
-
-	/**
-	 * Return a bean factory with attributes and EnterpriseServices configured.
-	 */
-	protected BeanFactory getBeanFactory() throws IOException {
-		return new ClassPathXmlApplicationContext(DEFAULT_CONTEXT, CLASS);
-	}
-
-	@Test
-	void testDefaultExclusionPrefix() throws Exception {
-		DefaultAdvisorAutoProxyCreator aapc = (DefaultAdvisorAutoProxyCreator) getBeanFactory().getBean(ADVISOR_APC_BEAN_NAME);
-		assertThat(aapc.getAdvisorBeanNamePrefix()).isEqualTo((ADVISOR_APC_BEAN_NAME + DefaultAdvisorAutoProxyCreator.SEPARATOR));
-		assertThat(aapc.isUsePrefix()).isFalse();
-	}
-
-	/**
-	 * If no pointcuts match (no attrs) there should be proxying.
-	 */
-	@Test
-	void testNoProxy() throws Exception {
-		BeanFactory bf = getBeanFactory();
-		Object o = bf.getBean("noSetters");
-		assertThat(AopUtils.isAopProxy(o)).isFalse();
-	}
-
-	@Test
-	void testTxIsProxied() throws Exception {
-		BeanFactory bf = getBeanFactory();
-		ITestBean test = (ITestBean) bf.getBean("test");
-		assertThat(AopUtils.isAopProxy(test)).isTrue();
-	}
-
-	@Test
-	void testRegexpApplied() throws Exception {
-		BeanFactory bf = getBeanFactory();
-		ITestBean test = (ITestBean) bf.getBean("test");
-		MethodCounter counter = (MethodCounter) bf.getBean("countingAdvice");
-		assertThat(counter.getCalls()).isEqualTo(0);
-		test.getName();
-		assertThat(counter.getCalls()).isEqualTo(1);
-	}
-
-	@Test
-	void testTransactionAttributeOnMethod() throws Exception {
-		BeanFactory bf = getBeanFactory();
-		ITestBean test = (ITestBean) bf.getBean("test");
-
-		CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
-		OrderedTxCheckAdvisor txc = (OrderedTxCheckAdvisor) bf.getBean("orderedBeforeTransaction");
-		assertThat(txc.getCountingBeforeAdvice().getCalls()).isEqualTo(0);
-
-		assertThat(txMan.commits).isEqualTo(0);
-		assertThat(test.getAge()).as("Initial value was correct").isEqualTo(4);
-		int newAge = 5;
-		test.setAge(newAge);
-		assertThat(txc.getCountingBeforeAdvice().getCalls()).isEqualTo(1);
-
-		assertThat(test.getAge()).as("New value set correctly").isEqualTo(newAge);
-		assertThat(txMan.commits).as("Transaction counts match").isEqualTo(1);
-	}
-
-	/**
-	 * Should not roll back on servlet exception.
-	 */
-	@Test
-	void testRollbackRulesOnMethodCauseRollback() throws Exception {
-		BeanFactory bf = getBeanFactory();
-		Rollback rb = (Rollback) bf.getBean("rollback");
-
-		CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
-		OrderedTxCheckAdvisor txc = (OrderedTxCheckAdvisor) bf.getBean("orderedBeforeTransaction");
-		assertThat(txc.getCountingBeforeAdvice().getCalls()).isEqualTo(0);
-
-		assertThat(txMan.commits).isEqualTo(0);
-		rb.echoException(null);
-		// Fires only on setters
-		assertThat(txc.getCountingBeforeAdvice().getCalls()).isEqualTo(0);
-		assertThat(txMan.commits).as("Transaction counts match").isEqualTo(1);
-
-		assertThat(txMan.rollbacks).isEqualTo(0);
-		Exception ex = new Exception();
-		try {
-			rb.echoException(ex);
-		}
-		catch (Exception actual) {
-			assertThat(actual).isEqualTo(ex);
-		}
-		assertThat(txMan.rollbacks).as("Transaction counts match").isEqualTo(1);
-	}
-
-	@Test
-	void testRollbackRulesOnMethodPreventRollback() throws Exception {
-		BeanFactory bf = getBeanFactory();
-		Rollback rb = (Rollback) bf.getBean("rollback");
-
-		CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
-
-		assertThat(txMan.commits).isEqualTo(0);
-		// Should NOT roll back on ServletException
-		try {
-			rb.echoException(new ServletException());
-		}
-		catch (ServletException ex) {
-
-		}
-		assertThat(txMan.commits).as("Transaction counts match").isEqualTo(1);
-	}
-
-	@Test
-	void testProgrammaticRollback() throws Exception {
-		BeanFactory bf = getBeanFactory();
-
-		Object bean = bf.getBean(TXMANAGER_BEAN_NAME);
-		boolean condition = bean instanceof CallCountingTransactionManager;
-		assertThat(condition).isTrue();
-		CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
-
-		Rollback rb = (Rollback) bf.getBean("rollback");
-		assertThat(txMan.commits).isEqualTo(0);
-		rb.rollbackOnly(false);
-		assertThat(txMan.commits).as("Transaction counts match").isEqualTo(1);
-		assertThat(txMan.rollbacks).isEqualTo(0);
-		// Will cause rollback only
-		rb.rollbackOnly(true);
-		assertThat(txMan.rollbacks).isEqualTo(1);
-	}
-
-}
-
-
-@SuppressWarnings("serial")
-class NeverMatchAdvisor extends StaticMethodMatcherPointcutAdvisor {
-
-	public NeverMatchAdvisor() {
-		super(new NopInterceptor());
-	}
-
-	/**
-	 * This method is solely to allow us to create a mixture of dependencies in
-	 * the bean definitions. The dependencies don't have any meaning, and don't
-	 * <b>do</b> anything.
-	 */
-	public void setDependencies(List<?> l) {
-
-	}
-
-	/**
-	 * @see org.springframework.aop.MethodMatcher#matches(java.lang.reflect.Method, java.lang.Class)
-	 */
-	@Override
-	public boolean matches(Method m, @Nullable Class<?> targetClass) {
-		return false;
-	}
-
-}
-
-
-class NoSetters {
-
-	public void A() {
-
-	}
-
-	public int getB() {
-		return -1;
-	}
-
-}
-
-
-@SuppressWarnings("serial")
-class OrderedTxCheckAdvisor extends StaticMethodMatcherPointcutAdvisor implements InitializingBean {
-
-	/**
-	 * Should we insist on the presence of a transaction attribute or refuse to accept one?
-	 */
-	private boolean requireTransactionContext = false;
-
-
-	public void setRequireTransactionContext(boolean requireTransactionContext) {
-		this.requireTransactionContext = requireTransactionContext;
-	}
-
-	public boolean isRequireTransactionContext() {
-		return requireTransactionContext;
-	}
-
-
-	public CountingBeforeAdvice getCountingBeforeAdvice() {
-		return (CountingBeforeAdvice) getAdvice();
-	}
-
-	@Override
-	public void afterPropertiesSet() throws Exception {
-		setAdvice(new TxCountingBeforeAdvice());
-	}
-
-	@Override
-	public boolean matches(Method method, @Nullable Class<?> targetClass) {
-		return method.getName().startsWith("setAge");
-	}
-
-
-	private class TxCountingBeforeAdvice extends CountingBeforeAdvice {
-
-		@Override
-		public void before(Method method, Object[] args, Object target) throws Throwable {
-			// do transaction checks
-			if (requireTransactionContext) {
-				TransactionInterceptor.currentTransactionStatus();
-			}
-			else {
-				try {
-					TransactionInterceptor.currentTransactionStatus();
-					throw new RuntimeException("Shouldn't have a transaction");
-				}
-				catch (NoTransactionException ex) {
-					// this is Ok
-				}
-			}
-			super.before(method, args, target);
-		}
-	}
-
-}
-
-
-class Rollback {
-
-	/**
-	 * Inherits transaction attribute.
-	 * Illustrates programmatic rollback.
-	 */
-	public void rollbackOnly(boolean rollbackOnly) {
-		if (rollbackOnly) {
-			setRollbackOnly();
-		}
-	}
-
-	/**
-	 * Extracted in a protected method to facilitate testing
-	 */
-	protected void setRollbackOnly() {
-		TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
-	}
-
-	/**
-	 * @org.springframework.transaction.interceptor.RuleBasedTransaction ( timeout=-1 )
-	 * @org.springframework.transaction.interceptor.RollbackRule ( "java.lang.Exception" )
-	 * @org.springframework.transaction.interceptor.NoRollbackRule ( "ServletException" )
-	 */
-	public void echoException(Exception ex) throws Exception {
-		if (ex != null) {
-			throw ex;
-		}
-	}
-
-}
@@ -1,81 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.beans.factory.xml;
-
-import java.util.List;
-
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestInstance;
-import org.junit.jupiter.api.TestInstance.Lifecycle;
-
-import org.springframework.beans.factory.support.DefaultListableBeanFactory;
-import org.springframework.core.io.ClassPathResource;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author Costin Leau
- */
-@TestInstance(Lifecycle.PER_CLASS)
-class ComponentBeanDefinitionParserTests {
-
-	private final DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
-
-
-	@BeforeAll
-	void setUp() throws Exception {
-		new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
-			new ClassPathResource("component-config.xml", ComponentBeanDefinitionParserTests.class));
-	}
-
-	@AfterAll
-	void tearDown() {
-		bf.destroySingletons();
-	}
-
-	@Test
-	void testBionicBasic() {
-		Component cp = getBionicFamily();
-		assertThat("Bionic-1").isEqualTo(cp.getName());
-	}
-
-	@Test
-	void testBionicFirstLevelChildren() {
-		Component cp = getBionicFamily();
-		List<Component> components = cp.getComponents();
-		assertThat(2).isEqualTo(components.size());
-		assertThat("Mother-1").isEqualTo(components.get(0).getName());
-		assertThat("Rock-1").isEqualTo(components.get(1).getName());
-	}
-
-	@Test
-	void testBionicSecondLevelChildren() {
-		Component cp = getBionicFamily();
-		List<Component> components = cp.getComponents().get(0).getComponents();
-		assertThat(2).isEqualTo(components.size());
-		assertThat("Karate-1").isEqualTo(components.get(0).getName());
-		assertThat("Sport-1").isEqualTo(components.get(1).getName());
-	}
-
-	private Component getBionicFamily() {
-		return bf.getBean("bionic-family", Component.class);
-	}
-
-}
-
@@ -1,25 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.beans.factory.xml;
-
-public class ComponentNamespaceHandler extends NamespaceHandlerSupport {
-
-	@Override
-	public void init() {
-		registerBeanDefinitionParser("component", new ComponentBeanDefinitionParser());
-	}
-}
@@ -1,405 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.context.annotation.jsr330;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import javax.inject.Named;
-import javax.inject.Singleton;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.aop.support.AopUtils;
-import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
-import org.springframework.context.annotation.ScopeMetadata;
-import org.springframework.context.annotation.ScopeMetadataResolver;
-import org.springframework.context.annotation.ScopedProxyMode;
-import org.springframework.mock.web.MockHttpServletRequest;
-import org.springframework.mock.web.MockHttpSession;
-import org.springframework.web.context.request.RequestContextHolder;
-import org.springframework.web.context.request.ServletRequestAttributes;
-import org.springframework.web.context.support.GenericWebApplicationContext;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author Mark Fisher
- * @author Juergen Hoeller
- * @author Chris Beams
- */
-class ClassPathBeanDefinitionScannerJsr330ScopeIntegrationTests {
-
-	private static final String DEFAULT_NAME = "default";
-
-	private static final String MODIFIED_NAME = "modified";
-
-	private ServletRequestAttributes oldRequestAttributes;
-
-	private ServletRequestAttributes newRequestAttributes;
-
-	private ServletRequestAttributes oldRequestAttributesWithSession;
-
-	private ServletRequestAttributes newRequestAttributesWithSession;
-
-
-	@BeforeEach
-	void setup() {
-		this.oldRequestAttributes = new ServletRequestAttributes(new MockHttpServletRequest());
-		this.newRequestAttributes = new ServletRequestAttributes(new MockHttpServletRequest());
-
-		MockHttpServletRequest oldRequestWithSession = new MockHttpServletRequest();
-		oldRequestWithSession.setSession(new MockHttpSession());
-		this.oldRequestAttributesWithSession = new ServletRequestAttributes(oldRequestWithSession);
-
-		MockHttpServletRequest newRequestWithSession = new MockHttpServletRequest();
-		newRequestWithSession.setSession(new MockHttpSession());
-		this.newRequestAttributesWithSession = new ServletRequestAttributes(newRequestWithSession);
-	}
-
-	@AfterEach
-	void reset() {
-		RequestContextHolder.setRequestAttributes(null);
-	}
-
-
-	@Test
-	void testPrototype() {
-		ApplicationContext context = createContext(ScopedProxyMode.NO);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("prototype");
-		assertThat(bean).isNotNull();
-		assertThat(context.isPrototype("prototype")).isTrue();
-		assertThat(context.isSingleton("prototype")).isFalse();
-	}
-
-	@Test
-	void testSingletonScopeWithNoProxy() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(ScopedProxyMode.NO);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
-		assertThat(context.isSingleton("singleton")).isTrue();
-		assertThat(context.isPrototype("singleton")).isFalse();
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// singleton bean, so name should be modified even after lookup
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void testSingletonScopeIgnoresProxyInterfaces() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(ScopedProxyMode.INTERFACES);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// singleton bean, so name should be modified even after lookup
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void testSingletonScopeIgnoresProxyTargetClass() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(ScopedProxyMode.TARGET_CLASS);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// singleton bean, so name should be modified even after lookup
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void testRequestScopeWithNoProxy() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(ScopedProxyMode.NO);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("request");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// but a newly retrieved bean should have the default name
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("request");
-		assertThat(bean2.getName()).isEqualTo(DEFAULT_NAME);
-	}
-
-	@Test
-	void testRequestScopeWithProxiedInterfaces() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(ScopedProxyMode.INTERFACES);
-		IScopedTestBean bean = (IScopedTestBean) context.getBean("request");
-
-		// should be dynamic proxy, implementing both interfaces
-		assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
-		boolean condition = bean instanceof AnotherScopeTestInterface;
-		assertThat(condition).isTrue();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// this is a proxy so it should be reset to default
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void testRequestScopeWithProxiedTargetClass() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(ScopedProxyMode.TARGET_CLASS);
-		IScopedTestBean bean = (IScopedTestBean) context.getBean("request");
-
-		// should be a class-based proxy
-		assertThat(AopUtils.isCglibProxy(bean)).isTrue();
-		boolean condition = bean instanceof RequestScopedTestBean;
-		assertThat(condition).isTrue();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// this is a proxy so it should be reset to default
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void testSessionScopeWithNoProxy() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		ApplicationContext context = createContext(ScopedProxyMode.NO);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("session");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// but a newly retrieved bean should have the default name
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("session");
-		assertThat(bean2.getName()).isEqualTo(DEFAULT_NAME);
-	}
-
-	@Test
-	void testSessionScopeWithProxiedInterfaces() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		ApplicationContext context = createContext(ScopedProxyMode.INTERFACES);
-		IScopedTestBean bean = (IScopedTestBean) context.getBean("session");
-
-		// should be dynamic proxy, implementing both interfaces
-		assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
-		boolean condition = bean instanceof AnotherScopeTestInterface;
-		assertThat(condition).isTrue();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
-		// this is a proxy so it should be reset to default
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		IScopedTestBean bean2 = (IScopedTestBean) context.getBean("session");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-		bean2.setName(DEFAULT_NAME);
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void testSessionScopeWithProxiedTargetClass() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		ApplicationContext context = createContext(ScopedProxyMode.TARGET_CLASS);
-		IScopedTestBean bean = (IScopedTestBean) context.getBean("session");
-
-		// should be a class-based proxy
-		assertThat(AopUtils.isCglibProxy(bean)).isTrue();
-		boolean condition1 = bean instanceof ScopedTestBean;
-		assertThat(condition1).isTrue();
-		boolean condition = bean instanceof SessionScopedTestBean;
-		assertThat(condition).isTrue();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
-		// this is a proxy so it should be reset to default
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		IScopedTestBean bean2 = (IScopedTestBean) context.getBean("session");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-		bean2.setName(DEFAULT_NAME);
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-
-	private ApplicationContext createContext(final ScopedProxyMode scopedProxyMode) {
-		GenericWebApplicationContext context = new GenericWebApplicationContext();
-		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
-		scanner.setIncludeAnnotationConfig(false);
-		scanner.setScopeMetadataResolver(new ScopeMetadataResolver() {
-			@Override
-			public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
-				ScopeMetadata metadata = new ScopeMetadata();
-				if (definition instanceof AnnotatedBeanDefinition) {
-					AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
-					for (String type : annDef.getMetadata().getAnnotationTypes()) {
-						if (type.equals(javax.inject.Singleton.class.getName())) {
-							metadata.setScopeName(BeanDefinition.SCOPE_SINGLETON);
-							break;
-						}
-						else if (annDef.getMetadata().getMetaAnnotationTypes(type).contains(javax.inject.Scope.class.getName())) {
-							metadata.setScopeName(type.substring(type.length() - 13, type.length() - 6).toLowerCase());
-							metadata.setScopedProxyMode(scopedProxyMode);
-							break;
-						}
-						else if (type.startsWith("javax.inject")) {
-							metadata.setScopeName(BeanDefinition.SCOPE_PROTOTYPE);
-						}
-					}
-				}
-				return metadata;
-			}
-		});
-
-		// Scan twice in order to find errors in the bean definition compatibility check.
-		scanner.scan(getClass().getPackage().getName());
-		scanner.scan(getClass().getPackage().getName());
-
-		context.registerAlias("classPathBeanDefinitionScannerJsr330ScopeIntegrationTests.SessionScopedTestBean", "session");
-		context.refresh();
-		return context;
-	}
-
-
-	public interface IScopedTestBean {
-
-		String getName();
-
-		void setName(String name);
-	}
-
-
-	public static abstract class ScopedTestBean implements IScopedTestBean {
-
-		private String name = DEFAULT_NAME;
-
-		@Override
-		public String getName() { return this.name; }
-
-		@Override
-		public void setName(String name) { this.name = name; }
-	}
-
-
-	@Named("prototype")
-	public static class PrototypeScopedTestBean extends ScopedTestBean {
-	}
-
-
-	@Named("singleton")
-	@Singleton
-	public static class SingletonScopedTestBean extends ScopedTestBean {
-	}
-
-
-	public interface AnotherScopeTestInterface {
-	}
-
-
-	@Named("request")
-	@RequestScoped
-	public static class RequestScopedTestBean extends ScopedTestBean implements AnotherScopeTestInterface {
-	}
-
-
-	@Named
-	@SessionScoped
-	public static class SessionScopedTestBean extends ScopedTestBean implements AnotherScopeTestInterface {
-	}
-
-
-	@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
-	@Retention(RetentionPolicy.RUNTIME)
-	@javax.inject.Scope
-	public @interface RequestScoped {
-	}
-
-
-	@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
-	@Retention(RetentionPolicy.RUNTIME)
-	@javax.inject.Scope
-	public @interface SessionScoped {
-	}
-
-}
@@ -1,341 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.context.annotation.scope;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.aop.support.AopUtils;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
-import org.springframework.context.annotation.ScopedProxyMode;
-import org.springframework.mock.web.MockHttpServletRequest;
-import org.springframework.mock.web.MockHttpSession;
-import org.springframework.stereotype.Component;
-import org.springframework.web.context.annotation.RequestScope;
-import org.springframework.web.context.annotation.SessionScope;
-import org.springframework.web.context.request.RequestContextHolder;
-import org.springframework.web.context.request.ServletRequestAttributes;
-import org.springframework.web.context.support.GenericWebApplicationContext;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.springframework.context.annotation.ScopedProxyMode.DEFAULT;
-import static org.springframework.context.annotation.ScopedProxyMode.INTERFACES;
-import static org.springframework.context.annotation.ScopedProxyMode.NO;
-import static org.springframework.context.annotation.ScopedProxyMode.TARGET_CLASS;
-
-/**
- * @author Mark Fisher
- * @author Juergen Hoeller
- * @author Chris Beams
- * @author Sam Brannen
- */
-class ClassPathBeanDefinitionScannerScopeIntegrationTests {
-
-	private static final String DEFAULT_NAME = "default";
-	private static final String MODIFIED_NAME = "modified";
-
-	private ServletRequestAttributes oldRequestAttributes = new ServletRequestAttributes(new MockHttpServletRequest());
-	private ServletRequestAttributes newRequestAttributes = new ServletRequestAttributes(new MockHttpServletRequest());
-
-	private ServletRequestAttributes oldRequestAttributesWithSession;
-	private ServletRequestAttributes newRequestAttributesWithSession;
-
-
-	@BeforeEach
-	void setup() {
-		MockHttpServletRequest oldRequestWithSession = new MockHttpServletRequest();
-		oldRequestWithSession.setSession(new MockHttpSession());
-		this.oldRequestAttributesWithSession = new ServletRequestAttributes(oldRequestWithSession);
-
-		MockHttpServletRequest newRequestWithSession = new MockHttpServletRequest();
-		newRequestWithSession.setSession(new MockHttpSession());
-		this.newRequestAttributesWithSession = new ServletRequestAttributes(newRequestWithSession);
-	}
-
-	@AfterEach
-	void reset() {
-		RequestContextHolder.resetRequestAttributes();
-	}
-
-
-	@Test
-	void singletonScopeWithNoProxy() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(NO);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// singleton bean, so name should be modified even after lookup
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void singletonScopeIgnoresProxyInterfaces() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(INTERFACES);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// singleton bean, so name should be modified even after lookup
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void singletonScopeIgnoresProxyTargetClass() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(TARGET_CLASS);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// singleton bean, so name should be modified even after lookup
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void requestScopeWithNoProxy() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(NO);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("request");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// but a newly retrieved bean should have the default name
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("request");
-		assertThat(bean2.getName()).isEqualTo(DEFAULT_NAME);
-	}
-
-	@Test
-	void requestScopeWithProxiedInterfaces() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(INTERFACES);
-		IScopedTestBean bean = (IScopedTestBean) context.getBean("request");
-
-		// should be dynamic proxy, implementing both interfaces
-		assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
-		boolean condition = bean instanceof AnotherScopeTestInterface;
-		assertThat(condition).isTrue();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// this is a proxy so it should be reset to default
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void requestScopeWithProxiedTargetClass() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		ApplicationContext context = createContext(TARGET_CLASS);
-		IScopedTestBean bean = (IScopedTestBean) context.getBean("request");
-
-		// should be a class-based proxy
-		assertThat(AopUtils.isCglibProxy(bean)).isTrue();
-		boolean condition = bean instanceof RequestScopedTestBean;
-		assertThat(condition).isTrue();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributes);
-		// this is a proxy so it should be reset to default
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-
-		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void sessionScopeWithNoProxy() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		ApplicationContext context = createContext(NO);
-		ScopedTestBean bean = (ScopedTestBean) context.getBean("session");
-
-		// should not be a proxy
-		assertThat(AopUtils.isAopProxy(bean)).isFalse();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
-		// not a proxy so this should not have changed
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-
-		// but a newly retrieved bean should have the default name
-		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("session");
-		assertThat(bean2.getName()).isEqualTo(DEFAULT_NAME);
-	}
-
-	@Test
-	void sessionScopeWithProxiedInterfaces() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		ApplicationContext context = createContext(INTERFACES);
-		IScopedTestBean bean = (IScopedTestBean) context.getBean("session");
-
-		// should be dynamic proxy, implementing both interfaces
-		assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
-		boolean condition = bean instanceof AnotherScopeTestInterface;
-		assertThat(condition).isTrue();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
-		// this is a proxy so it should be reset to default
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		IScopedTestBean bean2 = (IScopedTestBean) context.getBean("session");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-		bean2.setName(DEFAULT_NAME);
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-	@Test
-	void sessionScopeWithProxiedTargetClass() {
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		ApplicationContext context = createContext(TARGET_CLASS);
-		IScopedTestBean bean = (IScopedTestBean) context.getBean("session");
-
-		// should be a class-based proxy
-		assertThat(AopUtils.isCglibProxy(bean)).isTrue();
-		boolean condition1 = bean instanceof ScopedTestBean;
-		assertThat(condition1).isTrue();
-		boolean condition = bean instanceof SessionScopedTestBean;
-		assertThat(condition).isTrue();
-
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
-		// this is a proxy so it should be reset to default
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-		bean.setName(MODIFIED_NAME);
-
-		IScopedTestBean bean2 = (IScopedTestBean) context.getBean("session");
-		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
-		bean2.setName(DEFAULT_NAME);
-		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
-
-		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
-		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
-	}
-
-
-	private ApplicationContext createContext(ScopedProxyMode scopedProxyMode) {
-		GenericWebApplicationContext context = new GenericWebApplicationContext();
-		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
-		scanner.setIncludeAnnotationConfig(false);
-		scanner.setBeanNameGenerator((definition, registry) -> definition.getScope());
-		scanner.setScopedProxyMode(scopedProxyMode);
-
-		// Scan twice in order to find errors in the bean definition compatibility check.
-		scanner.scan(getClass().getPackage().getName());
-		scanner.scan(getClass().getPackage().getName());
-
-		context.refresh();
-		return context;
-	}
-
-
-	interface IScopedTestBean {
-
-		String getName();
-
-		void setName(String name);
-	}
-
-
-	static abstract class ScopedTestBean implements IScopedTestBean {
-
-		private String name = DEFAULT_NAME;
-
-		@Override
-		public String getName() { return this.name; }
-
-		@Override
-		public void setName(String name) { this.name = name; }
-	}
-
-
-	@Component
-	static class SingletonScopedTestBean extends ScopedTestBean {
-	}
-
-
-	interface AnotherScopeTestInterface {
-	}
-
-
-	@Component
-	@RequestScope(proxyMode = DEFAULT)
-	static class RequestScopedTestBean extends ScopedTestBean implements AnotherScopeTestInterface {
-	}
-
-
-	@Component
-	@SessionScope(proxyMode = DEFAULT)
-	static class SessionScopedTestBean extends ScopedTestBean implements AnotherScopeTestInterface {
-	}
-
-}
@@ -1,710 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env;
-
-import java.io.File;
-import java.io.IOException;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.DefaultListableBeanFactory;
-import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.context.EnvironmentAware;
-import org.springframework.context.annotation.AnnotatedBeanDefinitionReader;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.context.annotation.Profile;
-import org.springframework.context.support.ClassPathXmlApplicationContext;
-import org.springframework.context.support.FileSystemXmlApplicationContext;
-import org.springframework.context.support.GenericApplicationContext;
-import org.springframework.context.support.GenericXmlApplicationContext;
-import org.springframework.context.support.StaticApplicationContext;
-import org.springframework.core.io.ClassPathResource;
-import org.springframework.jca.context.ResourceAdapterApplicationContext;
-import org.springframework.jca.support.SimpleBootstrapContext;
-import org.springframework.jca.work.SimpleTaskWorkManager;
-import org.springframework.mock.env.MockEnvironment;
-import org.springframework.mock.env.MockPropertySource;
-import org.springframework.mock.web.MockServletConfig;
-import org.springframework.mock.web.MockServletContext;
-import org.springframework.util.FileCopyUtils;
-import org.springframework.web.context.WebApplicationContext;
-import org.springframework.web.context.support.AbstractRefreshableWebApplicationContext;
-import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
-import org.springframework.web.context.support.GenericWebApplicationContext;
-import org.springframework.web.context.support.StandardServletEnvironment;
-import org.springframework.web.context.support.StaticWebApplicationContext;
-import org.springframework.web.context.support.XmlWebApplicationContext;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;
-import static org.springframework.context.ConfigurableApplicationContext.ENVIRONMENT_BEAN_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DERIVED_DEV_BEAN_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DERIVED_DEV_ENV_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_BEAN_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_ENV_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.ENVIRONMENT_AWARE_BEAN_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_BEAN_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_ENV_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.TRANSITIVE_BEAN_NAME;
-import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.XML_PATH;
-
-/**
- * System integration tests for container support of the {@link Environment} API.
- *
- * <p>
- * Tests all existing BeanFactory and ApplicationContext implementations to ensure that:
- * <ul>
- * <li>a standard environment object is always present
- * <li>a custom environment object can be set and retrieved against the factory/context
- * <li>the {@link EnvironmentAware} interface is respected
- * <li>the environment object is registered with the container as a singleton bean (if an
- * ApplicationContext)
- * <li>bean definition files (if any, and whether XML or @Configuration) are registered
- * conditionally based on environment metadata
- * </ul>
- *
- * @author Chris Beams
- * @author Sam Brannen
- * @see org.springframework.context.support.EnvironmentIntegrationTests
- */
-@SuppressWarnings("resource")
-public class EnvironmentSystemIntegrationTests {
-
-	private final ConfigurableEnvironment prodEnv = new StandardEnvironment();
-
-	private final ConfigurableEnvironment devEnv = new StandardEnvironment();
-
-	private final ConfigurableEnvironment prodWebEnv = new StandardServletEnvironment();
-
-	@BeforeEach
-	void setUp() {
-		prodEnv.setActiveProfiles(PROD_ENV_NAME);
-		devEnv.setActiveProfiles(DEV_ENV_NAME);
-		prodWebEnv.setActiveProfiles(PROD_ENV_NAME);
-	}
-
-	@Test
-	void genericApplicationContext_standardEnv() {
-		ConfigurableApplicationContext ctx = new GenericApplicationContext(newBeanFactoryWithEnvironmentAwareBean());
-		ctx.refresh();
-
-		assertHasStandardEnvironment(ctx);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, ctx.getEnvironment());
-	}
-
-	@Test
-	void genericApplicationContext_customEnv() {
-		GenericApplicationContext ctx = new GenericApplicationContext(newBeanFactoryWithEnvironmentAwareBean());
-		ctx.setEnvironment(prodEnv);
-		ctx.refresh();
-
-		assertHasEnvironment(ctx, prodEnv);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, prodEnv);
-	}
-
-	@Test
-	void xmlBeanDefinitionReader_inheritsEnvironmentFromEnvironmentCapableBDR() {
-		GenericApplicationContext ctx = new GenericApplicationContext();
-		ctx.setEnvironment(prodEnv);
-		new XmlBeanDefinitionReader(ctx).loadBeanDefinitions(XML_PATH);
-		ctx.refresh();
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void annotatedBeanDefinitionReader_inheritsEnvironmentFromEnvironmentCapableBDR() {
-		GenericApplicationContext ctx = new GenericApplicationContext();
-		ctx.setEnvironment(prodEnv);
-		new AnnotatedBeanDefinitionReader(ctx).register(Config.class);
-		ctx.refresh();
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void classPathBeanDefinitionScanner_inheritsEnvironmentFromEnvironmentCapableBDR_scanProfileAnnotatedConfigClasses() {
-		// it's actually ConfigurationClassPostProcessor's Environment that gets the job done here.
-		GenericApplicationContext ctx = new GenericApplicationContext();
-		ctx.setEnvironment(prodEnv);
-		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(ctx);
-		scanner.scan("org.springframework.core.env.scan1");
-		ctx.refresh();
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void classPathBeanDefinitionScanner_inheritsEnvironmentFromEnvironmentCapableBDR_scanProfileAnnotatedComponents() {
-		GenericApplicationContext ctx = new GenericApplicationContext();
-		ctx.setEnvironment(prodEnv);
-		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(ctx);
-		scanner.scan("org.springframework.core.env.scan2");
-		ctx.refresh();
-		assertThat(scanner.getEnvironment()).isEqualTo(ctx.getEnvironment());
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void genericXmlApplicationContext() {
-		GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
-		assertHasStandardEnvironment(ctx);
-		ctx.setEnvironment(prodEnv);
-		ctx.load(XML_PATH);
-		ctx.refresh();
-
-		assertHasEnvironment(ctx, prodEnv);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, prodEnv);
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void classPathXmlApplicationContext() {
-		ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext(XML_PATH);
-		ctx.setEnvironment(prodEnv);
-		ctx.refresh();
-
-		assertEnvironmentBeanRegistered(ctx);
-		assertHasEnvironment(ctx, prodEnv);
-		assertEnvironmentAwareInvoked(ctx, ctx.getEnvironment());
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void fileSystemXmlApplicationContext() throws IOException {
-		ClassPathResource xml = new ClassPathResource(XML_PATH);
-		File tmpFile = File.createTempFile("test", "xml");
-		FileCopyUtils.copy(xml.getFile(), tmpFile);
-
-		// strange - FSXAC strips leading '/' unless prefixed with 'file:'
-		ConfigurableApplicationContext ctx =
-				new FileSystemXmlApplicationContext(new String[] {"file:" + tmpFile.getPath()}, false);
-		ctx.setEnvironment(prodEnv);
-		ctx.refresh();
-		assertEnvironmentBeanRegistered(ctx);
-		assertHasEnvironment(ctx, prodEnv);
-		assertEnvironmentAwareInvoked(ctx, ctx.getEnvironment());
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withPojos() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-
-		assertHasStandardEnvironment(ctx);
-		ctx.setEnvironment(prodEnv);
-
-		ctx.register(EnvironmentAwareBean.class);
-		ctx.refresh();
-
-		assertEnvironmentAwareInvoked(ctx, prodEnv);
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withProdEnvAndProdConfigClass() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-
-		assertHasStandardEnvironment(ctx);
-		ctx.setEnvironment(prodEnv);
-
-		ctx.register(ProdConfig.class);
-		ctx.refresh();
-
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withProdEnvAndDevConfigClass() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-
-		assertHasStandardEnvironment(ctx);
-		ctx.setEnvironment(prodEnv);
-
-		ctx.register(DevConfig.class);
-		ctx.refresh();
-
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isFalse();
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withDevEnvAndDevConfigClass() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-
-		assertHasStandardEnvironment(ctx);
-		ctx.setEnvironment(devEnv);
-
-		ctx.register(DevConfig.class);
-		ctx.refresh();
-
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isTrue();
-		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withImportedConfigClasses() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-
-		assertHasStandardEnvironment(ctx);
-		ctx.setEnvironment(prodEnv);
-
-		ctx.register(Config.class);
-		ctx.refresh();
-
-		assertEnvironmentAwareInvoked(ctx, prodEnv);
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isFalse();
-	}
-
-	@Test
-	void mostSpecificDerivedClassDrivesEnvironment_withDerivedDevEnvAndDerivedDevConfigClass() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		StandardEnvironment derivedDevEnv = new StandardEnvironment();
-		derivedDevEnv.setActiveProfiles(DERIVED_DEV_ENV_NAME);
-		ctx.setEnvironment(derivedDevEnv);
-		ctx.register(DerivedDevConfig.class);
-		ctx.refresh();
-
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isTrue();
-		assertThat(ctx.containsBean(DERIVED_DEV_BEAN_NAME)).isTrue();
-		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void mostSpecificDerivedClassDrivesEnvironment_withDevEnvAndDerivedDevConfigClass() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.setEnvironment(devEnv);
-		ctx.register(DerivedDevConfig.class);
-		ctx.refresh();
-
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(DERIVED_DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isFalse();
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withProfileExpressionMatchOr() {
-		testProfileExpression(true, "p3");
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withProfileExpressionMatchAnd() {
-		testProfileExpression(true, "p1", "p2");
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withProfileExpressionNoMatchAnd() {
-		testProfileExpression(false, "p1");
-	}
-
-	@Test
-	void annotationConfigApplicationContext_withProfileExpressionNoMatchNone() {
-		testProfileExpression(false, "p4");
-	}
-
-	private void testProfileExpression(boolean expected, String... activeProfiles) {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		StandardEnvironment environment = new StandardEnvironment();
-		environment.setActiveProfiles(activeProfiles);
-		ctx.setEnvironment(environment);
-		ctx.register(ProfileExpressionConfig.class);
-		ctx.refresh();
-		assertThat(ctx.containsBean("expressionBean")).isEqualTo(expected);
-	}
-
-	@Test
-	void webApplicationContext() {
-		GenericWebApplicationContext ctx = new GenericWebApplicationContext(newBeanFactoryWithEnvironmentAwareBean());
-		assertHasStandardServletEnvironment(ctx);
-		ctx.setEnvironment(prodWebEnv);
-		ctx.refresh();
-
-		assertHasEnvironment(ctx, prodWebEnv);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, prodWebEnv);
-	}
-
-	@Test
-	void xmlWebApplicationContext() {
-		AbstractRefreshableWebApplicationContext ctx = new XmlWebApplicationContext();
-		ctx.setConfigLocation("classpath:" + XML_PATH);
-		ctx.setEnvironment(prodWebEnv);
-		ctx.refresh();
-
-		assertHasEnvironment(ctx, prodWebEnv);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, prodWebEnv);
-		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
-		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
-	}
-
-	@Test
-	void staticApplicationContext() {
-		StaticApplicationContext ctx = new StaticApplicationContext();
-
-		assertHasStandardEnvironment(ctx);
-
-		registerEnvironmentBeanDefinition(ctx);
-
-		ctx.setEnvironment(prodEnv);
-		ctx.refresh();
-
-		assertHasEnvironment(ctx, prodEnv);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, prodEnv);
-	}
-
-	@Test
-	void staticWebApplicationContext() {
-		StaticWebApplicationContext ctx = new StaticWebApplicationContext();
-
-		assertHasStandardServletEnvironment(ctx);
-
-		registerEnvironmentBeanDefinition(ctx);
-
-		ctx.setEnvironment(prodWebEnv);
-		ctx.refresh();
-
-		assertHasEnvironment(ctx, prodWebEnv);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, prodWebEnv);
-	}
-
-	@Test
-	void annotationConfigWebApplicationContext() {
-		AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
-		ctx.setEnvironment(prodWebEnv);
-		ctx.setConfigLocation(EnvironmentAwareBean.class.getName());
-		ctx.refresh();
-
-		assertHasEnvironment(ctx, prodWebEnv);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, prodWebEnv);
-	}
-
-	@Test
-	void registerServletParamPropertySources_AbstractRefreshableWebApplicationContext() {
-		MockServletContext servletContext = new MockServletContext();
-		servletContext.addInitParameter("pCommon", "pCommonContextValue");
-		servletContext.addInitParameter("pContext1", "pContext1Value");
-
-		MockServletConfig servletConfig = new MockServletConfig(servletContext);
-		servletConfig.addInitParameter("pCommon", "pCommonConfigValue");
-		servletConfig.addInitParameter("pConfig1", "pConfig1Value");
-
-		AbstractRefreshableWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
-		ctx.setConfigLocation(EnvironmentAwareBean.class.getName());
-		ctx.setServletConfig(servletConfig);
-		ctx.refresh();
-
-		ConfigurableEnvironment environment = ctx.getEnvironment();
-		assertThat(environment).isInstanceOf(StandardServletEnvironment.class);
-		MutablePropertySources propertySources = environment.getPropertySources();
-		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)).isTrue();
-		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)).isTrue();
-
-		// ServletConfig gets precedence
-		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonConfigValue");
-		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)))
-				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)));
-
-		// but all params are available
-		assertThat(environment.getProperty("pContext1")).isEqualTo("pContext1Value");
-		assertThat(environment.getProperty("pConfig1")).isEqualTo("pConfig1Value");
-
-		// Servlet* PropertySources have precedence over System* PropertySources
-		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)))
-				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME)));
-
-		// Replace system properties with a mock property source for convenience
-		MockPropertySource mockSystemProperties = new MockPropertySource(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME);
-		mockSystemProperties.setProperty("pCommon", "pCommonSysPropsValue");
-		mockSystemProperties.setProperty("pSysProps1", "pSysProps1Value");
-		propertySources.replace(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, mockSystemProperties);
-
-		// assert that servletconfig params resolve with higher precedence than sysprops
-		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonConfigValue");
-		assertThat(environment.getProperty("pSysProps1")).isEqualTo("pSysProps1Value");
-	}
-
-	@Test
-	void registerServletParamPropertySources_GenericWebApplicationContext() {
-		MockServletContext servletContext = new MockServletContext();
-		servletContext.addInitParameter("pCommon", "pCommonContextValue");
-		servletContext.addInitParameter("pContext1", "pContext1Value");
-
-		GenericWebApplicationContext ctx = new GenericWebApplicationContext();
-		ctx.setServletContext(servletContext);
-		ctx.refresh();
-
-		ConfigurableEnvironment environment = ctx.getEnvironment();
-		assertThat(environment).isInstanceOf(StandardServletEnvironment.class);
-		MutablePropertySources propertySources = environment.getPropertySources();
-		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)).isTrue();
-
-		// ServletContext params are available
-		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonContextValue");
-		assertThat(environment.getProperty("pContext1")).isEqualTo("pContext1Value");
-
-		// Servlet* PropertySources have precedence over System* PropertySources
-		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)))
-				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME)));
-
-		// Replace system properties with a mock property source for convenience
-		MockPropertySource mockSystemProperties = new MockPropertySource(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME);
-		mockSystemProperties.setProperty("pCommon", "pCommonSysPropsValue");
-		mockSystemProperties.setProperty("pSysProps1", "pSysProps1Value");
-		propertySources.replace(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, mockSystemProperties);
-
-		// assert that servletcontext init params resolve with higher precedence than sysprops
-		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonContextValue");
-		assertThat(environment.getProperty("pSysProps1")).isEqualTo("pSysProps1Value");
-	}
-
-	@Test
-	void registerServletParamPropertySources_StaticWebApplicationContext() {
-		MockServletContext servletContext = new MockServletContext();
-		servletContext.addInitParameter("pCommon", "pCommonContextValue");
-		servletContext.addInitParameter("pContext1", "pContext1Value");
-
-		MockServletConfig servletConfig = new MockServletConfig(servletContext);
-		servletConfig.addInitParameter("pCommon", "pCommonConfigValue");
-		servletConfig.addInitParameter("pConfig1", "pConfig1Value");
-
-		StaticWebApplicationContext ctx = new StaticWebApplicationContext();
-		ctx.setServletConfig(servletConfig);
-		ctx.refresh();
-
-		ConfigurableEnvironment environment = ctx.getEnvironment();
-		MutablePropertySources propertySources = environment.getPropertySources();
-		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)).isTrue();
-		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)).isTrue();
-
-		// ServletConfig gets precedence
-		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonConfigValue");
-		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)))
-				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)));
-
-		// but all params are available
-		assertThat(environment.getProperty("pContext1")).isEqualTo("pContext1Value");
-		assertThat(environment.getProperty("pConfig1")).isEqualTo("pConfig1Value");
-
-		// Servlet* PropertySources have precedence over System* PropertySources
-		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)))
-				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME)));
-
-		// Replace system properties with a mock property source for convenience
-		MockPropertySource mockSystemProperties = new MockPropertySource(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME);
-		mockSystemProperties.setProperty("pCommon", "pCommonSysPropsValue");
-		mockSystemProperties.setProperty("pSysProps1", "pSysProps1Value");
-		propertySources.replace(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, mockSystemProperties);
-
-		// assert that servletconfig params resolve with higher precedence than sysprops
-		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonConfigValue");
-		assertThat(environment.getProperty("pSysProps1")).isEqualTo("pSysProps1Value");
-	}
-
-	@Test
-	void resourceAdapterApplicationContext() {
-		ResourceAdapterApplicationContext ctx = new ResourceAdapterApplicationContext(new SimpleBootstrapContext(new SimpleTaskWorkManager()));
-
-		assertHasStandardEnvironment(ctx);
-
-		registerEnvironmentBeanDefinition(ctx);
-
-		ctx.setEnvironment(prodEnv);
-		ctx.refresh();
-
-		assertHasEnvironment(ctx, prodEnv);
-		assertEnvironmentBeanRegistered(ctx);
-		assertEnvironmentAwareInvoked(ctx, prodEnv);
-	}
-
-	@Test
-	void abstractApplicationContextValidatesRequiredPropertiesOnRefresh() {
-		{
-			ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
-			ctx.refresh();
-		}
-
-		{
-			ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
-			ctx.getEnvironment().setRequiredProperties("foo", "bar");
-			assertThatExceptionOfType(MissingRequiredPropertiesException.class).isThrownBy(
-					ctx::refresh);
-		}
-
-		{
-			ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
-			ctx.getEnvironment().setRequiredProperties("foo");
-			ctx.setEnvironment(new MockEnvironment().withProperty("foo", "fooValue"));
-			ctx.refresh(); // should succeed
-		}
-	}
-
-
-	private DefaultListableBeanFactory newBeanFactoryWithEnvironmentAwareBean() {
-		DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
-		registerEnvironmentBeanDefinition(bf);
-		return bf;
-	}
-
-	private void registerEnvironmentBeanDefinition(BeanDefinitionRegistry registry) {
-		registry.registerBeanDefinition(ENVIRONMENT_AWARE_BEAN_NAME,
-				rootBeanDefinition(EnvironmentAwareBean.class).getBeanDefinition());
-	}
-
-	private void assertEnvironmentBeanRegistered(
-			ConfigurableApplicationContext ctx) {
-		// ensure environment is registered as a bean
-		assertThat(ctx.containsBean(ENVIRONMENT_BEAN_NAME)).isTrue();
-	}
-
-	private void assertHasStandardEnvironment(ApplicationContext ctx) {
-		Environment defaultEnv = ctx.getEnvironment();
-		assertThat(defaultEnv).isNotNull();
-		assertThat(defaultEnv).isInstanceOf(StandardEnvironment.class);
-	}
-
-	private void assertHasStandardServletEnvironment(WebApplicationContext ctx) {
-		// ensure a default servlet environment exists
-		Environment defaultEnv = ctx.getEnvironment();
-		assertThat(defaultEnv).isNotNull();
-		assertThat(defaultEnv).isInstanceOf(StandardServletEnvironment.class);
-	}
-
-	private void assertHasEnvironment(ApplicationContext ctx, Environment expectedEnv) {
-		// ensure the custom environment took
-		Environment actualEnv = ctx.getEnvironment();
-		assertThat(actualEnv).isNotNull();
-		assertThat(actualEnv).isEqualTo(expectedEnv);
-		// ensure environment is registered as a bean
-		assertThat(ctx.containsBean(ENVIRONMENT_BEAN_NAME)).isTrue();
-	}
-
-	private void assertEnvironmentAwareInvoked(ConfigurableApplicationContext ctx, Environment expectedEnv) {
-		assertThat(ctx.getBean(EnvironmentAwareBean.class).environment).isEqualTo(expectedEnv);
-	}
-
-
-	private static class EnvironmentAwareBean implements EnvironmentAware {
-
-		public Environment environment;
-
-		@Override
-		public void setEnvironment(Environment environment) {
-			this.environment = environment;
-		}
-	}
-
-
-	/**
-	 * Mirrors the structure of beans and environment-specific config files in
-	 * EnvironmentSystemIntegrationTests-context.xml
-	 */
-	@Configuration
-	@Import({DevConfig.class, ProdConfig.class})
-	static class Config {
-		@Bean
-		public EnvironmentAwareBean envAwareBean() {
-			return new EnvironmentAwareBean();
-		}
-	}
-
-	@Profile(DEV_ENV_NAME)
-	@Configuration
-	@Import(TransitiveConfig.class)
-	static class DevConfig {
-		@Bean
-		public Object devBean() {
-			return new Object();
-		}
-	}
-
-	@Profile(PROD_ENV_NAME)
-	@Configuration
-	static class ProdConfig {
-		@Bean
-		public Object prodBean() {
-			return new Object();
-		}
-	}
-
-	@Configuration
-	static class TransitiveConfig {
-		@Bean
-		public Object transitiveBean() {
-			return new Object();
-		}
-	}
-
-	@Profile(DERIVED_DEV_ENV_NAME)
-	@Configuration
-	static class DerivedDevConfig extends DevConfig {
-		@Bean
-		public Object derivedDevBean() {
-			return new Object();
-		}
-	}
-
-	@Profile("(p1 & p2) | p3")
-	@Configuration
-	static class ProfileExpressionConfig {
-		@Bean
-		public Object expressionBean() {
-			return new Object();
-		}
-	}
-
-
-	/**
-	 * Constants used both locally and in scan* sub-packages
-	 */
-	public static class Constants {
-
-		public static final String XML_PATH = "org/springframework/core/env/EnvironmentSystemIntegrationTests-context.xml";
-
-		public static final String ENVIRONMENT_AWARE_BEAN_NAME = "envAwareBean";
-
-		public static final String PROD_BEAN_NAME = "prodBean";
-		public static final String DEV_BEAN_NAME = "devBean";
-		public static final String DERIVED_DEV_BEAN_NAME = "derivedDevBean";
-		public static final String TRANSITIVE_BEAN_NAME = "transitiveBean";
-
-		public static final String PROD_ENV_NAME = "prod";
-		public static final String DEV_ENV_NAME = "dev";
-		public static final String DERIVED_DEV_ENV_NAME = "derivedDev";
-	}
-
-}
@@ -1,40 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env;
-
-import org.junit.jupiter.api.Test;
-
-import org.springframework.context.support.GenericApplicationContext;
-
-import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;
-
-class PropertyPlaceholderConfigurerEnvironmentIntegrationTests {
-
-	@Test
-	@SuppressWarnings("deprecation")
-	void test() {
-		GenericApplicationContext ctx = new GenericApplicationContext();
-		ctx.registerBeanDefinition("ppc",
-				rootBeanDefinition(org.springframework.beans.factory.config.PropertyPlaceholderConfigurer.class)
-				.addPropertyValue("searchSystemEnvironment", false)
-				.getBeanDefinition());
-		ctx.refresh();
-		ctx.getBean("ppc");
-		ctx.close();
-	}
-
-}
@@ -1,26 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env.scan1;
-
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-
-@Configuration
-@Import({ DevConfig.class, ProdConfig.class })
-class Config {
-
-}
@@ -1,32 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env.scan1;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Profile;
-
-@Profile(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_ENV_NAME)
-@Configuration
-class DevConfig {
-
-	@Bean
-	public Object devBean() {
-		return new Object();
-	}
-
-}
@@ -1,32 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env.scan1;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Profile;
-
-@Profile(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_ENV_NAME)
-@Configuration
-class ProdConfig {
-
-	@Bean
-	public Object prodBean() {
-		return new Object();
-	}
-
-}
@@ -1,25 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env.scan2;
-
-import org.springframework.context.annotation.Profile;
-import org.springframework.stereotype.Component;
-
-@Profile(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_ENV_NAME)
-@Component(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_BEAN_NAME)
-class DevBean {
-}
@@ -1,26 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env.scan2;
-
-import org.springframework.context.annotation.Profile;
-import org.springframework.stereotype.Component;
-
-@Profile(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_ENV_NAME)
-@Component(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_BEAN_NAME)
-class ProdBean {
-
-}
@@ -1,63 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.expression.spel.support;
-
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import org.junit.jupiter.api.Test;
-
-import org.springframework.core.MethodParameter;
-import org.springframework.core.convert.TypeDescriptor;
-import org.springframework.expression.MethodExecutor;
-
-class Spr7538Tests {
-
-	@Test
-	void repro() throws Exception {
-		AlwaysTrueReleaseStrategy target = new AlwaysTrueReleaseStrategy();
-		BeanFactoryTypeConverter converter = new BeanFactoryTypeConverter();
-
-		StandardEvaluationContext context = new StandardEvaluationContext();
-		context.setTypeConverter(converter);
-
-		List<Foo> arguments = Collections.emptyList();
-
-		List<TypeDescriptor> paramDescriptors = new ArrayList<>();
-		Method method = AlwaysTrueReleaseStrategy.class.getMethod("checkCompleteness", List.class);
-		paramDescriptors.add(new TypeDescriptor(new MethodParameter(method, 0)));
-
-
-		List<TypeDescriptor> argumentTypes = new ArrayList<>();
-		argumentTypes.add(TypeDescriptor.forObject(arguments));
-		ReflectiveMethodResolver resolver = new ReflectiveMethodResolver();
-		MethodExecutor executor = resolver.resolve(context, target, "checkCompleteness", argumentTypes);
-
-		Object result = executor.execute(context, target, arguments);
-		System.out.println("Result: " + result);
-	}
-
-	static class AlwaysTrueReleaseStrategy {
-		public boolean checkCompleteness(List<Foo> messages) {
-			return true;
-		}
-	}
-
-	static class Foo{}
-}
@@ -1,250 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.scheduling.annotation;
-
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.aspectj.lang.annotation.Aspect;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
-import org.springframework.aop.support.AopUtils;
-import org.springframework.beans.factory.BeanCreationException;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
-import org.springframework.dao.support.PersistenceExceptionTranslator;
-import org.springframework.stereotype.Repository;
-import org.springframework.tests.EnabledForTestGroups;
-import org.springframework.tests.transaction.CallCountingTransactionManager;
-import org.springframework.transaction.PlatformTransactionManager;
-import org.springframework.transaction.annotation.EnableTransactionManagement;
-import org.springframework.transaction.annotation.Transactional;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.mockito.Mockito.mock;
-import static org.springframework.tests.TestGroup.PERFORMANCE;
-
-/**
- * Integration tests cornering bug SPR-8651, which revealed that @Scheduled methods may
- * not work well with beans that have already been proxied for other reasons such
- * as @Transactional or @Async processing.
- *
- * @author Chris Beams
- * @author Juergen Hoeller
- * @since 3.1
- */
-@SuppressWarnings("resource")
-@EnabledForTestGroups(PERFORMANCE)
-class ScheduledAndTransactionalAnnotationIntegrationTests {
-
-	@Test
-	void failsWhenJdkProxyAndScheduledMethodNotPresentOnInterface() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(Config.class, JdkProxyTxConfig.class, RepoConfigA.class);
-		assertThatExceptionOfType(BeanCreationException.class)
-			.isThrownBy(ctx::refresh)
-			.satisfies(ex -> assertThat(ex.getRootCause()).isInstanceOf(IllegalStateException.class));
-	}
-
-	@Test
-	void succeedsWhenSubclassProxyAndScheduledMethodNotPresentOnInterface() throws InterruptedException {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(Config.class, SubclassProxyTxConfig.class, RepoConfigA.class);
-		ctx.refresh();
-
-		Thread.sleep(100);  // allow @Scheduled method to be called several times
-
-		MyRepository repository = ctx.getBean(MyRepository.class);
-		CallCountingTransactionManager txManager = ctx.getBean(CallCountingTransactionManager.class);
-		assertThat(AopUtils.isCglibProxy(repository)).isEqualTo(true);
-		assertThat(repository.getInvocationCount()).isGreaterThan(0);
-		assertThat(txManager.commits).isGreaterThan(0);
-	}
-
-	@Test
-	void succeedsWhenJdkProxyAndScheduledMethodIsPresentOnInterface() throws InterruptedException {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(Config.class, JdkProxyTxConfig.class, RepoConfigB.class);
-		ctx.refresh();
-
-		Thread.sleep(100);  // allow @Scheduled method to be called several times
-
-		MyRepositoryWithScheduledMethod repository = ctx.getBean(MyRepositoryWithScheduledMethod.class);
-		CallCountingTransactionManager txManager = ctx.getBean(CallCountingTransactionManager.class);
-		assertThat(AopUtils.isJdkDynamicProxy(repository)).isTrue();
-		assertThat(repository.getInvocationCount()).isGreaterThan(0);
-		assertThat(txManager.commits).isGreaterThan(0);
-	}
-
-	@Test
-	void withAspectConfig() throws InterruptedException {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(AspectConfig.class, MyRepositoryWithScheduledMethodImpl.class);
-		ctx.refresh();
-
-		Thread.sleep(100);  // allow @Scheduled method to be called several times
-
-		MyRepositoryWithScheduledMethod repository = ctx.getBean(MyRepositoryWithScheduledMethod.class);
-		assertThat(AopUtils.isCglibProxy(repository)).isTrue();
-		assertThat(repository.getInvocationCount()).isGreaterThan(0);
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement
-	static class JdkProxyTxConfig {
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement(proxyTargetClass = true)
-	static class SubclassProxyTxConfig {
-	}
-
-
-	@Configuration
-	static class RepoConfigA {
-
-		@Bean
-		MyRepository repository() {
-			return new MyRepositoryImpl();
-		}
-	}
-
-
-	@Configuration
-	static class RepoConfigB {
-
-		@Bean
-		MyRepositoryWithScheduledMethod repository() {
-			return new MyRepositoryWithScheduledMethodImpl();
-		}
-	}
-
-
-	@Configuration
-	@EnableScheduling
-	static class Config {
-
-		@Bean
-		PlatformTransactionManager txManager() {
-			return new CallCountingTransactionManager();
-		}
-
-		@Bean
-		PersistenceExceptionTranslator peTranslator() {
-			return mock(PersistenceExceptionTranslator.class);
-		}
-
-		@Bean
-		static PersistenceExceptionTranslationPostProcessor peTranslationPostProcessor() {
-			return new PersistenceExceptionTranslationPostProcessor();
-		}
-	}
-
-
-	@Configuration
-	@EnableScheduling
-	static class AspectConfig {
-
-		@Bean
-		static AnnotationAwareAspectJAutoProxyCreator autoProxyCreator() {
-			AnnotationAwareAspectJAutoProxyCreator apc = new AnnotationAwareAspectJAutoProxyCreator();
-			apc.setProxyTargetClass(true);
-			return apc;
-		}
-
-		@Bean
-		static MyAspect myAspect() {
-			return new MyAspect();
-		}
-	}
-
-
-	@Aspect
-	public static class MyAspect {
-
-		private final AtomicInteger count = new AtomicInteger(0);
-
-		@org.aspectj.lang.annotation.Before("execution(* scheduled())")
-		public void checkTransaction() {
-			this.count.incrementAndGet();
-		}
-	}
-
-
-	public interface MyRepository {
-
-		int getInvocationCount();
-	}
-
-
-	@Repository
-	static class MyRepositoryImpl implements MyRepository {
-
-		private final AtomicInteger count = new AtomicInteger(0);
-
-		@Transactional
-		@Scheduled(fixedDelay = 5)
-		public void scheduled() {
-			this.count.incrementAndGet();
-		}
-
-		@Override
-		public int getInvocationCount() {
-			return this.count.get();
-		}
-	}
-
-
-	public interface MyRepositoryWithScheduledMethod {
-
-		int getInvocationCount();
-
-		void scheduled();
-	}
-
-
-	@Repository
-	static class MyRepositoryWithScheduledMethodImpl implements MyRepositoryWithScheduledMethod {
-
-		private final AtomicInteger count = new AtomicInteger(0);
-
-		@Autowired(required = false)
-		private MyAspect myAspect;
-
-		@Override
-		@Transactional
-		@Scheduled(fixedDelay = 5)
-		public void scheduled() {
-			this.count.incrementAndGet();
-		}
-
-		@Override
-		public int getInvocationCount() {
-			if (this.myAspect != null) {
-				assertThat(this.myAspect.count.get()).isEqualTo(this.count.get());
-			}
-			return this.count.get();
-		}
-	}
-
-}
@@ -1,331 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.transaction.annotation;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import javax.sql.DataSource;
-
-import org.junit.jupiter.api.Test;
-
-import org.springframework.aop.framework.Advised;
-import org.springframework.aop.support.AopUtils;
-import org.springframework.cache.Cache;
-import org.springframework.cache.CacheManager;
-import org.springframework.cache.concurrent.ConcurrentMapCache;
-import org.springframework.cache.support.SimpleCacheManager;
-import org.springframework.context.annotation.AdviceMode;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.ImportResource;
-import org.springframework.jdbc.datasource.DataSourceTransactionManager;
-import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
-import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
-import org.springframework.stereotype.Repository;
-import org.springframework.tests.transaction.CallCountingTransactionManager;
-import org.springframework.transaction.PlatformTransactionManager;
-import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-
-/**
- * Integration tests for the @EnableTransactionManagement annotation.
- *
- * @author Chris Beams
- * @author Sam Brannen
- * @since 3.1
- */
-@SuppressWarnings("resource")
-class EnableTransactionManagementIntegrationTests {
-
-	@Test
-	void repositoryIsNotTxProxy() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
-
-		assertThat(isTxProxy(ctx.getBean(FooRepository.class))).isFalse();
-	}
-
-	@Test
-	void repositoryIsTxProxy_withDefaultTxManagerName() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class, DefaultTxManagerNameConfig.class);
-
-		assertTxProxying(ctx);
-	}
-
-	@Test
-	void repositoryIsTxProxy_withCustomTxManagerName() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class, CustomTxManagerNameConfig.class);
-
-		assertTxProxying(ctx);
-	}
-
-	@Test
-	void repositoryIsTxProxy_withNonConventionalTxManagerName_fallsBackToByTypeLookup() {
-		assertTxProxying(new AnnotationConfigApplicationContext(Config.class, NonConventionalTxManagerNameConfig.class));
-	}
-
-	@Test
-	void repositoryIsClassBasedTxProxy() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class, ProxyTargetClassTxConfig.class);
-
-		assertTxProxying(ctx);
-		assertThat(AopUtils.isCglibProxy(ctx.getBean(FooRepository.class))).isTrue();
-	}
-
-	@Test
-	void repositoryUsesAspectJAdviceMode() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(Config.class, AspectJTxConfig.class);
-		// this test is a bit fragile, but gets the job done, proving that an
-		// attempt was made to look up the AJ aspect. It's due to classpath issues
-		// in .integration-tests that it's not found.
-		assertThatExceptionOfType(Exception.class)
-			.isThrownBy(ctx::refresh)
-			.withMessageContaining("AspectJJtaTransactionManagementConfiguration");
-	}
-
-	@Test
-	void implicitTxManager() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ImplicitTxManagerConfig.class);
-
-		FooRepository fooRepository = ctx.getBean(FooRepository.class);
-		fooRepository.findAll();
-
-		CallCountingTransactionManager txManager = ctx.getBean(CallCountingTransactionManager.class);
-		assertThat(txManager.begun).isEqualTo(1);
-		assertThat(txManager.commits).isEqualTo(1);
-		assertThat(txManager.rollbacks).isEqualTo(0);
-	}
-
-	@Test
-	void explicitTxManager() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ExplicitTxManagerConfig.class);
-
-		FooRepository fooRepository = ctx.getBean(FooRepository.class);
-		fooRepository.findAll();
-
-		CallCountingTransactionManager txManager1 = ctx.getBean("txManager1", CallCountingTransactionManager.class);
-		assertThat(txManager1.begun).isEqualTo(1);
-		assertThat(txManager1.commits).isEqualTo(1);
-		assertThat(txManager1.rollbacks).isEqualTo(0);
-
-		CallCountingTransactionManager txManager2 = ctx.getBean("txManager2", CallCountingTransactionManager.class);
-		assertThat(txManager2.begun).isEqualTo(0);
-		assertThat(txManager2.commits).isEqualTo(0);
-		assertThat(txManager2.rollbacks).isEqualTo(0);
-	}
-
-	@Test
-	void apcEscalation() {
-		new AnnotationConfigApplicationContext(EnableTxAndCachingConfig.class);
-	}
-
-
-	private void assertTxProxying(AnnotationConfigApplicationContext ctx) {
-		FooRepository repo = ctx.getBean(FooRepository.class);
-		assertThat(isTxProxy(repo)).isTrue();
-		// trigger a transaction
-		repo.findAll();
-	}
-
-	private boolean isTxProxy(FooRepository repo) {
-		if (!AopUtils.isAopProxy(repo)) {
-			return false;
-		}
-		return Arrays.stream(((Advised) repo).getAdvisors())
-				.anyMatch(BeanFactoryTransactionAttributeSourceAdvisor.class::isInstance);
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement
-	@ImportResource("org/springframework/transaction/annotation/enable-caching.xml")
-	static class EnableTxAndCachingConfig {
-
-		@Bean
-		public PlatformTransactionManager txManager() {
-			return new CallCountingTransactionManager();
-		}
-
-		@Bean
-		public FooRepository fooRepository() {
-			return new DummyFooRepository();
-		}
-
-		@Bean
-		public CacheManager cacheManager() {
-			SimpleCacheManager mgr = new SimpleCacheManager();
-			ArrayList<Cache> caches = new ArrayList<>();
-			caches.add(new ConcurrentMapCache(""));
-			mgr.setCaches(caches);
-			return mgr;
-		}
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement
-	static class ImplicitTxManagerConfig {
-
-		@Bean
-		public PlatformTransactionManager txManager() {
-			return new CallCountingTransactionManager();
-		}
-
-		@Bean
-		public FooRepository fooRepository() {
-			return new DummyFooRepository();
-		}
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement
-	static class ExplicitTxManagerConfig implements TransactionManagementConfigurer {
-
-		@Bean
-		public PlatformTransactionManager txManager1() {
-			return new CallCountingTransactionManager();
-		}
-
-		@Bean
-		public PlatformTransactionManager txManager2() {
-			return new CallCountingTransactionManager();
-		}
-
-		@Override
-		public PlatformTransactionManager annotationDrivenTransactionManager() {
-			return txManager1();
-		}
-
-		@Bean
-		public FooRepository fooRepository() {
-			return new DummyFooRepository();
-		}
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement
-	static class DefaultTxManagerNameConfig {
-
-		@Bean
-		PlatformTransactionManager transactionManager(DataSource dataSource) {
-			return new DataSourceTransactionManager(dataSource);
-		}
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement
-	static class CustomTxManagerNameConfig {
-
-		@Bean
-		PlatformTransactionManager txManager(DataSource dataSource) {
-			return new DataSourceTransactionManager(dataSource);
-		}
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement
-	static class NonConventionalTxManagerNameConfig {
-
-		@Bean
-		PlatformTransactionManager txManager(DataSource dataSource) {
-			return new DataSourceTransactionManager(dataSource);
-		}
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement(proxyTargetClass=true)
-	static class ProxyTargetClassTxConfig {
-
-		@Bean
-		PlatformTransactionManager transactionManager(DataSource dataSource) {
-			return new DataSourceTransactionManager(dataSource);
-		}
-	}
-
-
-	@Configuration
-	@EnableTransactionManagement(mode=AdviceMode.ASPECTJ)
-	static class AspectJTxConfig {
-
-		@Bean
-		PlatformTransactionManager transactionManager(DataSource dataSource) {
-			return new DataSourceTransactionManager(dataSource);
-		}
-	}
-
-
-	@Configuration
-	static class Config {
-
-		@Bean
-		FooRepository fooRepository() {
-			JdbcFooRepository repos = new JdbcFooRepository();
-			repos.setDataSource(dataSource());
-			return repos;
-		}
-
-		@Bean
-		DataSource dataSource() {
-			return new EmbeddedDatabaseBuilder()
-				.setType(EmbeddedDatabaseType.HSQL)
-				.build();
-		}
-	}
-
-
-	interface FooRepository {
-
-		List<Object> findAll();
-	}
-
-
-	@Repository
-	static class JdbcFooRepository implements FooRepository {
-
-		public void setDataSource(DataSource dataSource) {
-		}
-
-		@Override
-		@Transactional
-		public List<Object> findAll() {
-			return Collections.emptyList();
-		}
-	}
-
-
-	@Repository
-	static class DummyFooRepository implements FooRepository {
-
-		@Override
-		@Transactional
-		public List<Object> findAll() {
-			return Collections.emptyList();
-		}
-	}
-
-}
@@ -1,129 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.transaction.annotation;
-
-import org.junit.jupiter.api.Test;
-
-import org.springframework.aop.support.AopUtils;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import org.springframework.context.annotation.Configuration;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests proving that regardless the proxy strategy used (JDK interface-based vs. CGLIB
- * subclass-based), discovery of advice-oriented annotations is consistent.
- *
- * For example, Spring's @Transactional may be declared at the interface or class level,
- * and whether interface or subclass proxies are used, the @Transactional annotation must
- * be discovered in a consistent fashion.
- *
- * @author Chris Beams
- */
-@SuppressWarnings("resource")
-class ProxyAnnotationDiscoveryTests {
-
-	@Test
-	void annotatedServiceWithoutInterface_PTC_true() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(PTCTrue.class, AnnotatedServiceWithoutInterface.class);
-		ctx.refresh();
-		AnnotatedServiceWithoutInterface s = ctx.getBean(AnnotatedServiceWithoutInterface.class);
-		assertThat(AopUtils.isCglibProxy(s)).isTrue();
-		assertThat(s).isInstanceOf(AnnotatedServiceWithoutInterface.class);
-	}
-
-	@Test
-	void annotatedServiceWithoutInterface_PTC_false() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(PTCFalse.class, AnnotatedServiceWithoutInterface.class);
-		ctx.refresh();
-		AnnotatedServiceWithoutInterface s = ctx.getBean(AnnotatedServiceWithoutInterface.class);
-		assertThat(AopUtils.isCglibProxy(s)).isTrue();
-		assertThat(s).isInstanceOf(AnnotatedServiceWithoutInterface.class);
-	}
-
-	@Test
-	void nonAnnotatedService_PTC_true() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(PTCTrue.class, AnnotatedServiceImpl.class);
-		ctx.refresh();
-		NonAnnotatedService s = ctx.getBean(NonAnnotatedService.class);
-		assertThat(AopUtils.isCglibProxy(s)).isTrue();
-		assertThat(s).isInstanceOf(AnnotatedServiceImpl.class);
-	}
-
-	@Test
-	void nonAnnotatedService_PTC_false() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(PTCFalse.class, AnnotatedServiceImpl.class);
-		ctx.refresh();
-		NonAnnotatedService s = ctx.getBean(NonAnnotatedService.class);
-		assertThat(AopUtils.isJdkDynamicProxy(s)).isTrue();
-		assertThat(s).isNotInstanceOf(AnnotatedServiceImpl.class);
-	}
-
-	@Test
-	void annotatedService_PTC_true() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(PTCTrue.class, NonAnnotatedServiceImpl.class);
-		ctx.refresh();
-		AnnotatedService s = ctx.getBean(AnnotatedService.class);
-		assertThat(AopUtils.isCglibProxy(s)).isTrue();
-		assertThat(s).isInstanceOf(NonAnnotatedServiceImpl.class);
-	}
-
-	@Test
-	void annotatedService_PTC_false() {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		ctx.register(PTCFalse.class, NonAnnotatedServiceImpl.class);
-		ctx.refresh();
-		AnnotatedService s = ctx.getBean(AnnotatedService.class);
-		assertThat(AopUtils.isJdkDynamicProxy(s)).isTrue();
-		assertThat(s).isNotInstanceOf(NonAnnotatedServiceImpl.class);
-	}
-}
-
-@Configuration
-@EnableTransactionManagement(proxyTargetClass=false)
-class PTCFalse { }
-
-@Configuration
-@EnableTransactionManagement(proxyTargetClass=true)
-class PTCTrue { }
-
-interface NonAnnotatedService {
-	void m();
-}
-
-interface AnnotatedService {
-	@Transactional void m();
-}
-
-class NonAnnotatedServiceImpl implements AnnotatedService {
-	@Override
-	public void m() { }
-}
-
-class AnnotatedServiceImpl implements NonAnnotatedService {
-	@Override
-	@Transactional public void m() { }
-}
-
-class AnnotatedServiceWithoutInterface {
-	@Transactional public void m() { }
-}
@@ -1 +0,0 @@
-http\://www.foo.example/schema/component=org.springframework.beans.factory.xml.ComponentNamespaceHandler
@@ -1 +0,0 @@
-http\://www.foo.example/schema/component/component.xsd=org/springframework/beans/factory/xml/component.xsd
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Configuration status="WARN">
-	<Appenders>
-		<Console name="Console" target="SYSTEM_OUT">
-			<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{1.} - %msg%n" />
-		</Console>
-	</Appenders>
-	<Loggers>
-		<Root level="debug">
-			<AppenderRef ref="Console" />
-		</Root>
-	</Loggers>
-</Configuration>
@@ -1,37 +1,31 @@
-pluginManagement {
-	repositories {
-		gradlePluginPortal()
-		maven { url 'https://repo.spring.io/plugins-release' }
-	}
-}
+rootProject.name = "spring"

 include "spring-aop"
 include "spring-aspects"
 include "spring-beans"
+include "spring-beans-groovy"
 include "spring-context"
 include "spring-context-support"
-include "spring-context-indexer"
 include "spring-core"
-include "kotlin-coroutines"
-project(':kotlin-coroutines').projectDir = file('spring-core/kotlin-coroutines')
 include "spring-expression"
 include "spring-instrument"
-include "spring-jcl"
+include "spring-instrument-tomcat"
 include "spring-jdbc"
 include "spring-jms"
 include "spring-messaging"
 include "spring-orm"
+include "spring-orm-hibernate4"
+include "spring-orm-hibernate5"
 include "spring-oxm"
 include "spring-test"
 include "spring-tx"
 include "spring-web"
 include "spring-webmvc"
-include "spring-webflux"
+include "spring-webmvc-portlet"
+include "spring-webmvc-tiles2"
 include "spring-websocket"
-include "framework-bom"
-include "integration-tests"
+include "spring-framework-bom"

-rootProject.name = "spring"
-rootProject.children.each {project ->
-	project.buildFileName = "${project.name}.gradle"
-}
+// Exposes gradle buildSrc for IDE support
+include "buildSrc"
+rootProject.children.find{ it.name == "buildSrc" }.name = "spring-build-src"
@@ -1,9 +0,0 @@
-description = "Spring AOP"
-
-dependencies {
-	compile(project(":spring-beans"))
-	compile(project(":spring-core"))
-	optional("org.aspectj:aspectjweaver")
-	optional("org.apache.commons:commons-pool2")
-	optional("com.jamonapi:jamon")
-}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -20,7 +20,7 @@ package org.aopalliance.aop;
 * Superclass for all AOP infrastructure exceptions.
 * Unchecked, as such exceptions are fatal and end user
 * code shouldn't be forced to catch them.
- *
+ * 
 * @author Rod Johnson
 * @author Bob Lee
 * @author Juergen Hoeller
@@ -1,4 +0,0 @@
-/**
- * The core AOP Alliance advice marker.
- */
-package org.aopalliance.aop;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -19,7 +19,7 @@ package org.aopalliance.intercept;
 import java.lang.reflect.Constructor;

 /**
- * Description of an invocation to a constructor, given to an
+ * Description of an invocation to a constuctor, given to an
 * interceptor upon constructor-call.
 *
 * <p>A constructor invocation is a joinpoint and can be intercepted
@@ -30,12 +30,12 @@ import java.lang.reflect.Constructor;
 */
 public interface ConstructorInvocation extends Invocation {

-	/**
-	 * Get the constructor being called.
-	 * <p>This method is a friendly implementation of the
-	 * {@link Joinpoint#getStaticPart()} method (same result).
-	 * @return the constructor being called
-	 */
-	Constructor<?> getConstructor();
+    /**
+     * Get the constructor being called.
+     * <p>This method is a friendly implementation of the
+     * {@link Joinpoint#getStaticPart()} method (same result).
+     * @return the constructor being called
+     */
+    Constructor<?> getConstructor();

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -24,7 +24,7 @@ import org.aopalliance.aop.Advice;
 * <p>A generic interceptor can intercept runtime events that occur
 * within a base program. Those events are materialized by (reified
 * in) joinpoints. Runtime joinpoints can be invocations, field
- * access, exceptions...
+ * access, exceptions... 
 *
 * <p>This interface is not used directly. Use the sub-interfaces
 * to intercept specific events. For instance, the following class
@@ -32,8 +32,8 @@ import org.aopalliance.aop.Advice;
 * debugger:
 *
 * <pre class=code>
- * class DebuggingInterceptor implements MethodInterceptor,
- *     ConstructorInterceptor {
+ * class DebuggingInterceptor implements MethodInterceptor, 
+ *     ConstructorInterceptor, FieldInterceptor {
 *
 *   Object invoke(MethodInvocation i) throws Throwable {
 *     debug(i.getMethod(), i.getThis(), i.getArgs());
@@ -44,6 +44,16 @@ import org.aopalliance.aop.Advice;
 *     debug(i.getConstructor(), i.getThis(), i.getArgs());
 *     return i.proceed();
 *   }
+ * 
+ *   Object get(FieldAccess fa) throws Throwable {
+ *     debug(fa.getField(), fa.getThis(), null);
+ *     return fa.proceed();
+ *   }
+ *
+ *   Object set(FieldAccess fa) throws Throwable {
+ *     debug(fa.getField(), fa.getThis(), fa.getValueToSet());
+ *     return fa.proceed();
+ *   }
 *
 *   void debug(AccessibleObject ao, Object this, Object value) {
 *     ...
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -39,9 +39,8 @@ package org.aopalliance.intercept;
 *
 * @author Rod Johnson
 */
-@FunctionalInterface
 public interface MethodInterceptor extends Interceptor {
-
+	
 	/**
 	 * Implement this method to perform extra treatments before and
 	 * after the invocation. Polite implementations would certainly
@@ -32,7 +32,7 @@ public interface MethodInvocation extends Invocation {

 	/**
 	 * Get the method being called.
-	 * <p>This method is a friendly implementation of the
+	 * <p>This method is a frienly implementation of the
 	 * {@link Joinpoint#getStaticPart()} method (same result).
 	 * @return the method being called
 	 */
@@ -1,4 +0,0 @@
-/**
- * The AOP Alliance reflective interception abstraction.
- */
-package org.aopalliance.intercept;
@@ -1,4 +0,0 @@
-/**
- * Spring's variant of the AOP Alliance interfaces.
- */
-package org.aopalliance;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -31,18 +31,9 @@ import org.aopalliance.aop.Advice;
 * implemented using interception.
 *
 * @author Rod Johnson
- * @author Juergen Hoeller
 */
 public interface Advisor {

-	/**
-	 * Common placeholder for an empty {@code Advice} to be returned from
-	 * {@link #getAdvice()} if no proper advice has been configured (yet).
-	 * @since 5.0
-	 */
-	Advice EMPTY_ADVICE = new Advice() {};
-
-
 	/**
 	 * Return the advice part of this aspect. An advice may be an
 	 * interceptor, a before advice, a throws advice, etc.
@@ -18,8 +18,6 @@ package org.springframework.aop;

 import java.lang.reflect.Method;

-import org.springframework.lang.Nullable;
-
 /**
 * After returning advice is invoked only on normal method return, not if an
 * exception is thrown. Such advice can see the return value, but cannot change it.
@@ -41,6 +39,6 @@ public interface AfterReturningAdvice extends AfterAdvice {
 	 * allowed by the method signature. Otherwise the exception
 	 * will be wrapped as a runtime exception.
 	 */
-	void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
+	void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -23,16 +23,10 @@ package org.springframework.aop;
 * <p>Can be used as part of a {@link Pointcut} or for the entire
 * targeting of an {@link IntroductionAdvisor}.
 *
- * <p>Concrete implementations of this interface typically should provide proper
- * implementations of {@link Object#equals(Object)} and {@link Object#hashCode()}
- * in order to allow the filter to be used in caching scenarios &mdash; for
- * example, in proxies generated by CGLIB.
- *
 * @author Rod Johnson
 * @see Pointcut
 * @see MethodMatcher
 */
-@FunctionalInterface
 public interface ClassFilter {

 	/**
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -33,7 +33,8 @@ public interface IntroductionAwareMethodMatcher extends MethodMatcher {
 	 * instead of the 2-arg {@link #matches(java.lang.reflect.Method, Class)} method
 	 * if the caller supports the extended IntroductionAwareMethodMatcher interface.
 	 * @param method the candidate method
-	 * @param targetClass the target class
+	 * @param targetClass the target class (may be {@code null}, in which case
+	 * the candidate class must be taken to be the method's declaring class)
 	 * @param hasIntroductions {@code true} if the object on whose behalf we are
 	 * asking is the subject on one or more introductions; {@code false} otherwise
 	 * @return whether or not this method matches statically
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -18,15 +18,14 @@ package org.springframework.aop;

 import java.lang.reflect.Method;

-import org.springframework.lang.Nullable;
-
 /**
 * Advice invoked before a method is invoked. Such advices cannot
 * prevent the method call proceeding, unless they throw a Throwable.
 *
- * @author Rod Johnson
 * @see AfterReturningAdvice
 * @see ThrowsAdvice
+ *
+ * @author Rod Johnson
 */
 public interface MethodBeforeAdvice extends BeforeAdvice {

@@ -40,6 +39,6 @@ public interface MethodBeforeAdvice extends BeforeAdvice {
 	 * allowed by the method signature. Otherwise the exception
 	 * will be wrapped as a runtime exception.
 	 */
-	void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
+	void before(Method method, Object[] args, Object target) throws Throwable;

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -40,11 +40,6 @@ import java.lang.reflect.Method;
 * in an interceptor chain, will have run, so any state changes they have produced in
 * parameters or ThreadLocal state will be available at the time of evaluation.
 *
- * <p>Concrete implementations of this interface typically should provide proper
- * implementations of {@link Object#equals(Object)} and {@link Object#hashCode()}
- * in order to allow the matcher to be used in caching scenarios &mdash; for
- * example, in proxies generated by CGLIB.
- *
 * @author Rod Johnson
 * @since 11.11.2003
 * @see Pointcut
@@ -59,7 +54,8 @@ public interface MethodMatcher {
 	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} call)
 	 * will be made.
 	 * @param method the candidate method
-	 * @param targetClass the target class
+	 * @param targetClass the target class (may be {@code null}, in which case
+	 * the candidate class must be taken to be the method's declaring class)
 	 * @return whether or not this method matches statically
 	 */
 	boolean matches(Method method, Class<?> targetClass);
@@ -85,7 +81,8 @@ public interface MethodMatcher {
 	 * immediately before potential running of the advice, after any
 	 * advice earlier in the advice chain has run.
 	 * @param method the candidate method
-	 * @param targetClass the target class
+	 * @param targetClass the target class (may be {@code null}, in which case
+	 * the candidate class must be taken to be the method's declaring class)
 	 * @param args arguments to the method
 	 * @return whether there's a runtime match
 	 * @see MethodMatcher#matches(Method, Class)
@@ -18,8 +18,6 @@ package org.springframework.aop;

 import org.aopalliance.intercept.MethodInvocation;

-import org.springframework.lang.Nullable;
-
 /**
 * Extension of the AOP Alliance {@link org.aopalliance.intercept.MethodInvocation}
 * interface, allowing access to the proxy that the method invocation was made through.
@@ -75,7 +73,7 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	 * @param key the name of the attribute
 	 * @param value the value of the attribute, or {@code null} to reset it
 	 */
-	void setUserAttribute(String key, @Nullable Object value);
+	void setUserAttribute(String key, Object value);

 	/**
 	 * Return the value of the specified user attribute.
@@ -83,7 +81,6 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	 * @return the value of the attribute, or {@code null} if not set
 	 * @see #setUserAttribute
 	 */
-	@Nullable
 	Object getUserAttribute(String key);

 }
@@ -16,8 +16,6 @@

 package org.springframework.aop;

-import org.springframework.lang.Nullable;
-
 /**
 * Minimal interface for exposing the target class behind a proxy.
 *
@@ -36,7 +34,6 @@ public interface TargetClassAware {
 	 * (typically a proxy configuration or an actual proxy).
 	 * @return the target Class, or {@code null} if not known
 	 */
-	@Nullable
 	Class<?> getTargetClass();

 }
@@ -1,5 +1,5 @@
-/*
- * Copyright 2002-2018 the original author or authors.
+/*<
+ * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -16,8 +16,6 @@

 package org.springframework.aop;

-import org.springframework.lang.Nullable;
-
 /**
 * A {@code TargetSource} is used to obtain the current "target" of
 * an AOP invocation, which will be invoked via reflection if no around
@@ -31,7 +29,6 @@ import org.springframework.lang.Nullable;
 * {@code TargetSources} directly: this is an AOP framework interface.
 *
 * @author Rod Johnson
- * @author Juergen Hoeller
 */
 public interface TargetSource extends TargetClassAware {

@@ -42,7 +39,6 @@ public interface TargetSource extends TargetClassAware {
 	 * @return the type of targets returned by this {@link TargetSource}
 	 */
 	@Override
-	@Nullable
 	Class<?> getTargetClass();

 	/**
@@ -61,7 +57,6 @@ public interface TargetSource extends TargetClassAware {
 	 * or {@code null} if there is no actual target instance
 	 * @throws Exception if the target object can't be resolved
 	 */
-	@Nullable
 	Object getTarget() throws Exception;

 	/**
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -24,7 +24,7 @@ import java.io.Serializable;
 * @author Rod Johnson
 */
@SuppressWarnings("serial")
-final class TrueClassFilter implements ClassFilter, Serializable {
+class TrueClassFilter implements ClassFilter, Serializable {

 	public static final TrueClassFilter INSTANCE = new TrueClassFilter();

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2015 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -25,7 +25,7 @@ import java.lang.reflect.Method;
 * @author Rod Johnson
 */
@SuppressWarnings("serial")
-final class TrueMethodMatcher implements MethodMatcher, Serializable {
+class TrueMethodMatcher implements MethodMatcher, Serializable {

 	public static final TrueMethodMatcher INSTANCE = new TrueMethodMatcher();

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -24,7 +24,7 @@ import java.io.Serializable;
 * @author Rod Johnson
 */
@SuppressWarnings("serial")
-final class TruePointcut implements Pointcut, Serializable {
+class TruePointcut implements Pointcut, Serializable {

 	public static final TruePointcut INSTANCE = new TruePointcut();

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -42,7 +42,6 @@ import org.springframework.aop.support.MethodMatchers;
 import org.springframework.aop.support.StaticMethodMatcher;
 import org.springframework.core.DefaultParameterNameDiscoverer;
 import org.springframework.core.ParameterNameDiscoverer;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.CollectionUtils;
@@ -63,7 +62,7 @@ import org.springframework.util.StringUtils;
 public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation, Serializable {

 	/**
-	 * Key used in ReflectiveMethodInvocation userAttributes map for the current joinpoint.
+	 * Key used in ReflectiveMethodInvocation userAtributes map for the current joinpoint.
 	 */
 	protected static final String JOIN_POINT_KEY = JoinPoint.class.getName();

@@ -108,7 +107,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * (used when determining advice precedence so that we can determine
 	 * whether two pieces of advice come from the same aspect).
 	 */
-	private String aspectName = "";
+	private String aspectName;

 	/**
 	 * The order of declaration of this advice within the aspect.
@@ -117,17 +116,14 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence

 	/**
 	 * This will be non-null if the creator of this advice object knows the argument names
-	 * and sets them explicitly.
+	 * and sets them explicitly
 	 */
-	@Nullable
 	private String[] argumentNames;

-	/** Non-null if after throwing advice binds the thrown value. */
-	@Nullable
+	/** Non-null if after throwing advice binds the thrown value */
 	private String throwingName;

-	/** Non-null if after returning advice binds the return value. */
-	@Nullable
+	/** Non-null if after returning advice binds the return value */
 	private String returningName;

 	private Class<?> discoveredReturningType = Object.class;
@@ -136,22 +132,20 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence

 	/**
 	 * Index for thisJoinPoint argument (currently only
-	 * supported at index 0 if present at all).
+	 * supported at index 0 if present at all)
 	 */
 	private int joinPointArgumentIndex = -1;

 	/**
 	 * Index for thisJoinPointStaticPart argument (currently only
-	 * supported at index 0 if present at all).
+	 * supported at index 0 if present at all)
 	 */
 	private int joinPointStaticPartArgumentIndex = -1;

-	@Nullable
 	private Map<String, Integer> argumentBindings;

 	private boolean argumentsIntrospected = false;

-	@Nullable
 	private Type discoveredReturningGenericType;
 	// Note: Unlike return type, no such generic information is needed for the throwing type,
 	// since Java doesn't allow exception types to be parameterized.
@@ -213,7 +207,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	/**
 	 * Return the ClassLoader for aspect instances.
 	 */
-	@Nullable
 	public final ClassLoader getAspectClassLoader() {
 		return this.aspectInstanceFactory.getAspectClassLoader();
 	}
@@ -224,9 +217,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}


-	/**
-	 * Set the name of the aspect (bean) in which the advice was declared.
-	 */
 	public void setAspectName(String name) {
 		this.aspectName = name;
 	}
@@ -270,7 +260,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			}
 		}
 		if (this.argumentNames != null) {
-			if (this.aspectJAdviceMethod.getParameterCount() == this.argumentNames.length + 1) {
+			if (this.aspectJAdviceMethod.getParameterTypes().length == this.argumentNames.length + 1) {
 				// May need to add implicit join point arg name...
 				Class<?> firstArgType = this.aspectJAdviceMethod.getParameterTypes()[0];
 				if (firstArgType == JoinPoint.class ||
@@ -315,7 +305,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		return this.discoveredReturningType;
 	}

-	@Nullable
 	protected Type getDiscoveredReturningGenericType() {
 		return this.discoveredReturningGenericType;
 	}
@@ -470,10 +459,9 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}

 	private void bindExplicitArguments(int numArgumentsLeftToBind) {
-		Assert.state(this.argumentNames != null, "No argument names available");
-		this.argumentBindings = new HashMap<>();
+		this.argumentBindings = new HashMap<String, Integer>();

-		int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterCount();
+		int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterTypes().length;
 		if (this.argumentNames.length != numExpectedArgumentNames) {
 			throw new IllegalStateException("Expecting to find " + numExpectedArgumentNames +
 					" arguments to bind by name in advice, but actually found " +
@@ -511,7 +499,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}

 		// configure the pointcut expression accordingly.
-		configurePointcutParameters(this.argumentNames, argumentIndexOffset);
+		configurePointcutParameters(argumentIndexOffset);
 	}

 	/**
@@ -519,7 +507,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * pointcut parameters - but returning and throwing vars are handled differently
 	 * and must be removed from the list if present.
 	 */
-	private void configurePointcutParameters(String[] argumentNames, int argumentIndexOffset) {
+	private void configurePointcutParameters(int argumentIndexOffset) {
 		int numParametersToRemove = argumentIndexOffset;
 		if (this.returningName != null) {
 			numParametersToRemove++;
@@ -527,20 +515,20 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		if (this.throwingName != null) {
 			numParametersToRemove++;
 		}
-		String[] pointcutParameterNames = new String[argumentNames.length - numParametersToRemove];
+		String[] pointcutParameterNames = new String[this.argumentNames.length - numParametersToRemove];
 		Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
 		Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();

 		int index = 0;
-		for (int i = 0; i < argumentNames.length; i++) {
+		for (int i = 0; i < this.argumentNames.length; i++) {
 			if (i < argumentIndexOffset) {
 				continue;
 			}
-			if (argumentNames[i].equals(this.returningName) ||
-				argumentNames[i].equals(this.throwingName)) {
+			if (this.argumentNames[i].equals(this.returningName) ||
+				this.argumentNames[i].equals(this.throwingName)) {
 				continue;
 			}
-			pointcutParameterNames[index] = argumentNames[i];
+			pointcutParameterNames[index] = this.argumentNames[i];
 			pointcutParameterTypes[index] = methodParameterTypes[i];
 			index++;
 		}
@@ -551,16 +539,14 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence

 	/**
 	 * Take the arguments at the method execution join point and output a set of arguments
-	 * to the advice method.
+	 * to the advice method
 	 * @param jp the current JoinPoint
 	 * @param jpMatch the join point match that matched this execution join point
 	 * @param returnValue the return value from the method execution (may be null)
 	 * @param ex the exception thrown by the method execution (may be null)
 	 * @return the empty array if there are no arguments
 	 */
-	protected Object[] argBinding(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
-			@Nullable Object returnValue, @Nullable Throwable ex) {
-
+	protected Object[] argBinding(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable ex) {
 		calculateArgumentBindings();

 		// AMC start
@@ -619,23 +605,20 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * @return the invocation result
 	 * @throws Throwable in case of invocation failure
 	 */
-	protected Object invokeAdviceMethod(
-			@Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
-			throws Throwable {
-
+	protected Object invokeAdviceMethod(JoinPointMatch jpMatch, Object returnValue, Throwable ex) throws Throwable {
 		return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
 	}

 	// As above, but in this case we are given the join point.
-	protected Object invokeAdviceMethod(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
-			@Nullable Object returnValue, @Nullable Throwable t) throws Throwable {
+	protected Object invokeAdviceMethod(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable t)
+			throws Throwable {

 		return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
 	}

 	protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
 		Object[] actualArgs = args;
-		if (this.aspectJAdviceMethod.getParameterCount() == 0) {
+		if (this.aspectJAdviceMethod.getParameterTypes().length == 0) {
 			actualArgs = null;
 		}
 		try {
@@ -663,7 +646,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	/**
 	 * Get the current join point match at the join point we are being dispatched on.
 	 */
-	@Nullable
 	protected JoinPointMatch getJoinPointMatch() {
 		MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
 		if (!(mi instanceof ProxyMethodInvocation)) {
@@ -678,10 +660,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	// 'last man wins' which is not what we want at all.
 	// Using the expression is guaranteed to be safe, since 2 identical expressions
 	// are guaranteed to bind in exactly the same way.
-	@Nullable
 	protected JoinPointMatch getJoinPointMatch(ProxyMethodInvocation pmi) {
-		String expression = this.pointcut.getExpression();
-		return (expression != null ? (JoinPointMatch) pmi.getUserAttribute(expression) : null);
+		return (JoinPointMatch) pmi.getUserAttribute(this.pointcut.getExpression());
 	}


@@ -720,7 +700,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}

 		@Override
-		public boolean equals(@Nullable Object other) {
+		public boolean equals(Object other) {
 			if (this == other) {
 				return true;
 			}
@@ -735,11 +715,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		public int hashCode() {
 			return this.adviceMethod.hashCode();
 		}
-
-		@Override
-		public String toString() {
-			return getClass().getName() + ": " + this.adviceMethod;
-		}
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -17,7 +17,6 @@
 package org.springframework.aop.aspectj;

 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;

 /**
 * Interface implemented to provide an instance of an AspectJ aspect.
@@ -41,10 +40,8 @@ public interface AspectInstanceFactory extends Ordered {

 	/**
 	 * Expose the aspect class loader that this factory uses.
-	 * @return the aspect class loader (or {@code null} for the bootstrap loader)
-	 * @see org.springframework.util.ClassUtils#getDefaultClassLoader()
+	 * @return the aspect class loader (never {@code null})
 	 */
-	@Nullable
 	ClassLoader getAspectClassLoader();

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -30,7 +30,6 @@ import org.aspectj.weaver.tools.PointcutParser;
 import org.aspectj.weaver.tools.PointcutPrimitive;

 import org.springframework.core.ParameterNameDiscoverer;
-import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;

 /**
@@ -132,8 +131,8 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	private static final int STEP_REFERENCE_PCUT_BINDING = 7;
 	private static final int STEP_FINISHED = 8;

-	private static final Set<String> singleValuedAnnotationPcds = new HashSet<>();
-	private static final Set<String> nonReferencePointcutTokens = new HashSet<>();
+	private static final Set<String> singleValuedAnnotationPcds = new HashSet<String>();
+	private static final Set<String> nonReferencePointcutTokens = new HashSet<String>();


 	static {
@@ -156,32 +155,29 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}


-	/** The pointcut expression associated with the advice, as a simple String. */
-	@Nullable
+	/** The pointcut expression associated with the advice, as a simple String */
 	private String pointcutExpression;

 	private boolean raiseExceptions;

-	/** If the advice is afterReturning, and binds the return value, this is the parameter name used. */
-	@Nullable
+	/** If the advice is afterReturning, and binds the return value, this is the parameter name used */
 	private String returningName;

-	/** If the advice is afterThrowing, and binds the thrown value, this is the parameter name used. */
-	@Nullable
+	/** If the advice is afterThrowing, and binds the thrown value, this is the parameter name used */
 	private String throwingName;

-	private Class<?>[] argumentTypes = new Class<?>[0];
+	private Class<?>[] argumentTypes;

-	private String[] parameterNameBindings = new String[0];
+	private String[] parameterNameBindings;

 	private int numberOfRemainingUnboundArguments;


 	/**
-	 * Create a new discoverer that attempts to discover parameter names.
+	 * Create a new discoverer that attempts to discover parameter names
 	 * from the given pointcut expression.
 	 */
-	public AspectJAdviceParameterNameDiscoverer(@Nullable String pointcutExpression) {
+	public AspectJAdviceParameterNameDiscoverer(String pointcutExpression) {
 		this.pointcutExpression = pointcutExpression;
 	}

@@ -200,7 +196,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * returning variable name must be specified.
 	 * @param returningName the name of the returning variable
 	 */
-	public void setReturningName(@Nullable String returningName) {
+	public void setReturningName(String returningName) {
 		this.returningName = returningName;
 	}

@@ -209,7 +205,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * throwing variable name must be specified.
 	 * @param throwingName the name of the throwing variable
 	 */
-	public void setThrowingName(@Nullable String throwingName) {
+	public void setThrowingName(String throwingName) {
 		this.throwingName = throwingName;
 	}

@@ -222,7 +218,6 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * @return the parameter names
 	 */
 	@Override
-	@Nullable
 	public String[] getParameterNames(Method method) {
 		this.argumentTypes = method.getParameterTypes();
 		this.numberOfRemainingUnboundArguments = this.argumentTypes.length;
@@ -272,7 +267,15 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 				}
 			}
 		}
-		catch (AmbiguousBindingException | IllegalArgumentException ex) {
+		catch (AmbiguousBindingException ambigEx) {
+			if (this.raiseExceptions) {
+				throw ambigEx;
+			}
+			else {
+				return null;
+			}
+		}
+		catch (IllegalArgumentException ex) {
 			if (this.raiseExceptions) {
 				throw ex;
 			}
@@ -303,7 +306,6 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * {@link #setRaiseExceptions(boolean) raiseExceptions} has been set to {@code true}
 	 */
 	@Override
-	@Nullable
 	public String[] getParameterNames(Constructor<?> ctor) {
 		if (this.raiseExceptions) {
 			throw new UnsupportedOperationException("An advice method can never be a constructor");
@@ -409,7 +411,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * <p>Some more support from AspectJ in doing this exercise would be nice... :)
 	 */
 	private void maybeBindAnnotationsFromPointcutExpression() {
-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			String toMatch = tokens[i];
@@ -468,8 +470,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	/*
 	 * If the token starts meets Java identifier conventions, it's in.
 	 */
-	@Nullable
-	private String maybeExtractVariableName(@Nullable String candidateToken) {
+	private String maybeExtractVariableName(String candidateToken) {
 		if (!StringUtils.hasLength(candidateToken)) {
 			return null;
 		}
@@ -492,7 +493,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * Given an args pointcut body (could be {@code args} or {@code at_args}),
 	 * add any candidate variable names to the given list.
 	 */
-	private void maybeExtractVariableNamesFromArgs(@Nullable String argsSpec, List<String> varNames) {
+	private void maybeExtractVariableNamesFromArgs(String argsSpec, List<String> varNames) {
 		if (argsSpec == null) {
 			return;
 		}
@@ -516,7 +517,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 					+ " unbound args at this(),target(),args() binding stage, with no way to determine between them");
 		}

-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			if (tokens[i].equals("this") ||
@@ -533,7 +534,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 			else if (tokens[i].equals("args") || tokens[i].startsWith("args(")) {
 				PointcutBody body = getPointcutBody(tokens, i);
 				i += body.numTokensConsumed;
-				List<String> candidateVarNames = new ArrayList<>();
+				List<String> candidateVarNames = new ArrayList<String>();
 				maybeExtractVariableNamesFromArgs(body.text, candidateVarNames);
 				// we may have found some var names that were bound in previous primitive args binding step,
 				// filter them out...
@@ -567,7 +568,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 					+ " unbound args at reference pointcut binding stage, with no way to determine between them");
 		}

-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			String toMatch = tokens[i];
@@ -648,7 +649,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 				}

 				if (tokens[currentIndex].endsWith(")")) {
-					sb.append(tokens[currentIndex].substring(0, tokens[currentIndex].length() - 1));
+					sb.append(tokens[currentIndex], 0, tokens[currentIndex].length() - 1);
 					return new PointcutBody(numTokensConsumed, sb.toString().trim());
 				}

@@ -669,7 +670,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}

 	/**
-	 * Match up args against unbound arguments of primitive types.
+	 * Match up args against unbound arguments of primitive types
 	 */
 	private void maybeBindPrimitiveArgsFromPointcutExpression() {
 		int numUnboundPrimitives = countNumberOfUnboundPrimitiveArguments();
@@ -679,7 +680,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 		}
 		if (numUnboundPrimitives == 1) {
 			// Look for arg variable and bind it if we find exactly one...
-			List<String> varNames = new ArrayList<>();
+			List<String> varNames = new ArrayList<String>();
 			String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 			for (int i = 0; i < tokens.length; i++) {
 				if (tokens[i].equals("args") || tokens[i].startsWith("args(")) {
@@ -773,10 +774,9 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov

 		private int numTokensConsumed;

-		@Nullable
 		private String text;

-		public PointcutBody(int tokens, @Nullable String text) {
+		public PointcutBody(int tokens, String text) {
 			this.numTokensConsumed = tokens;
 			this.text = text;
 		}
@@ -22,7 +22,6 @@ import java.lang.reflect.Type;

 import org.springframework.aop.AfterAdvice;
 import org.springframework.aop.AfterReturningAdvice;
-import org.springframework.lang.Nullable;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.TypeUtils;

@@ -61,7 +60,7 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
 	}

 	@Override
-	public void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable {
+	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
 		if (shouldInvokeOnReturnValueOf(method, returnValue)) {
 			invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
 		}
@@ -76,7 +75,7 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
 	 * @param returnValue the return value of the target method
 	 * @return whether to invoke the advice method for the given return value
 	 */
-	private boolean shouldInvokeOnReturnValueOf(Method method, @Nullable Object returnValue) {
+	private boolean shouldInvokeOnReturnValueOf(Method method, Object returnValue) {
 		Class<?> type = getDiscoveredReturningType();
 		Type genericType = getDiscoveredReturningGenericType();
 		// If we aren't dealing with a raw type, check if generic parameters are assignable.
@@ -95,7 +94,7 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
 	 * @param returnValue the return value of the target method
 	 * @return whether to invoke the advice method for the given return value and type
 	 */
-	private boolean matchesReturnValue(Class<?> type, Method method, @Nullable Object returnValue) {
+	private boolean matchesReturnValue(Class<?> type, Method method, Object returnValue) {
 		if (returnValue != null) {
 			return ClassUtils.isAssignableValue(type, returnValue);
 		}
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`implementation-class=org.springframework.build.gradle.DetectSplitPackagesPlugin`
				`@@ -1 +0,0 @@`
				`http\://www.foo.example/schema/component=org.springframework.beans.factory.xml.ComponentNamespaceHandler`