Release v5.3.35

.github/actions/await-http-resource/action.yml

@@ -1,20 +0,0 @@
-name: Await HTTP Resource
-description: Waits for an HTTP resource to be available (a HEAD request succeeds)
-inputs:
-  url:
-    description: 'The URL of the resource to await'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Await HTTP resource
-      shell: bash
-      run: |
-        url=${{ inputs.url }}
-        echo "Waiting for $url"
-        until curl --fail --head --silent ${{ inputs.url }} > /dev/null
-        do
-          echo "."
-          sleep 60
-        done
-        echo "$url is available"

.github/actions/build/action.yml

@@ -1,56 +0,0 @@
-name: 'Build'
-description: 'Builds the project, optionally publishing it to a local deployment repository'
-inputs:
-  java-version:
-    required: false
-    default: '8'
-    description: 'The Java version to compile and test with'
-  java-early-access:
-    required: false
-    default: 'false'
-    description: 'Whether the Java version is in early access'
-  java-toolchain:
-    required: false
-    default: 'false'
-    description: 'Whether a Java toolchain should be used'
-  publish:
-    required: false
-    default: 'false'
-    description: 'Whether to publish artifacts ready for deployment to Artifactory'
-  develocity-access-key:
-    required: false
-    description: 'The access key for authentication with ge.spring.io'
-outputs:
-  build-scan-url:
-    description: 'The URL, if any, of the build scan produced by the build'
-    value: ${{ (inputs.publish == 'true' && steps.publish.outputs.build-scan-url) || steps.build.outputs.build-scan-url }}
-  version:
-    description: 'The version that was built'
-    value: ${{ steps.read-version.outputs.version }}
-runs:
-  using: composite
-  steps:
-    - name: Prepare Gradle Build
-      uses: ./.github/actions/prepare-gradle-build
-      with:
-        develocity-access-key: ${{ inputs.develocity-access-key }}
-        java-version: ${{ inputs.java-version }}
-        java-early-access: ${{ inputs.java-early-access }}
-        java-toolchain: ${{ inputs.java-toolchain }}
-    - name: Build
-      id: build
-      if: ${{ inputs.publish == 'false' }}
-      shell: bash
-      run: ./gradlew check
-    - name: Publish
-      id: publish
-      if: ${{ inputs.publish == 'true' }}
-      shell: bash
-      run: ./gradlew -PdeploymentRepository=$(pwd)/deployment-repository build publishAllPublicationsToDeploymentRepository
-    - name: Read Version From gradle.properties
-      id: read-version
-      shell: bash
-      run: |
-        version=$(sed -n 's/version=\(.*\)/\1/p' gradle.properties)
-        echo "Version is $version"
-        echo "version=$version" >> $GITHUB_OUTPUT

.github/actions/create-github-release/action.yml

@@ -1,23 +0,0 @@
-name: Create GitHub Release
-description: Create the release on GitHub with a changelog
-inputs:
-  milestone:
-    description: Name of the GitHub milestone for which a release will be created
-    required: true
-  token:
-    description: Token to use for authentication with GitHub
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Generate Changelog
-      uses: spring-io/github-changelog-generator@185319ad7eaa75b0e8e72e4b6db19c8b2cb8c4c1 #v0.0.11
-      with:
-        milestone: ${{ inputs.milestone }}
-        token: ${{ inputs.token }}
-        config-file: .github/actions/create-github-release/changelog-generator.yml
-    - name: Create GitHub Release
-      env:
-        GITHUB_TOKEN: ${{ inputs.token }}
-      shell: bash
-      run: gh release create ${{ format('v{0}', inputs.milestone) }} --notes-file changelog.md

.github/actions/prepare-gradle-build/action.yml

@@ -1,49 +0,0 @@
-name: 'Prepare Gradle Build'
-description: 'Prepares a Gradle build. Sets up Java and Gradle and configures Gradle properties'
-inputs:
-  java-version:
-    required: false
-    default: '8'
-    description: 'The Java version to use for the build'
-  java-early-access:
-    required: false
-    default: 'false'
-    description: 'Whether the Java version is in early access'
-  java-toolchain:
-    required: false
-    default: 'false'
-    description: 'Whether a Java toolchain should be used'
-  develocity-access-key:
-    required: false
-    description: 'The access key for authentication with ge.spring.io'
-runs:
-  using: composite
-  steps:
-    - name: Set Up Java
-      uses: actions/setup-java@v4
-      with:
-        distribution: ${{ inputs.java-early-access == 'true' && 'temurin' || 'liberica' }}
-        java-version: |
-          ${{ inputs.java-early-access == 'true' && format('{0}-ea', inputs.java-version) || inputs.java-version }}
-          ${{ inputs.java-toolchain == 'true' && '8' || '' }}
-    - name: Set Up Gradle
-      uses: gradle/actions/setup-gradle@d9c87d481d55275bb5441eef3fe0e46805f9ef70 # v3.5.0
-      with:
-        cache-read-only: false
-        develocity-access-key: ${{ inputs.develocity-access-key }}
-    - name: Configure Gradle Properties
-      shell: bash
-      run: |
-        mkdir -p $HOME/.gradle
-        echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
-        echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
-        echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-        echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
-    - name: Configure Toolchain Properties
-      if: ${{ inputs.java-toolchain == 'true' }}
-      shell: bash
-      run: |
-        echo toolchainVersion=${{ inputs.java-version }} >> $HOME/.gradle/gradle.properties
-        echo systemProp.org.gradle.java.installations.auto-detect=false >> $HOME/.gradle/gradle.properties
-        echo systemProp.org.gradle.java.installations.auto-download=false >> $HOME/.gradle/gradle.properties
-        echo systemProp.org.gradle.java.installations.paths=${{ format('$JAVA_HOME_{0}_X64', inputs.java-version) }} >> $HOME/.gradle/gradle.properties

.github/actions/send-notification/action.yml

@@ -1,4 +1,4 @@
-name: Send Notification
+name: Send notification
 description: Sends a Google Chat message as a notification of the job's outcome
 inputs:
   webhook-url:

.github/actions/sync-to-maven-central/action.yml

@@ -1,43 +0,0 @@
-name: Sync to Maven Central
-description: Syncs a release to Maven Central and waits for it to be available for use
-inputs:
-  jfrog-cli-config-token:
-    description: 'Config token for the JFrog CLI'
-    required: true
-  spring-framework-version:
-    description: 'The version of Spring Framework that is being synced to Central'
-    required: true
-  ossrh-s01-token-username:
-    description: 'Username for authentication with s01.oss.sonatype.org'
-    required: true
-  ossrh-s01-token-password:
-    description: 'Password for authentication with s01.oss.sonatype.org'
-    required: true
-  ossrh-s01-staging-profile:
-    description: 'Staging profile to use when syncing to Central'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Set Up JFrog CLI
-      uses: jfrog/setup-jfrog-cli@105617d23456a69a92485207c4f28ae12297581d # v4.2.1
-      env:
-        JF_ENV_SPRING: ${{ inputs.jfrog-cli-config-token }}
-    - name: Download Release Artifacts
-      shell: bash
-      run: jf rt download --spec ${{ format('{0}/artifacts.spec', github.action_path) }} --spec-vars 'buildName=${{ format('spring-framework-{0}', inputs.spring-framework-version) }};buildNumber=${{ github.run_number }}'
-    - name: Sync
-      uses: spring-io/nexus-sync-action@42477a2230a2f694f9eaa4643fa9e76b99b7ab84 # v0.0.1
-      with:
-        username: ${{ inputs.ossrh-s01-token-username }}
-        password: ${{ inputs.ossrh-s01-token-password }}
-        staging-profile-name: ${{ inputs.ossrh-s01-staging-profile }}
-        create: true
-        upload: true
-        close: true
-        release: true
-        generate-checksums: true
-    - name: Await
-      uses: ./.github/actions/await-http-resource
-      with:
-        url: ${{ format('https://repo.maven.apache.org/maven2/org/springframework/spring-context/{0}/spring-context-{0}.jar', inputs.spring-framework-version) }}

.github/actions/sync-to-maven-central/artifacts.spec

@@ -1,20 +0,0 @@
-{
-  "files": [
-    {
-      "aql": {
-        "items.find": {
-          "$and": [
-            {
-              "@build.name": "${buildName}",
-              "@build.number": "${buildNumber}",
-              "path": {
-                "$nmatch": "org/springframework/spring-*.zip"
-              }
-            }
-          ]
-        }
-      },
-      "target": "nexus/"
-    }
-  ]
-}

.github/workflows/build-and-deploy-snapshot.yml

@@ -1,4 +1,4 @@
-name: Build and Deploy Snapshot
+name: Build and deploy snapshot
 on:
   push:
     branches:
@@ -7,26 +7,43 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
   build-and-deploy-snapshot:
-    name: Build and Deploy Snapshot
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
     if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    name: Build and deploy snapshot
+    runs-on: ubuntu-latest
     steps:
-      - name: Check Out Code
-        uses: actions/checkout@v4
-      - name: Build and Publish
-        id: build-and-publish
-        uses: ./.github/actions/build
+      - name: Set up Java
+        uses: actions/setup-java@v4
         with:
-          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-          publish: true
+          distribution: 'liberica'
+          java-version: 8
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
+        with:
+          cache-read-only: false
+      - name: Configure Gradle properties
+        shell: bash
+        run: |
+          mkdir -p $HOME/.gradle
+          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
+          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
+          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
+          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
+      - name: Build and publish
+        id: build
+        env:
+          CI: 'true'
+          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
+          DEVELOCITY_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+        run: ./gradlew -PdeploymentRepository=$(pwd)/deployment-repository build publishAllPublicationsToDeploymentRepository
       - name: Deploy
-        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
+        uses: spring-io/artifactory-deploy-action@v0.0.1
         with:
           uri: 'https://repo.spring.io'
           username: ${{ secrets.ARTIFACTORY_USERNAME }}
           password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-          build-name: 'spring-framework-5.3.x'
+          build-name: ${{ format('spring-framework-{0}', github.ref_name)}}
           repository: 'libs-snapshot-local'
           folder: 'deployment-repository'
           signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
@@ -36,24 +53,11 @@ jobs:
             /**/spring-*-docs.zip::zip.type=docs
             /**/spring-*-dist.zip::zip.type=dist
             /**/spring-*-schema.zip::zip.type=schema
-      - name: Send Notification
+      - name: Send notification
         uses: ./.github/actions/send-notification
         if: always()
         with:
           webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
           status: ${{ job.status }}
-          build-scan-url: ${{ steps.build-and-publish.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | Linux | Java 8', github.ref_name) }}
-    outputs:
-      version: ${{ steps.build-and-publish.outputs.version }}
-  verify:
-    name: Verify
-    needs: build-and-deploy-snapshot
-    uses: ./.github/workflows/verify.yml
-    secrets:
-      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
-      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
-    with:
-      version: ${{ needs.build-and-deploy-snapshot.outputs.version }}
+          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
+          run-name: ${{ format('{0} | Linux | Java 8', github.ref_name) }}

.github/workflows/ci.yml

@@ -7,9 +7,6 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
   ci:
-    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
-    runs-on: ${{ matrix.os.id }}
-    timeout-minutes: 60
     if: ${{ github.repository == 'spring-projects/spring-framework' }}
     strategy:
       matrix:
@@ -28,24 +25,52 @@ jobs:
               name: Linux
             java:
               version: 8
+    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
+    runs-on: ${{ matrix.os.id }}
     steps:
+      - name: Set up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'liberica'
+          java-version: |
+            ${{ matrix.java.version }}
+            ${{ matrix.java.toolchain && '8' || '' }}
       - name: Prepare Windows runner
         if: ${{ runner.os == 'Windows' }}
         run: |
           git config --global core.autocrlf true
           git config --global core.longPaths true
           Stop-Service -name Docker
-      - name: Check Out Code
+      - name: Check out code
         uses: actions/checkout@v4
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
+        with:
+          cache-read-only: false
+      - name: Configure Gradle properties
+        shell: bash
+        run: |
+          mkdir -p $HOME/.gradle
+          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
+          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
+          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
+          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
+      - name: Configure toolchain properties
+        if: ${{ matrix.java.toolchain }}
+        shell: bash
+        run: |
+          echo toolchainVersion=${{ matrix.java.version }} >> $HOME/.gradle/gradle.properties
+          echo systemProp.org.gradle.java.installations.auto-detect=false >> $HOME/.gradle/gradle.properties
+          echo systemProp.org.gradle.java.installations.auto-download=false >> $HOME/.gradle/gradle.properties
+          echo systemProp.org.gradle.java.installations.paths=${{ format('$JAVA_HOME_{0}_X64', matrix.java.version) }} >> $HOME/.gradle/gradle.properties
       - name: Build
         id: build
-        uses: ./.github/actions/build
-        with:
-          java-version: ${{ matrix.java.version }}
-          java-early-access: ${{ matrix.java.early-access || 'false' }}
-          java-toolchain: ${{ matrix.java.toolchain }}
-          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-      - name: Send Notification
+        env:
+          CI: 'true'
+          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
+          DEVELOCITY_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+        run: ./gradlew check
+      - name: Send notification
         uses: ./.github/actions/send-notification
         if: always()
         with:

.github/workflows/gradle-wrapper-validation.yml

@@ -1,11 +1,13 @@
 name: "Validate Gradle Wrapper"
 on: [push, pull_request]
+
 permissions:
   contents: read
+
 jobs:
   validation:
-    name: "Validate Gradle Wrapper"
+    name: "Validation"
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: gradle/actions/wrapper-validation@d9c87d481d55275bb5441eef3fe0e46805f9ef70 # v3.5.0
+      - uses: gradle/wrapper-validation-action@v2

.github/workflows/release.yml

@@ -1,95 +0,0 @@
-name: Release
-on:
-  push:
-    tags:
-      - v5.3.[0-9]+
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build-and-stage-release:
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    name: Build and Stage Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@v4
-      - name: Build and Publish
-        id: build-and-publish
-        uses: ./.github/actions/build
-        with:
-          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-          publish: true
-      - name: Stage Release
-        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
-        with:
-          uri: 'https://repo.spring.io'
-          username: ${{ secrets.ARTIFACTORY_USERNAME }}
-          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-          build-name: ${{ format('spring-framework-{0}', steps.build-and-publish.outputs.version)}}
-          repository: 'libs-staging-local'
-          folder: 'deployment-repository'
-          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
-          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          artifact-properties: |
-            /**/spring-*.zip::zip.name=spring-framework,zip.deployed=false
-            /**/spring-*-docs.zip::zip.type=docs
-            /**/spring-*-dist.zip::zip.type=dist
-            /**/spring-*-schema.zip::zip.type=schema
-    outputs:
-      version: ${{ steps.build-and-publish.outputs.version }}
-  verify:
-    name: Verify
-    needs: build-and-stage-release
-    uses: ./.github/workflows/verify.yml
-    with:
-      staging: true
-      version: ${{ needs.build-and-stage-release.outputs.version }}
-    secrets:
-      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
-      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
-  sync-to-maven-central:
-    name: Sync to Maven Central
-    needs:
-      - build-and-stage-release
-      - verify
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - name: Sync to Maven Central
-        uses: ./.github/actions/sync-to-maven-central
-        with:
-          jfrog-cli-config-token: ${{ secrets.JF_ARTIFACTORY_SPRING }}
-          ossrh-s01-staging-profile: ${{ secrets.OSSRH_S01_STAGING_PROFILE }}
-          ossrh-s01-token-password: ${{ secrets.OSSRH_S01_TOKEN_PASSWORD }}
-          ossrh-s01-token-username: ${{ secrets.OSSRH_S01_TOKEN_USERNAME }}
-          spring-framework-version: ${{ needs.build-and-stage-release.outputs.version }}
-  promote-release:
-    name: Promote Release
-    needs:
-      - build-and-stage-release
-      - sync-to-maven-central
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up JFrog CLI
-        uses: jfrog/setup-jfrog-cli@105617d23456a69a92485207c4f28ae12297581d # v4.2.1
-        env:
-          JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
-      - name: Promote build
-        run: jfrog rt build-promote ${{ format('spring-framework-{0}', needs.build-and-stage-release.outputs.version)}} ${{ github.run_number }} libs-release-local
-  create-github-release:
-    name: Create GitHub Release
-    needs:
-      - build-and-stage-release
-      - promote-release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - name: Create GitHub Release
-        uses: ./.github/actions/create-github-release
-        with:
-          milestone: ${{ needs.build-and-stage-release.outputs.version }}
-          token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}

.github/workflows/verify.yml

@@ -1,71 +0,0 @@
-name: Verify
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      staging:
-        required: false
-        default: false
-        type: boolean
-    secrets:
-      repository-username:
-        required: false
-      repository-password:
-        required: false
-      google-chat-webhook-url:
-        required: true
-      token:
-        required: true
-jobs:
-  verify:
-    name: Verify
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Release Verification Tests
-        uses: actions/checkout@v4
-        with:
-          repository: spring-projects/spring-framework-release-verification
-          ref: 'v0.0.2'
-          token: ${{ secrets.token }}
-      - name: Check Out Send Notification Action
-        uses: actions/checkout@v4
-        with:
-          path: spring-framework
-          sparse-checkout: .github/actions/send-notification
-      - name: Set Up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: 8
-      - name: Set Up Gradle
-        uses: gradle/actions/setup-gradle@dbbdc275be76ac10734476cc723d82dfe7ec6eda # v3.4.2
-        with:
-          cache-read-only: false
-      - name: Configure Gradle Properties
-        shell: bash
-        run: |
-          mkdir -p $HOME/.gradle
-          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-      - name: Run Release Verification Tests
-        env:
-          RVT_VERSION: ${{ inputs.version }}
-          RVT_RELEASE_TYPE: oss
-          RVT_STAGING: ${{ inputs.staging }}
-          RVT_OSS_REPOSITORY_USERNAME: ${{ secrets.repository-username }}
-          RVT_OSS_REPOSITORY_PASSWORD: ${{ secrets.repository-password }}
-        run: ./gradlew spring-framework-release-verification-tests:test
-      - name: Upload Build Reports on Failure
-        uses: actions/upload-artifact@v4
-        if: failure()
-        with:
-          name: build-reports
-          path: '**/build/reports/'
-      - name: Send Notification
-        uses: ./spring-framework/.github/actions/send-notification
-        if: failure()
-        with:
-          webhook-url: ${{ secrets.google-chat-webhook-url }}
-          status: ${{ job.status }}
-          run-name: ${{ format('{0} | Verification | {1}', github.ref_name, inputs.version) }}

build.gradle

@@ -28,8 +28,8 @@ configure(allprojects) { project ->
 	dependencyManagement {
 		imports {
 			mavenBom "com.fasterxml.jackson:jackson-bom:2.12.7"
-			mavenBom "io.netty:netty-bom:4.1.112.Final"
-			mavenBom "io.projectreactor:reactor-bom:2020.0.47"
+			mavenBom "io.netty:netty-bom:4.1.109.Final"
+			mavenBom "io.projectreactor:reactor-bom:2020.0.44"
 			mavenBom "io.r2dbc:r2dbc-bom:Arabba-SR13"
 			mavenBom "io.rsocket:rsocket-bom:1.1.3"
 			mavenBom "org.eclipse.jetty:jetty-bom:9.4.54.v20240208"
@@ -362,7 +362,7 @@ configure([rootProject] + javaProjects) { project ->
 		// JSR-305 only used for non-required meta-annotations
 		compileOnly("com.google.code.findbugs:jsr305")
 		testCompileOnly("com.google.code.findbugs:jsr305")
-		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.42")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.41")
 	}
 
 	ext.javadocLinks = [

ci/README.adoc

@@ -0,0 +1,59 @@
+== Spring Framework Concourse pipeline
+
+NOTE: CI is being migrated to GitHub Actions.
+
+The Spring Framework uses https://concourse-ci.org/[Concourse] for its CI build and other automated tasks.
+The Spring team has a dedicated Concourse instance available at https://ci.spring.io with a build pipeline
+for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-5.3.x[Spring Framework 5.3.x].
+
+=== Setting up your development environment
+
+If you're part of the Spring Framework project on GitHub, you can get access to CI management features.
+First, you need to go to https://ci.spring.io and install the client CLI for your platform (see bottom right of the screen).
+
+You can then login with the instance using:
+
+[source]
+----
+$ fly -t spring login -n spring-framework -c https://ci.spring.io
+----
+
+Once logged in, you should get something like:
+
+[source]
+----
+$ fly ts
+name                  url                   team                  expiry
+spring                https://ci.spring.io  spring-framework      Wed, 25 Mar 2020 17:45:26 UTC
+----
+
+=== Pipeline configuration and structure
+
+The build pipelines are described in `pipeline.yml` file.
+
+This file is listing Concourse resources, i.e. build inputs and outputs such as container images, artifact repositories, source repositories, notification services, etc.
+
+It also describes jobs (a job is a sequence of inputs, tasks and outputs); jobs are organized by groups.
+
+The `pipeline.yml` definition contains `((parameters))` which are loaded from the `parameters.yml` file or from our https://docs.cloudfoundry.org/credhub/[credhub instance].
+
+You'll find in this folder the following resources:
+
+* `pipeline.yml` the build pipeline
+* `parameters.yml` the build parameters used for the pipeline
+* `images/` holds the container images definitions used in this pipeline
+* `scripts/` holds the build scripts that ship within the CI container images
+* `tasks` contains the task definitions used in the main `pipeline.yml`
+
+=== Updating the build pipeline
+
+Updating files on the repository is not enough to update the build pipeline, as changes need to be applied.
+
+The pipeline can be deployed using the following command:
+
+[source]
+----
+$ fly -t spring set-pipeline -p spring-framework-5.3.x -c ci/pipeline.yml -l ci/parameters.yml
+----
+
+NOTE: This assumes that you have credhub integration configured with the appropriate secrets.

ci/config/changelog-generator.yml

@@ -17,12 +17,4 @@ changelog:
         - "type: dependency-upgrade"
   contributors:
     exclude:
-      names:
-        - "bclozel"
-        - "jhoeller"
-        - "poutsma"
-        - "rstoyanchev"
-        - "sbrannen"
-        - "sdeleuze"
-        - "simonbasle"
-        - "snicoll"
+      names: ["bclozel", "jhoeller", "poutsma", "rstoyanchev", "sbrannen", "sdeleuze", "snicoll", "simonbasle"]

ci/config/release-scripts.yml

@@ -0,0 +1,10 @@
+logging:
+  level:
+    io.spring.concourse: DEBUG
+spring:
+  main:
+    banner-mode: off
+sonatype:
+  exclude:
+    - 'build-info\.json'
+    - '.*\.zip'

ci/images/README.adoc

@@ -0,0 +1,21 @@
+== CI Images
+
+These images are used by CI to run the actual builds.
+
+To build the image locally run the following from this directory:
+
+----
+$ docker build --no-cache -f <image-folder>/Dockerfile .
+----
+
+For example
+
+----
+$ docker build --no-cache -f spring-framework-ci-image/Dockerfile .
+----
+
+To test run:
+
+----
+$ docker run -it --entrypoint /bin/bash <SHA>
+----

ci/images/ci-image/Dockerfile

@@ -0,0 +1,10 @@
+FROM ubuntu:jammy-20240125
+
+ADD setup.sh /setup.sh
+ADD get-jdk-url.sh /get-jdk-url.sh
+RUN ./setup.sh java8
+
+ENV JAVA_HOME /opt/openjdk/java8
+ENV JDK17 /opt/openjdk/java17
+
+ENV PATH $JAVA_HOME/bin:$PATH

ci/images/get-jdk-url.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+	java8)
+		 echo "https://github.com/bell-sw/Liberica/releases/download/8u402%2B7/bellsoft-jdk8u402+7-linux-amd64.tar.gz"
+	;;
+	java17)
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.10%2B13/bellsoft-jdk17.0.10+13-linux-amd64.tar.gz"
+	;;
+	*)
+		echo $"Unknown java version"
+		exit 1
+esac

ci/images/setup.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+set -ex
+
+###########################################################
+# UTILS
+###########################################################
+
+export DEBIAN_FRONTEND=noninteractive
+apt-get update
+apt-get install --no-install-recommends -y tzdata ca-certificates net-tools libxml2-utils git curl libudev1 libxml2-utils iptables iproute2 jq fontconfig
+ln -fs /usr/share/zoneinfo/UTC /etc/localtime
+dpkg-reconfigure --frontend noninteractive tzdata
+rm -rf /var/lib/apt/lists/*
+
+curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/concourse-java.sh > /opt/concourse-java.sh
+
+###########################################################
+# JAVA
+###########################################################
+
+mkdir -p /opt/openjdk
+pushd /opt/openjdk > /dev/null
+for jdk in java8 java17
+do
+  JDK_URL=$( /get-jdk-url.sh $jdk )
+  mkdir $jdk
+  pushd $jdk > /dev/null
+  curl -L ${JDK_URL} | tar zx --strip-components=1
+  test -f bin/java
+  test -f bin/javac
+  popd > /dev/null
+done
+popd
+
+###########################################################
+# GRADLE ENTERPRISE
+###########################################################
+cd /
+mkdir ~/.gradle
+echo 'systemProp.user.name=concourse' > ~/.gradle/gradle.properties

ci/parameters.yml

@@ -0,0 +1,10 @@
+github-repo: "https://github.com/spring-projects/spring-framework.git"
+github-repo-name: "spring-projects/spring-framework"
+sonatype-staging-profile: "org.springframework"
+docker-hub-organization: "springci"
+artifactory-server: "https://repo.spring.io"
+branch: "5.3.x"
+milestone: "5.3.x"
+build-name: "spring-framework"
+pipeline-name: "spring-framework"
+concourse-url: "https://ci.spring.io"

ci/pipeline.yml

@@ -0,0 +1,291 @@
+anchors:
+  git-repo-resource-source: &git-repo-resource-source
+    uri: ((github-repo))
+    username: ((github-username))
+    password: ((github-ci-release-token))
+    branch: ((branch))
+  gradle-enterprise-task-params: &gradle-enterprise-task-params
+    DEVELOCITY_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
+  sonatype-task-params: &sonatype-task-params
+    SONATYPE_USERNAME: ((sonatype-username))
+    SONATYPE_PASSWORD: ((sonatype-password))
+    SONATYPE_URL: ((sonatype-url))
+    SONATYPE_STAGING_PROFILE: ((sonatype-staging-profile))
+  artifactory-task-params: &artifactory-task-params
+    ARTIFACTORY_SERVER: ((artifactory-server))
+    ARTIFACTORY_USERNAME: ((artifactory-username))
+    ARTIFACTORY_PASSWORD: ((artifactory-password))
+  build-project-task-params: &build-project-task-params
+      BRANCH: ((branch))
+      <<: *gradle-enterprise-task-params
+  docker-resource-source: &docker-resource-source
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+  changelog-task-params: &changelog-task-params
+    name: generated-changelog/tag
+    tag: generated-changelog/tag
+    body: generated-changelog/changelog.md
+  github-task-params: &github-task-params
+    GITHUB_USERNAME: ((github-username))
+    GITHUB_TOKEN: ((github-ci-release-token))
+
+resource_types:
+- name: registry-image
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: concourse/registry-image-resource
+    tag: 1.8.0
+- name: artifactory-resource
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: springio/artifactory-resource
+    tag: 0.0.18
+- name: github-release
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: concourse/github-release-resource
+    tag: 1.8.0
+- name: github-status-resource
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: dpb587/github-status-resource
+    tag: master
+resources:
+- name: git-repo
+  type: git
+  icon: github
+  source:
+    <<: *git-repo-resource-source
+- name: ci-images-git-repo
+  type: git
+  icon: github
+  source:
+    uri: ((github-repo))
+    branch: ((branch))
+    paths: ["ci/images/*"]
+- name: ci-image
+  type: registry-image
+  icon: docker
+  source:
+    <<: *docker-resource-source
+    repository: ((docker-hub-organization))/spring-framework-ci
+    tag: ((milestone))
+- name: artifactory-repo
+  type: artifactory-resource
+  icon: package-variant
+  source:
+    uri: ((artifactory-server))
+    username: ((artifactory-username))
+    password: ((artifactory-password))
+    build_name: ((build-name))
+- name: github-pre-release
+  type: github-release
+  icon: briefcase-download-outline
+  source:
+    owner: spring-projects
+    repository: spring-framework
+    access_token: ((github-ci-release-token))
+    pre_release: true
+    release: false
+- name: github-release
+  type: github-release
+  icon: briefcase-download
+  source:
+    owner: spring-projects
+    repository: spring-framework
+    access_token: ((github-ci-release-token))
+    pre_release: false
+jobs:
+- name: build-ci-images
+  plan:
+    - get: git-repo
+    - get: ci-images-git-repo
+      trigger: true
+    - task: build-ci-image
+      privileged: true
+      file: git-repo/ci/tasks/build-ci-image.yml
+      output_mapping:
+        image: ci-image
+      vars:
+        ci-image-name: ci-image
+        <<: *docker-resource-source
+    - put: ci-image
+      params:
+        image: ci-image/image.tar
+- name: stage-milestone
+  serial: true
+  plan:
+  - get: ci-image
+  - get: git-repo
+    trigger: false
+  - task: stage
+    image: ci-image
+    file: git-repo/ci/tasks/stage-version.yml
+    params:
+      RELEASE_TYPE: M
+      <<: *gradle-enterprise-task-params
+  - put: artifactory-repo
+    params: &artifactory-params
+      signing_key: ((signing-key))
+      signing_passphrase: ((signing-passphrase))
+      repo: libs-staging-local
+      folder: distribution-repository
+      build_uri: "https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}"
+      build_number: "${BUILD_PIPELINE_NAME}-${BUILD_JOB_NAME}-${BUILD_NAME}"
+      disable_checksum_uploads: true
+      threads: 8
+      artifact_set:
+      - include:
+        - "/**/spring-*.zip"
+        properties:
+          "zip.name": "spring-framework"
+          "zip.displayname": "Spring Framework"
+          "zip.deployed": "false"
+      - include:
+        - "/**/spring-*-docs.zip"
+        properties:
+          "zip.type": "docs"
+      - include:
+        - "/**/spring-*-dist.zip"
+        properties:
+          "zip.type": "dist"
+      - include:
+        - "/**/spring-*-schema.zip"
+        properties:
+          "zip.type": "schema"
+  - put: git-repo
+    params:
+      repository: stage-git-repo
+- name: promote-milestone
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-milestone]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *artifactory-task-params
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *github-task-params
+    - put: github-pre-release
+      params:
+        <<: *changelog-task-params
+- name: stage-rc
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - task: stage
+      image: ci-image
+      file: git-repo/ci/tasks/stage-version.yml
+      params:
+        RELEASE_TYPE: RC
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+    - put: git-repo
+      params:
+        repository: stage-git-repo
+- name: promote-rc
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-rc]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: RC
+        <<: *artifactory-task-params
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: RC
+        <<: *github-task-params
+    - put: github-pre-release
+      params:
+        <<: *changelog-task-params
+- name: stage-release
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - task: stage
+      image: ci-image
+      file: git-repo/ci/tasks/stage-version.yml
+      params:
+        RELEASE_TYPE: RELEASE
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+    - put: git-repo
+      params:
+        repository: stage-git-repo
+- name: promote-release
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-release]
+      params:
+        download_artifacts: true
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: RELEASE
+        <<: *artifactory-task-params
+        <<: *sonatype-task-params
+- name: create-github-release
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: artifactory-repo
+      trigger: true
+      passed: [promote-release]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: RELEASE
+        <<: *github-task-params
+    - put: github-release
+      params:
+        <<: *changelog-task-params
+
+groups:
+- name: "releases"
+  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
+- name: "ci-images"
+  jobs: ["build-ci-images"]

ci/scripts/common.sh

@@ -0,0 +1,2 @@
+source /opt/concourse-java.sh
+setup_symlinks

ci/scripts/generate-changelog.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+CONFIG_DIR=git-repo/ci/config
+version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
+
+java -jar /github-changelog-generator.jar \
+  --spring.config.location=${CONFIG_DIR}/changelog-generator.yml \
+  ${version} generated-changelog/changelog.md
+
+echo ${version} > generated-changelog/version
+echo v${version} > generated-changelog/tag

ci/scripts/promote-version.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+CONFIG_DIR=git-repo/ci/config
+
+version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
+export BUILD_INFO_LOCATION=$(pwd)/artifactory-repo/build-info.json
+
+java -jar /concourse-release-scripts.jar \
+  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
+  publishToCentral $RELEASE_TYPE $BUILD_INFO_LOCATION artifactory-repo || { exit 1; }
+
+java -jar /concourse-release-scripts.jar \
+  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
+  promote $RELEASE_TYPE $BUILD_INFO_LOCATION || { exit 1; }
+
+echo "Promotion complete"
+echo $version > version/version

ci/scripts/stage-version.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+repository=$(pwd)/distribution-repository
+
+pushd git-repo > /dev/null
+git fetch --tags --all > /dev/null
+popd > /dev/null
+
+git clone git-repo stage-git-repo > /dev/null
+
+pushd stage-git-repo > /dev/null
+
+snapshotVersion=$( awk -F '=' '$1 == "version" { print $2 }' gradle.properties )
+if [[ $RELEASE_TYPE = "M" ]]; then
+	stageVersion=$( get_next_milestone_release $snapshotVersion)
+	nextVersion=$snapshotVersion
+elif [[ $RELEASE_TYPE = "RC" ]]; then
+	stageVersion=$( get_next_rc_release $snapshotVersion)
+	nextVersion=$snapshotVersion
+elif [[ $RELEASE_TYPE = "RELEASE" ]]; then
+	stageVersion=$( get_next_release $snapshotVersion)
+	nextVersion=$( bump_version_number $snapshotVersion)
+else
+	echo "Unknown release type $RELEASE_TYPE" >&2; exit 1;
+fi
+
+echo "Staging $stageVersion (next version will be $nextVersion)"
+sed -i "s/version=$snapshotVersion/version=$stageVersion/" gradle.properties
+
+git config user.name "Spring Builds" > /dev/null
+git config user.email "spring-builds@users.noreply.github.com" > /dev/null
+git add gradle.properties > /dev/null
+git commit -m"Release v$stageVersion" > /dev/null
+git tag -a "v$stageVersion" -m"Release v$stageVersion" > /dev/null
+
+./gradlew --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
+
+git reset --hard HEAD^ > /dev/null
+if [[ $nextVersion != $snapshotVersion ]]; then
+	echo "Setting next development version (v$nextVersion)"
+	sed -i "s/version=$snapshotVersion/version=$nextVersion/" gradle.properties
+	git add gradle.properties > /dev/null
+	git commit -m"Next development version (v$nextVersion)" > /dev/null
+fi;
+
+echo "Staging Complete"
+
+popd > /dev/null

ci/tasks/build-ci-image.yml

@@ -0,0 +1,30 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: concourse/oci-build-task
+    tag: 0.10.0
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+  - name: ci-images-git-repo
+outputs:
+  - name: image
+caches:
+  - path: ci-image-cache
+params:
+  CONTEXT: ci-images-git-repo/ci/images
+  DOCKERFILE: ci-images-git-repo/ci/images/ci-image/Dockerfile
+  DOCKER_HUB_AUTH: ((docker-hub-auth))
+run:
+  path: /bin/sh
+  args:
+    - "-c"
+    - |
+      mkdir -p /root/.docker
+      cat > /root/.docker/config.json <<EOF
+      { "auths": { "https://index.docker.io/v1/": { "auth": "$DOCKER_HUB_AUTH" }}}
+      EOF
+      build
+

ci/tasks/generate-changelog.yml

@@ -0,0 +1,22 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: springio/github-changelog-generator
+    tag: '0.0.8'
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+- name: git-repo
+- name: artifactory-repo
+outputs:
+- name: generated-changelog
+params:
+  GITHUB_ORGANIZATION:
+  GITHUB_REPO:
+  GITHUB_USERNAME:
+  GITHUB_TOKEN:
+  RELEASE_TYPE:
+run:
+  path: git-repo/ci/scripts/generate-changelog.sh

ci/tasks/promote-version.yml

@@ -0,0 +1,25 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: springio/concourse-release-scripts
+    tag: '0.4.0'
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+- name: git-repo
+- name: artifactory-repo
+outputs:
+- name: version
+params:
+  RELEASE_TYPE:
+  ARTIFACTORY_SERVER:
+  ARTIFACTORY_USERNAME:
+  ARTIFACTORY_PASSWORD:
+  SONATYPE_USER:
+  SONATYPE_PASSWORD:
+  SONATYPE_URL:
+  SONATYPE_STAGING_PROFILE:
+run:
+  path: git-repo/ci/scripts/promote-version.sh

ci/tasks/stage-version.yml

@@ -0,0 +1,17 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: stage-git-repo
+- name: distribution-repository
+params:
+  RELEASE_TYPE:
+  CI: true
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+caches:
+- path: gradle
+run:
+  path: git-repo/ci/scripts/stage-version.sh

gradle.properties

@@ -1,4 +1,4 @@
-version=5.3.39-SNAPSHOT
+version=5.3.35
 org.gradle.jvmargs=-Xmx2048m
 org.gradle.caching=true
 org.gradle.parallel=true

integration-tests/src/test/java/org/springframework/cache/annotation/EnableCachingIntegrationTests.java

@@ -63,7 +63,7 @@ class EnableCachingIntegrationTests {
 		// attempt was made to look up the AJ aspect. It's due to classpath issues
 		// in .integration-tests that it's not found.
 		assertThatException().isThrownBy(ctx::refresh)
-				.withMessageContaining("AspectJCachingConfiguration");
+			.withMessageContaining("AspectJCachingConfiguration");
 	}
 
 

integration-tests/src/test/java/org/springframework/core/env/EnvironmentSystemIntegrationTests.java

@@ -561,7 +561,8 @@ public class EnvironmentSystemIntegrationTests {
 		{
 			ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
 			ctx.getEnvironment().setRequiredProperties("foo", "bar");
-			assertThatExceptionOfType(MissingRequiredPropertiesException.class).isThrownBy(ctx::refresh);
+			assertThatExceptionOfType(MissingRequiredPropertiesException.class).isThrownBy(
+					ctx::refresh);
 		}
 
 		{

integration-tests/src/test/java/org/springframework/transaction/annotation/EnableTransactionManagementIntegrationTests.java

@@ -97,7 +97,7 @@ class EnableTransactionManagementIntegrationTests {
 		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.
+		// in .integration-tests that it's not found.
 		assertThatException()
 			.isThrownBy(ctx::refresh)
 			.withMessageContaining("AspectJJtaTransactionManagementConfiguration");

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJExpressionPointcut.java

@@ -18,7 +18,6 @@ package org.springframework.aop.aspectj;
 
 import java.io.IOException;
 import java.io.ObjectInputStream;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Arrays;
@@ -43,7 +42,6 @@ import org.aspectj.weaver.tools.PointcutParameter;
 import org.aspectj.weaver.tools.PointcutParser;
 import org.aspectj.weaver.tools.PointcutPrimitive;
 import org.aspectj.weaver.tools.ShadowMatch;
-import org.aspectj.weaver.tools.UnsupportedPointcutPrimitiveException;
 
 import org.springframework.aop.ClassFilter;
 import org.springframework.aop.IntroductionAwareMethodMatcher;
@@ -87,8 +85,6 @@ import org.springframework.util.StringUtils;
 public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
 
-	private static final String AJC_MAGIC = "ajc$";
-
 	private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<>();
 
 	static {
@@ -110,8 +106,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	@Nullable
 	private Class<?> pointcutDeclarationScope;
 
-	private boolean aspectCompiledByAjc;
-
 	private String[] pointcutParameterNames = new String[0];
 
 	private Class<?>[] pointcutParameterTypes = new Class<?>[0];
@@ -125,8 +119,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	@Nullable
 	private transient PointcutExpression pointcutExpression;
 
-	private transient boolean pointcutParsingFailed = false;
-
 	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<>(32);
 
 
@@ -143,7 +135,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * @param paramTypes the parameter types for the pointcut
 	 */
 	public AspectJExpressionPointcut(Class<?> declarationScope, String[] paramNames, Class<?>[] paramTypes) {
-		setPointcutDeclarationScope(declarationScope);
+		this.pointcutDeclarationScope = declarationScope;
 		if (paramNames.length != paramTypes.length) {
 			throw new IllegalStateException(
 					"Number of pointcut parameter names must match number of pointcut parameter types");
@@ -158,7 +150,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 */
 	public void setPointcutDeclarationScope(Class<?> pointcutDeclarationScope) {
 		this.pointcutDeclarationScope = pointcutDeclarationScope;
-		this.aspectCompiledByAjc = compiledByAjc(pointcutDeclarationScope);
 	}
 
 	/**
@@ -283,15 +274,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	@Override
 	public boolean matches(Class<?> targetClass) {
-		if (this.pointcutParsingFailed) {
-			// Pointcut parsing failed before below -> avoid trying again.
-			return false;
-		}
-		if (this.aspectCompiledByAjc && compiledByAjc(targetClass)) {
-			// ajc-compiled aspect class for ajc-compiled target class -> already weaved.
-			return false;
-		}
-
 		try {
 			try {
 				return obtainPointcutExpression().couldMatchJoinPointsInType(targetClass);
@@ -305,11 +287,8 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 				}
 			}
 		}
-		catch (IllegalArgumentException | IllegalStateException | UnsupportedPointcutPrimitiveException ex) {
-			this.pointcutParsingFailed = true;
-			if (logger.isDebugEnabled()) {
-				logger.debug("Pointcut parser rejected expression [" + getExpression() + "]: " + ex);
-			}
+		catch (IllegalArgumentException | IllegalStateException ex) {
+			throw ex;
 		}
 		catch (Throwable ex) {
 			logger.debug("PointcutExpression matching rejected target class", ex);
@@ -543,16 +522,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		return shadowMatch;
 	}
 
-	private static boolean compiledByAjc(Class<?> clazz) {
-		for (Field field : clazz.getDeclaredFields()) {
-			if (field.getName().startsWith(AJC_MAGIC)) {
-				return true;
-			}
-		}
-		Class<?> superclass = clazz.getSuperclass();
-		return (superclass != null && compiledByAjc(superclass));
-	}
-
 
 	@Override
 	public boolean equals(@Nullable Object other) {

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/BeanFactoryAspectJAdvisorsBuilder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -22,12 +22,9 @@ import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 import org.aspectj.lang.reflect.PerClauseKind;
 
 import org.springframework.aop.Advisor;
-import org.springframework.aop.framework.AopConfigException;
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.ListableBeanFactory;
 import org.springframework.lang.Nullable;
@@ -43,8 +40,6 @@ import org.springframework.util.Assert;
  */
 public class BeanFactoryAspectJAdvisorsBuilder {
 
-	private static final Log logger = LogFactory.getLog(BeanFactoryAspectJAdvisorsBuilder.class);
-
 	private final ListableBeanFactory beanFactory;
 
 	private final AspectJAdvisorFactory advisorFactory;
@@ -107,37 +102,30 @@ public class BeanFactoryAspectJAdvisorsBuilder {
 							continue;
 						}
 						if (this.advisorFactory.isAspect(beanType)) {
-							try {
-								AspectMetadata amd = new AspectMetadata(beanType, beanName);
-								if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
-									MetadataAwareAspectInstanceFactory factory =
-											new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
-									List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
-									if (this.beanFactory.isSingleton(beanName)) {
-										this.advisorsCache.put(beanName, classAdvisors);
-									}
-									else {
-										this.aspectFactoryCache.put(beanName, factory);
-									}
-									advisors.addAll(classAdvisors);
+							aspectNames.add(beanName);
+							AspectMetadata amd = new AspectMetadata(beanType, beanName);
+							if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
+								MetadataAwareAspectInstanceFactory factory =
+										new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
+								List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
+								if (this.beanFactory.isSingleton(beanName)) {
+									this.advisorsCache.put(beanName, classAdvisors);
 								}
 								else {
-									// Per target or per this.
-									if (this.beanFactory.isSingleton(beanName)) {
-										throw new IllegalArgumentException("Bean with name '" + beanName +
-												"' is a singleton, but aspect instantiation model is not singleton");
-									}
-									MetadataAwareAspectInstanceFactory factory =
-											new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
 									this.aspectFactoryCache.put(beanName, factory);
-									advisors.addAll(this.advisorFactory.getAdvisors(factory));
 								}
-								aspectNames.add(beanName);
+								advisors.addAll(classAdvisors);
 							}
-							catch (IllegalArgumentException | IllegalStateException | AopConfigException ex) {
-								if (logger.isDebugEnabled()) {
-									logger.debug("Ignoring incompatible aspect [" + beanType.getName() + "]: " + ex);
+							else {
+								// Per target or per this.
+								if (this.beanFactory.isSingleton(beanName)) {
+									throw new IllegalArgumentException("Bean with name '" + beanName +
+											"' is a singleton, but aspect instantiation model is not singleton");
 								}
+								MetadataAwareAspectInstanceFactory factory =
+										new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
+								this.aspectFactoryCache.put(beanName, factory);
+								advisors.addAll(this.advisorFactory.getAdvisors(factory));
 							}
 						}
 					}

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -50,7 +50,6 @@ import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.converter.ConvertingComparator;
 import org.springframework.lang.Nullable;
-import org.springframework.util.ClassUtils;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.ReflectionUtils.MethodFilter;
 import org.springframework.util.StringUtils;
@@ -134,19 +133,17 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 
 		List<Advisor> advisors = new ArrayList<>();
 		for (Method method : getAdvisorMethods(aspectClass)) {
-			if (method.equals(ClassUtils.getMostSpecificMethod(method, aspectClass))) {
-				// Prior to Spring Framework 5.2.7, advisors.size() was supplied as the declarationOrderInAspect
-				// to getAdvisor(...) to represent the "current position" in the declared methods list.
-				// However, since Java 7 the "current position" is not valid since the JDK no longer
-				// returns declared methods in the order in which they are declared in the source code.
-				// Thus, we now hard code the declarationOrderInAspect to 0 for all advice methods
-				// discovered via reflection in order to support reliable advice ordering across JVM launches.
-				// Specifically, a value of 0 aligns with the default value used in
-				// AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor).
-				Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
-				if (advisor != null) {
-					advisors.add(advisor);
-				}
+			// Prior to Spring Framework 5.2.7, advisors.size() was supplied as the declarationOrderInAspect
+			// to getAdvisor(...) to represent the "current position" in the declared methods list.
+			// However, since Java 7 the "current position" is not valid since the JDK no longer
+			// returns declared methods in the order in which they are declared in the source code.
+			// Thus, we now hard code the declarationOrderInAspect to 0 for all advice methods
+			// discovered via reflection in order to support reliable advice ordering across JVM launches.
+			// Specifically, a value of 0 aligns with the default value used in
+			// AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor).
+			Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
+			if (advisor != null) {
+				advisors.add(advisor);
 			}
 		}
 
@@ -213,16 +210,8 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 			return null;
 		}
 
-		try {
-			return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
-					this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
-		}
-		catch (IllegalArgumentException | IllegalStateException ex) {
-			if (logger.isDebugEnabled()) {
-				logger.debug("Ignoring incompatible advice method: " + candidateAdviceMethod, ex);
-			}
-			return null;
-		}
+		return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
+				this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
 	}
 
 	@Nullable

spring-aop/src/test/java/org/springframework/aop/aspectj/AspectJExpressionPointcutTests.java

@@ -39,13 +39,13 @@ import org.springframework.beans.testfixture.beans.TestBean;
 import org.springframework.beans.testfixture.beans.subpkg.DeepBean;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 
 /**
  * @author Rob Harrop
  * @author Rod Johnson
  * @author Chris Beams
- * @author Juergen Hoeller
  */
 public class AspectJExpressionPointcutTests {
 
@@ -244,7 +244,7 @@ public class AspectJExpressionPointcutTests {
 	@Test
 	public void testInvalidExpression() {
 		String expression = "execution(void org.springframework.beans.testfixture.beans.TestBean.setSomeNumber(Number) && args(Double)";
-		assertThat(getPointcut(expression).getClassFilter().matches(Object.class)).isFalse();
+		assertThatIllegalArgumentException().isThrownBy(() -> getPointcut(expression).getClassFilter().matches(Object.class));
 	}
 
 	private TestBean getAdvisedProxy(String pointcutExpression, CallCountingInterceptor interceptor) {

spring-aop/src/test/java/org/springframework/aop/aspectj/annotation/AbstractAspectJAdvisorFactoryTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -37,6 +37,7 @@ import org.aspectj.lang.annotation.DeclareParents;
 import org.aspectj.lang.annotation.DeclarePrecedence;
 import org.aspectj.lang.annotation.Pointcut;
 import org.aspectj.lang.reflect.MethodSignature;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import test.aop.DefaultLockable;
 import test.aop.Lockable;
@@ -75,24 +76,25 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 
 	/**
 	 * To be overridden by concrete test subclasses.
+	 * @return the fixture
 	 */
 	protected abstract AspectJAdvisorFactory getFixture();
 
 
 	@Test
 	void rejectsPerCflowAspect() {
-		assertThatExceptionOfType(AopConfigException.class)
-				.isThrownBy(() -> getFixture().getAdvisors(
+		assertThatExceptionOfType(AopConfigException.class).isThrownBy(() ->
+				getFixture().getAdvisors(
 						new SingletonMetadataAwareAspectInstanceFactory(new PerCflowAspect(), "someBean")))
-				.withMessageContaining("PERCFLOW");
+			.withMessageContaining("PERCFLOW");
 	}
 
 	@Test
 	void rejectsPerCflowBelowAspect() {
-		assertThatExceptionOfType(AopConfigException.class)
-				.isThrownBy(() -> getFixture().getAdvisors(
-						new SingletonMetadataAwareAspectInstanceFactory(new PerCflowBelowAspect(), "someBean")))
-				.withMessageContaining("PERCFLOWBELOW");
+		assertThatExceptionOfType(AopConfigException.class).isThrownBy(() ->
+					getFixture().getAdvisors(
+							new SingletonMetadataAwareAspectInstanceFactory(new PerCflowBelowAspect(), "someBean")))
+			.withMessageContaining("PERCFLOWBELOW");
 	}
 
 	@Test
@@ -383,7 +385,8 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 		assertThat(lockable.locked()).as("Already locked").isTrue();
 		lockable.lock();
 		assertThat(lockable.locked()).as("Real target ignores locking").isTrue();
-		assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(lockable::unlock);
+		assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() ->
+				lockable.unlock());
 	}
 
 	@Test
@@ -410,7 +413,9 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 		lockable.locked();
 	}
 
+	// TODO: Why does this test fail? It hasn't been run before, so it maybe never actually passed...
 	@Test
+	@Disabled
 	void introductionWithArgumentBinding() {
 		TestBean target = new TestBean();
 
@@ -518,16 +523,6 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 		assertThat(aspect.invocations).containsExactly("around - start", "before", "after throwing", "after", "around - end");
 	}
 
-	@Test
-	void parentAspect() {
-		TestBean target = new TestBean("Jane", 42);
-		MetadataAwareAspectInstanceFactory aspectInstanceFactory = new SingletonMetadataAwareAspectInstanceFactory(
-				new IncrementingAspect(), "incrementingAspect");
-		ITestBean proxy = (ITestBean) createProxy(target,
-				getFixture().getAdvisors(aspectInstanceFactory), ITestBean.class);
-		assertThat(proxy.getAge()).isEqualTo(86); // (42 + 1) * 2
-	}
-
 	@Test
 	void failureWithoutExplicitDeclarePrecedence() {
 		TestBean target = new TestBean();
@@ -652,7 +647,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 	static class NamedPointcutAspectWithFQN {
 
 		@SuppressWarnings("unused")
-		private final ITestBean fieldThatShouldBeIgnoredBySpringAtAspectJProcessing = new TestBean();
+		private ITestBean fieldThatShouldBeIgnoredBySpringAtAspectJProcessing = new TestBean();
 
 		@Pointcut("execution(* getAge())")
 		void getAge() {
@@ -772,31 +767,6 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 	}
 
 
-	@Aspect
-	abstract static class DoublingAspect {
-
-		@Around("execution(* getAge())")
-		public Object doubleAge(ProceedingJoinPoint pjp) throws Throwable {
-			return ((int) pjp.proceed()) * 2;
-		}
-	}
-
-
-	@Aspect
-	static class IncrementingAspect extends DoublingAspect {
-
-		@Override
-		public Object doubleAge(ProceedingJoinPoint pjp) throws Throwable {
-			return ((int) pjp.proceed()) * 2;
-		}
-
-		@Around("execution(* getAge())")
-		public int incrementAge(ProceedingJoinPoint pjp) throws Throwable {
-			return ((int) pjp.proceed()) + 1;
-		}
-	}
-
-
 	@Aspect
 	private static class InvocationTrackingAspect {
 
@@ -854,7 +824,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 
 		@Around("getAge()")
 		int preventExecution(ProceedingJoinPoint pjp) {
-			return 42;
+			return 666;
 		}
 	}
 
@@ -874,7 +844,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 
 		@Around("getAge()")
 		int preventExecution(ProceedingJoinPoint pjp) {
-			return 42;
+			return 666;
 		}
 	}
 
@@ -1096,7 +1066,7 @@ class PerThisAspect {
 
 	// Just to check that this doesn't cause problems with introduction processing
 	@SuppressWarnings("unused")
-	private final ITestBean fieldThatShouldBeIgnoredBySpringAtAspectJProcessing = new TestBean();
+	private ITestBean fieldThatShouldBeIgnoredBySpringAtAspectJProcessing = new TestBean();
 
 	@Around("execution(int *.getAge())")
 	int returnCountAsAge() {

spring-aspects/src/test/java/org/springframework/aop/aspectj/autoproxy/AutoProxyWithCodeStyleAspectsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -22,13 +22,12 @@ import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 /**
  * @author Adrian Colyer
- * @author Juergen Hoeller
  */
 public class AutoProxyWithCodeStyleAspectsTests {
 
 	@Test
 	@SuppressWarnings("resource")
-	public void noAutoProxyingOfAjcCompiledAspects() {
+	public void noAutoproxyingOfAjcCompiledAspects() {
 		new ClassPathXmlApplicationContext("org/springframework/aop/aspectj/autoproxy/ajcAutoproxyTests.xml");
 	}
 

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/SpringConfiguredWithAutoProxyingTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -20,10 +20,6 @@ import org.junit.jupiter.api.Test;
 
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 
-/**
- * @author Ramnivas Laddad
- * @author Juergen Hoeller
- */
 public class SpringConfiguredWithAutoProxyingTests {
 
 	@Test

spring-aspects/src/test/resources/org/springframework/aop/aspectj/autoproxy/ajcAutoproxyTests.xml

@@ -2,29 +2,16 @@
 <beans xmlns="http://www.springframework.org/schema/beans"
 		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		xmlns:aop="http://www.springframework.org/schema/aop"
-	    xmlns:cache="http://www.springframework.org/schema/cache"
-		xmlns:context="http://www.springframework.org/schema/context"
 		xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-2.0.xsd
-				http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-2.0.xsd
-				http://www.springframework.org/schema/cache https://www.springframework.org/schema/cache/spring-cache-3.1.xsd
-	   			http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context-2.5.xsd">
+				http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
 
 	<aop:aspectj-autoproxy/>
 
-	<context:spring-configured/>
-
-	<cache:annotation-driven mode="aspectj"/>
-
-	<bean id="cacheManager" class="org.springframework.cache.support.NoOpCacheManager"/>
-
-	<bean id="myAspect" class="org.springframework.aop.aspectj.autoproxy.CodeStyleAspect" factory-method="aspectOf">
+	<bean id="myAspect" class="org.springframework.aop.aspectj.autoproxy.CodeStyleAspect"
+			factory-method="aspectOf">
 		<property name="foo" value="bar"/>
 	</bean>
 
-	<bean id="otherBean" class="org.springframework.beans.factory.aspectj.ShouldBeConfiguredBySpring"/>
-
-	<bean id="yetAnotherBean" class="org.springframework.beans.factory.aspectj.ShouldBeConfiguredBySpring"/>
-
-	<bean id="configuredBean" class="org.springframework.beans.factory.aspectj.ShouldBeConfiguredBySpring" lazy-init="true"/>
+	<bean id="otherBean" class="java.lang.Object"/>
 
 </beans>

spring-aspects/src/test/resources/org/springframework/cache/config/annotation-jcache-aspectj.xml

@@ -24,7 +24,8 @@
 		</property>
 	</bean>
 
-	<bean id="defaultCache" class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+	<bean id="defaultCache"
+		  class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
 		<property name="name" value="default"/>
 	</bean>
 

spring-aspects/src/test/resources/org/springframework/scheduling/aspectj/annotationDrivenContext.xml

@@ -7,10 +7,12 @@
 				http://www.springframework.org/schema/task
 				https://www.springframework.org/schema/task/spring-task.xsd">
 
-	<task:annotation-driven mode="aspectj" executor="testExecutor" exception-handler="testExceptionHandler"/>
+	<task:annotation-driven mode="aspectj" executor="testExecutor"
+							exception-handler="testExceptionHandler"/>
 
 	<task:executor id="testExecutor"/>
 
-	<bean id="testExceptionHandler" class="org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler"/>
+	<bean id="testExceptionHandler"
+		  class="org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler"/>
 
 </beans>

spring-beans/src/main/java/org/springframework/beans/factory/BeanFactory.java

@@ -239,7 +239,7 @@ public interface BeanFactory {
 	 * specific type, specify the actual bean type as an argument here and subsequently
 	 * use {@link ObjectProvider#orderedStream()} or its lazy streaming/iteration options.
 	 * <p>Also, generics matching is strict here, as per the Java assignment rules.
-	 * For lenient fallback matching with unchecked semantics (similar to the 'unchecked'
+	 * For lenient fallback matching with unchecked semantics (similar to the ´unchecked´
 	 * Java compiler warning), consider calling {@link #getBeanProvider(Class)} with the
 	 * raw type as a second step if no full generic match is
 	 * {@link ObjectProvider#getIfAvailable() available} with this variant.

spring-beans/src/main/java/org/springframework/beans/propertyeditors/PathEditor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -92,9 +92,9 @@ public class PathEditor extends PropertyEditorSupport {
 				// a file prefix (let's try as Spring resource location)
 				nioPathCandidate = !text.startsWith(ResourceUtils.FILE_URL_PREFIX);
 			}
-			catch (FileSystemNotFoundException | IllegalArgumentException ex) {
-				// URI scheme not registered for NIO or not meeting Paths requirements:
-				// let's try URL protocol handlers via Spring's resource mechanism.
+			catch (FileSystemNotFoundException ex) {
+				// URI scheme not registered for NIO (let's try URL
+				// protocol handlers via Spring's resource mechanism).
 			}
 		}
 
@@ -111,13 +111,8 @@ public class PathEditor extends PropertyEditorSupport {
 				setValue(resource.getFile().toPath());
 			}
 			catch (IOException ex) {
-				String msg = "Could not resolve \"" + text + "\" to 'java.nio.file.Path' for " + resource + ": " +
-						ex.getMessage();
-				if (nioPathCandidate) {
-					msg += " - In case of ambiguity, consider adding the 'file:' prefix for an explicit reference " +
-							"to a file system resource of the same name: \"file:" + text + "\"";
-				}
-				throw new IllegalArgumentException(msg);
+				throw new IllegalArgumentException(
+						"Could not retrieve file for " + resource + ": " + ex.getMessage());
 			}
 		}
 	}

spring-beans/src/test/java/org/springframework/beans/BeanUtilsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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,8 +42,6 @@ import org.springframework.beans.propertyeditors.CustomDateEditor;
 import org.springframework.beans.testfixture.beans.DerivedTestBean;
 import org.springframework.beans.testfixture.beans.ITestBean;
 import org.springframework.beans.testfixture.beans.TestBean;
-import org.springframework.cglib.proxy.Enhancer;
-import org.springframework.cglib.proxy.MethodInterceptor;
 import org.springframework.core.io.Resource;
 import org.springframework.core.io.ResourceEditor;
 import org.springframework.lang.Nullable;
@@ -54,7 +52,7 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
 import static org.assertj.core.api.SoftAssertions.assertSoftly;
 
 /**
- * Tests for {@link BeanUtils}.
+ * Unit tests for {@link BeanUtils}.
  *
  * @author Juergen Hoeller
  * @author Rob Harrop
@@ -138,7 +136,7 @@ class BeanUtilsTests {
 		PropertyDescriptor[] actual = Introspector.getBeanInfo(TestBean.class).getPropertyDescriptors();
 		PropertyDescriptor[] descriptors = BeanUtils.getPropertyDescriptors(TestBean.class);
 		assertThat(descriptors).as("Descriptors should not be null").isNotNull();
-		assertThat(descriptors).as("Invalid number of descriptors returned").hasSameSizeAs(actual);
+		assertThat(descriptors.length).as("Invalid number of descriptors returned").isEqualTo(actual.length);
 	}
 
 	@Test
@@ -164,13 +162,13 @@ class BeanUtilsTests {
 		tb.setAge(32);
 		tb.setTouchy("touchy");
 		TestBean tb2 = new TestBean();
-		assertThat(tb2.getName()).as("Name empty").isNull();
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getName() == null).as("Name empty").isTrue();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 		BeanUtils.copyProperties(tb, tb2);
-		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+		assertThat(tb2.getName().equals(tb.getName())).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == tb.getAge()).as("Age copied").isTrue();
+		assertThat(tb2.getTouchy().equals(tb.getTouchy())).as("Touchy copied").isTrue();
 	}
 
 	@Test
@@ -180,13 +178,13 @@ class BeanUtilsTests {
 		tb.setAge(32);
 		tb.setTouchy("touchy");
 		TestBean tb2 = new TestBean();
-		assertThat(tb2.getName()).as("Name empty").isNull();
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getName() == null).as("Name empty").isTrue();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 		BeanUtils.copyProperties(tb, tb2);
-		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+		assertThat(tb2.getName().equals(tb.getName())).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == tb.getAge()).as("Age copied").isTrue();
+		assertThat(tb2.getTouchy().equals(tb.getTouchy())).as("Touchy copied").isTrue();
 	}
 
 	@Test
@@ -196,13 +194,13 @@ class BeanUtilsTests {
 		tb.setAge(32);
 		tb.setTouchy("touchy");
 		DerivedTestBean tb2 = new DerivedTestBean();
-		assertThat(tb2.getName()).as("Name empty").isNull();
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getName() == null).as("Name empty").isTrue();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 		BeanUtils.copyProperties(tb, tb2);
-		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+		assertThat(tb2.getName().equals(tb.getName())).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == tb.getAge()).as("Age copied").isTrue();
+		assertThat(tb2.getTouchy().equals(tb.getTouchy())).as("Touchy copied").isTrue();
 	}
 
 	/**
@@ -229,8 +227,8 @@ class BeanUtilsTests {
 		IntegerListHolder2 integerListHolder2 = new IntegerListHolder2();
 
 		BeanUtils.copyProperties(integerListHolder1, integerListHolder2);
-		assertThat(integerListHolder1.getList()).containsExactly(42);
-		assertThat(integerListHolder2.getList()).containsExactly(42);
+		assertThat(integerListHolder1.getList()).containsOnly(42);
+		assertThat(integerListHolder2.getList()).containsOnly(42);
 	}
 
 	/**
@@ -259,7 +257,7 @@ class BeanUtilsTests {
 		WildcardListHolder2 wildcardListHolder2 = new WildcardListHolder2();
 
 		BeanUtils.copyProperties(integerListHolder1, wildcardListHolder2);
-		assertThat(integerListHolder1.getList()).containsExactly(42);
+		assertThat(integerListHolder1.getList()).containsOnly(42);
 		assertThat(wildcardListHolder2.getList()).isEqualTo(Arrays.asList(42));
 	}
 
@@ -273,8 +271,9 @@ class BeanUtilsTests {
 		NumberUpperBoundedWildcardListHolder numberListHolder = new NumberUpperBoundedWildcardListHolder();
 
 		BeanUtils.copyProperties(integerListHolder1, numberListHolder);
-		assertThat(integerListHolder1.getList()).containsExactly(42);
-		assertThat(numberListHolder.getList()).isEqualTo(Arrays.asList(42));
+		assertThat(integerListHolder1.getList()).containsOnly(42);
+		assertThat(numberListHolder.getList()).hasSize(1);
+		assertThat(numberListHolder.getList().contains(Integer.valueOf(42))).isTrue();
 	}
 
 	/**
@@ -283,7 +282,7 @@ class BeanUtilsTests {
 	@Test
 	void copyPropertiesDoesNotCopyFromSuperTypeToSubType() {
 		NumberHolder numberHolder = new NumberHolder();
-		numberHolder.setNumber(42);
+		numberHolder.setNumber(Integer.valueOf(42));
 		IntegerHolder integerHolder = new IntegerHolder();
 
 		BeanUtils.copyProperties(numberHolder, integerHolder);
@@ -301,7 +300,7 @@ class BeanUtilsTests {
 		LongListHolder longListHolder = new LongListHolder();
 
 		BeanUtils.copyProperties(integerListHolder, longListHolder);
-		assertThat(integerListHolder.getList()).containsExactly(42);
+		assertThat(integerListHolder.getList()).containsOnly(42);
 		assertThat(longListHolder.getList()).isEmpty();
 	}
 
@@ -315,7 +314,7 @@ class BeanUtilsTests {
 		NumberListHolder numberListHolder = new NumberListHolder();
 
 		BeanUtils.copyProperties(integerListHolder, numberListHolder);
-		assertThat(integerListHolder.getList()).containsExactly(42);
+		assertThat(integerListHolder.getList()).containsOnly(42);
 		assertThat(numberListHolder.getList()).isEmpty();
 	}
 
@@ -324,13 +323,12 @@ class BeanUtilsTests {
 		Order original = new Order("test", Arrays.asList("foo", "bar"));
 
 		// Create a Proxy that loses the generic type information for the getLineItems() method.
-		OrderSummary proxy = (OrderSummary) Proxy.newProxyInstance(getClass().getClassLoader(),
-				new Class<?>[] {OrderSummary.class}, new OrderInvocationHandler(original));
+		OrderSummary proxy = proxyOrder(original);
 		assertThat(OrderSummary.class.getDeclaredMethod("getLineItems").toGenericString())
-				.contains("java.util.List<java.lang.String>");
+			.contains("java.util.List<java.lang.String>");
 		assertThat(proxy.getClass().getDeclaredMethod("getLineItems").toGenericString())
-				.contains("java.util.List")
-				.doesNotContain("<java.lang.String>");
+			.contains("java.util.List")
+			.doesNotContain("<java.lang.String>");
 
 		// Ensure that our custom Proxy works as expected.
 		assertThat(proxy.getId()).isEqualTo("test");
@@ -343,57 +341,40 @@ class BeanUtilsTests {
 		assertThat(target.getLineItems()).containsExactly("foo", "bar");
 	}
 
-	@Test  // gh-32888
-	public void copyPropertiesWithGenericCglibClass() {
-		Enhancer enhancer = new Enhancer();
-		enhancer.setSuperclass(User.class);
-		enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> proxy.invokeSuper(obj, args));
-		User user = (User) enhancer.create();
-		user.setId(1);
-		user.setName("proxy");
-		user.setAddress("addr");
-
-		User target = new User();
-		BeanUtils.copyProperties(user, target);
-		assertThat(target.getId()).isEqualTo(user.getId());
-		assertThat(target.getName()).isEqualTo(user.getName());
-		assertThat(target.getAddress()).isEqualTo(user.getAddress());
-	}
-
 	@Test
 	void copyPropertiesWithEditable() throws Exception {
 		TestBean tb = new TestBean();
-		assertThat(tb.getName()).as("Name empty").isNull();
+		assertThat(tb.getName() == null).as("Name empty").isTrue();
 		tb.setAge(32);
 		tb.setTouchy("bla");
 		TestBean tb2 = new TestBean();
 		tb2.setName("rod");
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 
 		// "touchy" should not be copied: it's not defined in ITestBean
 		BeanUtils.copyProperties(tb, tb2, ITestBean.class);
-		assertThat(tb2.getName()).as("Name copied").isNull();
-		assertThat(tb2.getAge()).as("Age copied").isEqualTo(32);
-		assertThat(tb2.getTouchy()).as("Touchy still empty").isNull();
+		assertThat(tb2.getName() == null).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == 32).as("Age copied").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy still empty").isTrue();
 	}
 
 	@Test
 	void copyPropertiesWithIgnore() throws Exception {
 		TestBean tb = new TestBean();
-		assertThat(tb.getName()).as("Name empty").isNull();
+		assertThat(tb.getName() == null).as("Name empty").isTrue();
 		tb.setAge(32);
 		tb.setTouchy("bla");
 		TestBean tb2 = new TestBean();
 		tb2.setName("rod");
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 
 		// "spouse", "touchy", "age" should not be copied
 		BeanUtils.copyProperties(tb, tb2, "spouse", "touchy", "age");
-		assertThat(tb2.getName()).as("Name copied").isNull();
-		assertThat(tb2.getAge()).as("Age still empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy still empty").isNull();
+		assertThat(tb2.getName() == null).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == 0).as("Age still empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy still empty").isTrue();
 	}
 
 	@Test
@@ -402,7 +383,7 @@ class BeanUtilsTests {
 		source.setName("name");
 		TestBean target = new TestBean();
 		BeanUtils.copyProperties(source, target, "specialProperty");
-		assertThat(target.getName()).isEqualTo("name");
+		assertThat("name").isEqualTo(target.getName());
 	}
 
 	@Test
@@ -539,7 +520,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class IntegerHolder {
 
@@ -554,7 +534,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class WildcardListHolder1 {
 
@@ -569,7 +548,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class WildcardListHolder2 {
 
@@ -584,7 +562,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class NumberUpperBoundedWildcardListHolder {
 
@@ -599,7 +576,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class NumberListHolder {
 
@@ -614,7 +590,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class IntegerListHolder1 {
 
@@ -629,7 +604,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class IntegerListHolder2 {
 
@@ -644,7 +618,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class LongListHolder {
 
@@ -825,7 +798,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	private static class BeanWithNullableTypes {
 
 		private Integer counter;
@@ -856,7 +828,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	private static class BeanWithPrimitiveTypes {
 
 		private boolean flag;
@@ -869,6 +840,7 @@ class BeanUtilsTests {
 		private char character;
 		private String text;
 
+
 		@SuppressWarnings("unused")
 		public BeanWithPrimitiveTypes(boolean flag, byte byteCount, short shortCount, int intCount, long longCount,
 				float floatCount, double doubleCount, char character, String text) {
@@ -919,8 +891,8 @@ class BeanUtilsTests {
 		public String getText() {
 			return text;
 		}
-	}
 
+	}
 
 	private static class PrivateBeanWithPrivateConstructor {
 
@@ -928,14 +900,13 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class Order {
 
 		private String id;
-
 		private List<String> lineItems;
 
+
 		Order() {
 		}
 
@@ -966,7 +937,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	private interface OrderSummary {
 
 		String getId();
@@ -975,10 +945,17 @@ class BeanUtilsTests {
 	}
 
 
+	private OrderSummary proxyOrder(Order order) {
+		return (OrderSummary) Proxy.newProxyInstance(getClass().getClassLoader(),
+			new Class<?>[] { OrderSummary.class }, new OrderInvocationHandler(order));
+	}
+
+
 	private static class OrderInvocationHandler implements InvocationHandler {
 
 		private final Order order;
 
+
 		OrderInvocationHandler(Order order) {
 			this.order = order;
 		}
@@ -996,46 +973,4 @@ class BeanUtilsTests {
 		}
 	}
 
-
-	private static class GenericBaseModel<T> {
-
-		private T id;
-
-		private String name;
-
-		public T getId() {
-			return id;
-		}
-
-		public void setId(T id) {
-			this.id = id;
-		}
-
-		public String getName() {
-			return name;
-		}
-
-		public void setName(String name) {
-			this.name = name;
-		}
-	}
-
-
-	private static class User extends GenericBaseModel<Integer> {
-
-		private String address;
-
-		public User() {
-			super();
-		}
-
-		public String getAddress() {
-			return address;
-		}
-
-		public void setAddress(String address) {
-			this.address = address;
-		}
-	}
-
 }

spring-beans/src/test/java/org/springframework/beans/propertyeditors/FileEditorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * 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.
@@ -31,82 +31,79 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
  * @author Chris Beams
  * @author Juergen Hoeller
  */
-class FileEditorTests {
+public class FileEditorTests {
 
 	@Test
-	void testClasspathFileName() {
+	public void testClasspathFileName() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		fileEditor.setAsText("classpath:" + ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".class");
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition = value instanceof File;
+		assertThat(condition).isTrue();
 		File file = (File) value;
-		assertThat(file).exists();
+		assertThat(file.exists()).isTrue();
 	}
 
 	@Test
-	void testWithNonExistentResource() {
-		PropertyEditor fileEditor = new FileEditor();
+	public void testWithNonExistentResource() throws Exception {
+		PropertyEditor propertyEditor = new FileEditor();
 		assertThatIllegalArgumentException().isThrownBy(() ->
-				fileEditor.setAsText("classpath:no_way_this_file_is_found.doc"));
+				propertyEditor.setAsText("classpath:no_way_this_file_is_found.doc"));
 	}
 
 	@Test
-	void testWithNonExistentFile() {
+	public void testWithNonExistentFile() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		fileEditor.setAsText("file:no_way_this_file_is_found.doc");
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition1 = value instanceof File;
+		assertThat(condition1).isTrue();
 		File file = (File) value;
-		assertThat(file).doesNotExist();
+		boolean condition = !file.exists();
+		assertThat(condition).isTrue();
 	}
 
 	@Test
-	void testAbsoluteFileName() {
+	public void testAbsoluteFileName() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		fileEditor.setAsText("/no_way_this_file_is_found.doc");
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition1 = value instanceof File;
+		assertThat(condition1).isTrue();
 		File file = (File) value;
-		assertThat(file).doesNotExist();
+		boolean condition = !file.exists();
+		assertThat(condition).isTrue();
 	}
 
 	@Test
-	void testCurrentDirectory() {
-		PropertyEditor fileEditor = new FileEditor();
-		fileEditor.setAsText("file:.");
-		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
-		File file = (File) value;
-		assertThat(file).isEqualTo(new File("."));
-	}
-
-	@Test
-	void testUnqualifiedFileNameFound() {
+	public void testUnqualifiedFileNameFound() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		String fileName = ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".class";
 		fileEditor.setAsText(fileName);
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition = value instanceof File;
+		assertThat(condition).isTrue();
 		File file = (File) value;
-		assertThat(file).exists();
+		assertThat(file.exists()).isTrue();
 		String absolutePath = file.getAbsolutePath().replace('\\', '/');
-		assertThat(absolutePath).endsWith(fileName);
+		assertThat(absolutePath.endsWith(fileName)).isTrue();
 	}
 
 	@Test
-	void testUnqualifiedFileNameNotFound() {
+	public void testUnqualifiedFileNameNotFound() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		String fileName = ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".clazz";
 		fileEditor.setAsText(fileName);
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition = value instanceof File;
+		assertThat(condition).isTrue();
 		File file = (File) value;
-		assertThat(file).doesNotExist();
+		assertThat(file.exists()).isFalse();
 		String absolutePath = file.getAbsolutePath().replace('\\', '/');
-		assertThat(absolutePath).endsWith(fileName);
+		assertThat(absolutePath.endsWith(fileName)).isTrue();
 	}
 
 }

spring-beans/src/test/java/org/springframework/beans/propertyeditors/PathEditorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 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,6 @@ package org.springframework.beans.propertyeditors;
 import java.beans.PropertyEditor;
 import java.io.File;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 
 import org.junit.jupiter.api.Test;
 
@@ -32,65 +31,65 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
  * @author Juergen Hoeller
  * @since 4.3.2
  */
-class PathEditorTests {
+public class PathEditorTests {
 
 	@Test
-	void testClasspathPathName() {
+	public void testClasspathPathName() {
 		PropertyEditor pathEditor = new PathEditor();
 		pathEditor.setAsText("classpath:" + ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".class");
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
-		assertThat(path.toFile()).exists();
+		assertThat(path.toFile().exists()).isTrue();
 	}
 
 	@Test
-	void testWithNonExistentResource() {
-		PropertyEditor pathEditor = new PathEditor();
+	public void testWithNonExistentResource() {
+		PropertyEditor propertyEditor = new PathEditor();
 		assertThatIllegalArgumentException().isThrownBy(() ->
-				pathEditor.setAsText("classpath:/no_way_this_file_is_found.doc"));
+				propertyEditor.setAsText("classpath:/no_way_this_file_is_found.doc"));
 	}
 
 	@Test
-	void testWithNonExistentPath() {
+	public void testWithNonExistentPath() {
 		PropertyEditor pathEditor = new PathEditor();
 		pathEditor.setAsText("file:/no_way_this_file_is_found.doc");
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
-		assertThat(path.toFile()).doesNotExist();
+		assertThat(!path.toFile().exists()).isTrue();
 	}
 
 	@Test
-	void testAbsolutePath() {
+	public void testAbsolutePath() {
 		PropertyEditor pathEditor = new PathEditor();
 		pathEditor.setAsText("/no_way_this_file_is_found.doc");
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
-		assertThat(path.toFile()).doesNotExist();
+		assertThat(!path.toFile().exists()).isTrue();
 	}
 
 	@Test
-	void testWindowsAbsolutePath() {
+	public void testWindowsAbsolutePath() {
 		PropertyEditor pathEditor = new PathEditor();
 		pathEditor.setAsText("C:\\no_way_this_file_is_found.doc");
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
-		assertThat(path.toFile()).doesNotExist();
+		assertThat(!path.toFile().exists()).isTrue();
 	}
 
 	@Test
-	void testWindowsAbsoluteFilePath() {
+	public void testWindowsAbsoluteFilePath() {
 		PropertyEditor pathEditor = new PathEditor();
 		try {
 			pathEditor.setAsText("file://C:\\no_way_this_file_is_found.doc");
 			Object value = pathEditor.getValue();
-			assertThat(value).isInstanceOf(Path.class);
+			assertThat(value instanceof Path).isTrue();
 			Path path = (Path) value;
-			assertThat(path.toFile()).doesNotExist();
+			assertThat(!path.toFile().exists()).isTrue();
 		}
 		catch (IllegalArgumentException ex) {
 			if (File.separatorChar == '\\') {  // on Windows, otherwise silently ignore
@@ -100,49 +99,39 @@ class PathEditorTests {
 	}
 
 	@Test
-	void testCurrentDirectory() {
-		PropertyEditor pathEditor = new PathEditor();
-		pathEditor.setAsText("file:.");
-		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
-		Path path = (Path) value;
-		assertThat(path).isEqualTo(Paths.get("."));
-	}
-
-	@Test
-	void testUnqualifiedPathNameFound() {
+	public void testUnqualifiedPathNameFound() {
 		PropertyEditor pathEditor = new PathEditor();
 		String fileName = ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".class";
 		pathEditor.setAsText(fileName);
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
 		File file = path.toFile();
-		assertThat(file).exists();
+		assertThat(file.exists()).isTrue();
 		String absolutePath = file.getAbsolutePath();
 		if (File.separatorChar == '\\') {
 			absolutePath = absolutePath.replace('\\', '/');
 		}
-		assertThat(absolutePath).endsWith(fileName);
+		assertThat(absolutePath.endsWith(fileName)).isTrue();
 	}
 
 	@Test
-	void testUnqualifiedPathNameNotFound() {
+	public void testUnqualifiedPathNameNotFound() {
 		PropertyEditor pathEditor = new PathEditor();
 		String fileName = ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".clazz";
 		pathEditor.setAsText(fileName);
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
 		File file = path.toFile();
-		assertThat(file).doesNotExist();
+		assertThat(file.exists()).isFalse();
 		String absolutePath = file.getAbsolutePath();
 		if (File.separatorChar == '\\') {
 			absolutePath = absolutePath.replace('\\', '/');
 		}
-		assertThat(absolutePath).endsWith(fileName);
+		assertThat(absolutePath.endsWith(fileName)).isTrue();
 	}
 
 }

spring-context/src/main/java/org/springframework/context/event/ApplicationContextEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -29,7 +29,7 @@ import org.springframework.context.ApplicationEvent;
 public abstract class ApplicationContextEvent extends ApplicationEvent {
 
 	/**
-	 * Create a new {@code ApplicationContextEvent}.
+	 * Create a new ContextStartedEvent.
 	 * @param source the {@code ApplicationContext} that the event is raised for
 	 * (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/event/ContextClosedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -29,7 +29,7 @@ import org.springframework.context.ApplicationContext;
 public class ContextClosedEvent extends ApplicationContextEvent {
 
 	/**
-	 * Create a new {@code ContextClosedEvent}.
+	 * Creates a new ContextClosedEvent.
 	 * @param source the {@code ApplicationContext} that has been closed
 	 * (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/event/ContextRefreshedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -29,7 +29,7 @@ import org.springframework.context.ApplicationContext;
 public class ContextRefreshedEvent extends ApplicationContextEvent {
 
 	/**
-	 * Create a new {@code ContextRefreshedEvent}.
+	 * Create a new ContextRefreshedEvent.
 	 * @param source the {@code ApplicationContext} that has been initialized
 	 * or refreshed (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/event/ContextStartedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -30,7 +30,7 @@ import org.springframework.context.ApplicationContext;
 public class ContextStartedEvent extends ApplicationContextEvent {
 
 	/**
-	 * Create a new {@code ContextStartedEvent}.
+	 * Create a new ContextStartedEvent.
 	 * @param source the {@code ApplicationContext} that has been started
 	 * (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/event/ContextStoppedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -30,7 +30,7 @@ import org.springframework.context.ApplicationContext;
 public class ContextStoppedEvent extends ApplicationContextEvent {
 
 	/**
-	 * Create a new {@code ContextStoppedEvent}.
+	 * Create a new ContextStoppedEvent.
 	 * @param source the {@code ApplicationContext} that has been stopped
 	 * (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -45,11 +45,7 @@ import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
- * Spring's default implementation of the {@link LifecycleProcessor} strategy.
- *
- * <p>Provides interaction with {@link Lifecycle} and {@link SmartLifecycle} beans in
- * groups for specific phases, on startup/shutdown as well as for explicit start/stop
- * interactions on a {@link org.springframework.context.ConfigurableApplicationContext}.
+ * Default implementation of the {@link LifecycleProcessor} strategy.
  *
  * @author Mark Fisher
  * @author Juergen Hoeller
@@ -149,13 +145,13 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 
 		lifecycleBeans.forEach((beanName, bean) -> {
 			if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
-				int startupPhase = getPhase(bean);
-				phases.computeIfAbsent(startupPhase,
-						phase -> new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly)
+				int phase = getPhase(bean);
+				phases.computeIfAbsent(
+						phase,
+						p -> new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly)
 				).add(beanName, bean);
 			}
 		});
-
 		if (!phases.isEmpty()) {
 			phases.values().forEach(LifecycleGroup::start);
 		}
@@ -195,7 +191,6 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 	private void stopBeans() {
 		Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
 		Map<Integer, LifecycleGroup> phases = new HashMap<>();
-
 		lifecycleBeans.forEach((beanName, bean) -> {
 			int shutdownPhase = getPhase(bean);
 			LifecycleGroup group = phases.get(shutdownPhase);
@@ -205,7 +200,6 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 			}
 			group.add(beanName, bean);
 		});
-
 		if (!phases.isEmpty()) {
 			List<Integer> keys = new ArrayList<>(phases.keySet());
 			keys.sort(Collections.reverseOrder());
@@ -320,8 +314,6 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 	/**
 	 * Helper class for maintaining a group of Lifecycle beans that should be started
 	 * and stopped together based on their 'phase' value (or the default value of 0).
-	 * The group is expected to be created in an ad-hoc fashion and group members are
-	 * expected to always have the same 'phase' value.
 	 */
 	private class LifecycleGroup {
 

spring-context/src/main/java/org/springframework/format/datetime/DateFormatter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 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.
@@ -22,10 +22,8 @@ import java.text.SimpleDateFormat;
 import java.util.Collections;
 import java.util.Date;
 import java.util.EnumMap;
-import java.util.LinkedHashSet;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Set;
 import java.util.TimeZone;
 
 import org.springframework.format.Formatter;
@@ -37,14 +35,9 @@ import org.springframework.util.StringUtils;
 
 /**
  * A formatter for {@link java.util.Date} types.
- *
  * <p>Supports the configuration of an explicit date time pattern, timezone,
  * locale, and fallback date time patterns for lenient parsing.
  *
- * <p>Common ISO patterns for UTC instants are applied at millisecond precision.
- * Note that {@link org.springframework.format.datetime.standard.InstantFormatter}
- * is recommended for flexible UTC parsing into a {@link java.time.Instant} instead.
- *
  * @author Keith Donald
  * @author Juergen Hoeller
  * @author Phillip Webb
@@ -58,21 +51,12 @@ public class DateFormatter implements Formatter<Date> {
 
 	private static final Map<ISO, String> ISO_PATTERNS;
 
-	private static final Map<ISO, String> ISO_FALLBACK_PATTERNS;
-
 	static {
-		// We use an EnumMap instead of Map.of(...) since the former provides better performance.
 		Map<ISO, String> formats = new EnumMap<>(ISO.class);
 		formats.put(ISO.DATE, "yyyy-MM-dd");
 		formats.put(ISO.TIME, "HH:mm:ss.SSSXXX");
 		formats.put(ISO.DATE_TIME, "yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
 		ISO_PATTERNS = Collections.unmodifiableMap(formats);
-
-		// Fallback format for the time part without milliseconds.
-		Map<ISO, String> fallbackFormats = new EnumMap<>(ISO.class);
-		fallbackFormats.put(ISO.TIME, "HH:mm:ssXXX");
-		fallbackFormats.put(ISO.DATE_TIME, "yyyy-MM-dd'T'HH:mm:ssXXX");
-		ISO_FALLBACK_PATTERNS = Collections.unmodifiableMap(fallbackFormats);
 	}
 
 
@@ -217,16 +201,8 @@ public class DateFormatter implements Formatter<Date> {
 			return getDateFormat(locale).parse(text);
 		}
 		catch (ParseException ex) {
-			Set<String> fallbackPatterns = new LinkedHashSet<>();
-			String isoPattern = ISO_FALLBACK_PATTERNS.get(this.iso);
-			if (isoPattern != null) {
-				fallbackPatterns.add(isoPattern);
-			}
 			if (!ObjectUtils.isEmpty(this.fallbackPatterns)) {
-				Collections.addAll(fallbackPatterns, this.fallbackPatterns);
-			}
-			if (!fallbackPatterns.isEmpty()) {
-				for (String pattern : fallbackPatterns) {
+				for (String pattern : this.fallbackPatterns) {
 					try {
 						DateFormat dateFormat = configureDateFormat(new SimpleDateFormat(pattern, locale));
 						// Align timezone for parsing format with printing format if ISO is set.
@@ -244,8 +220,8 @@ public class DateFormatter implements Formatter<Date> {
 			}
 			if (this.source != null) {
 				ParseException parseException = new ParseException(
-						String.format("Unable to parse date time value \"%s\" using configuration from %s", text, this.source),
-						ex.getErrorOffset());
+					String.format("Unable to parse date time value \"%s\" using configuration from %s", text, this.source),
+					ex.getErrorOffset());
 				parseException.initCause(ex);
 				throw parseException;
 			}

spring-context/src/main/java/org/springframework/format/datetime/standard/InstantFormatter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * 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.
@@ -41,12 +41,12 @@ public class InstantFormatter implements Formatter<Instant> {
 
 	@Override
 	public Instant parse(String text, Locale locale) throws ParseException {
-		if (!text.isEmpty() && Character.isAlphabetic(text.charAt(0))) {
+		if (text.length() > 0 && Character.isAlphabetic(text.charAt(0))) {
 			// assuming RFC-1123 value a la "Tue, 3 Jun 2008 11:05:30 GMT"
 			return Instant.from(DateTimeFormatter.RFC_1123_DATE_TIME.parse(text));
 		}
 		else {
-			// assuming UTC instant a la "2007-12-03T10:15:30.000Z"
+			// assuming UTC instant a la "2007-12-03T10:15:30.00Z"
 			return Instant.parse(text);
 		}
 	}

spring-context/src/test/java/org/springframework/aop/aspectj/OverloadedAdviceTests.java

@@ -28,14 +28,17 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
  *
  * @author Adrian Colyer
  * @author Chris Beams
- * @author Juergen Hoeller
  */
 class OverloadedAdviceTests {
 
 	@Test
 	@SuppressWarnings("resource")
-	void testConfigParsingWithMismatchedAdviceMethod() {
-		new ClassPathXmlApplicationContext(getClass().getSimpleName() + ".xml", getClass());
+	void testExceptionOnConfigParsingWithMismatchedAdviceMethod() {
+		assertThatExceptionOfType(BeanCreationException.class)
+			.isThrownBy(() -> new ClassPathXmlApplicationContext(getClass().getSimpleName() + ".xml", getClass()))
+			.havingRootCause()
+				.isInstanceOf(IllegalArgumentException.class)
+				.as("invalidAbsoluteTypeName should be detected by AJ").withMessageContaining("invalidAbsoluteTypeName");
 	}
 
 	@Test

spring-context/src/test/java/org/springframework/context/annotation/configuration/AutowiredConfigurationTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -27,7 +27,6 @@ import javax.inject.Provider;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.beans.factory.BeanFactory;
-import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -45,7 +44,6 @@ import org.springframework.context.support.GenericApplicationContext;
 import org.springframework.core.annotation.AliasFor;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.Resource;
-import org.springframework.util.Assert;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -94,8 +92,8 @@ class AutowiredConfigurationTests {
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
 				OptionalAutowiredMethodConfig.class);
 
-		assertThat(context.getBeansOfType(Colour.class)).isEmpty();
-		assertThat(context.getBean(TestBean.class).getName()).isEmpty();
+		assertThat(context.getBeansOfType(Colour.class).isEmpty()).isTrue();
+		assertThat(context.getBean(TestBean.class).getName()).isEqualTo("");
 		context.close();
 	}
 
@@ -186,22 +184,14 @@ class AutowiredConfigurationTests {
 		context.close();
 	}
 
-	@Test
-	void testValueInjectionWithAccidentalAutowiredAnnotations() {
-		AnnotationConfigApplicationContext context =
-				new AnnotationConfigApplicationContext(ValueConfigWithAccidentalAutowiredAnnotations.class);
-		doTestValueInjection(context);
-		context.close();
-	}
-
 	private void doTestValueInjection(BeanFactory context) {
 		System.clearProperty("myProp");
 
 		TestBean testBean = context.getBean("testBean", TestBean.class);
-		assertThat(testBean.getName()).isNull();
+		assertThat((Object) testBean.getName()).isNull();
 
 		testBean = context.getBean("testBean2", TestBean.class);
-		assertThat(testBean.getName()).isNull();
+		assertThat((Object) testBean.getName()).isNull();
 
 		System.setProperty("myProp", "foo");
 
@@ -214,10 +204,10 @@ class AutowiredConfigurationTests {
 		System.clearProperty("myProp");
 
 		testBean = context.getBean("testBean", TestBean.class);
-		assertThat(testBean.getName()).isNull();
+		assertThat((Object) testBean.getName()).isNull();
 
 		testBean = context.getBean("testBean2", TestBean.class);
-		assertThat(testBean.getName()).isNull();
+		assertThat((Object) testBean.getName()).isNull();
 	}
 
 	@Test
@@ -281,7 +271,7 @@ class AutowiredConfigurationTests {
 				return new TestBean("");
 			}
 			else {
-				return new TestBean(colour.get() + "-" + colours.get().get(0).toString());
+				return new TestBean(colour.get().toString() + "-" + colours.get().get(0).toString());
 			}
 		}
 	}
@@ -494,32 +484,6 @@ class AutowiredConfigurationTests {
 	}
 
 
-	@Configuration
-	static class ValueConfigWithAccidentalAutowiredAnnotations implements InitializingBean {
-
-		boolean invoked;
-
-		@Override
-		public void afterPropertiesSet() {
-			Assert.state(!invoked, "Factory method must not get invoked on startup");
-		}
-
-		@Bean @Scope("prototype")
-		@Autowired
-		public TestBean testBean(@Value("#{systemProperties[myProp]}") Provider<String> name) {
-			invoked = true;
-			return new TestBean(name.get());
-		}
-
-		@Bean @Scope("prototype")
-		@Autowired
-		public TestBean testBean2(@Value("#{systemProperties[myProp]}") Provider<String> name2) {
-			invoked = true;
-			return new TestBean(name2.get());
-		}
-	}
-
-
 	@Configuration
 	static class PropertiesConfig {
 

spring-context/src/test/java/org/springframework/format/datetime/DateFormatterTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * 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.
@@ -23,6 +23,9 @@ import java.util.Date;
 import java.util.Locale;
 import java.util.TimeZone;
 
+import org.joda.time.DateTimeZone;
+import org.joda.time.format.DateTimeFormat;
+import org.joda.time.format.DateTimeFormatter;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.format.annotation.DateTimeFormat.ISO;
@@ -30,88 +33,83 @@ import org.springframework.format.annotation.DateTimeFormat.ISO;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 
+
+
+
 /**
  * Tests for {@link DateFormatter}.
  *
  * @author Keith Donald
  * @author Phillip Webb
- * @author Juergen Hoeller
  */
-class DateFormatterTests {
+public class DateFormatterTests {
 
 	private static final TimeZone UTC = TimeZone.getTimeZone("UTC");
 
 
 	@Test
-	void shouldPrintAndParseDefault() throws Exception {
+	public void shouldPrintAndParseDefault() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
-
 		Date date = getDate(2009, Calendar.JUNE, 1);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("Jun 1, 2009");
 		assertThat(formatter.parse("Jun 1, 2009", Locale.US)).isEqualTo(date);
 	}
 
 	@Test
-	void shouldPrintAndParseFromPattern() throws ParseException {
+	public void shouldPrintAndParseFromPattern() throws ParseException {
 		DateFormatter formatter = new DateFormatter("yyyy-MM-dd");
 		formatter.setTimeZone(UTC);
-
 		Date date = getDate(2009, Calendar.JUNE, 1);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("2009-06-01");
 		assertThat(formatter.parse("2009-06-01", Locale.US)).isEqualTo(date);
 	}
 
 	@Test
-	void shouldPrintAndParseShort() throws Exception {
+	public void shouldPrintAndParseShort() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
 		formatter.setStyle(DateFormat.SHORT);
-
 		Date date = getDate(2009, Calendar.JUNE, 1);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("6/1/09");
 		assertThat(formatter.parse("6/1/09", Locale.US)).isEqualTo(date);
 	}
 
 	@Test
-	void shouldPrintAndParseMedium() throws Exception {
+	public void shouldPrintAndParseMedium() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
 		formatter.setStyle(DateFormat.MEDIUM);
-
 		Date date = getDate(2009, Calendar.JUNE, 1);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("Jun 1, 2009");
 		assertThat(formatter.parse("Jun 1, 2009", Locale.US)).isEqualTo(date);
 	}
 
 	@Test
-	void shouldPrintAndParseLong() throws Exception {
+	public void shouldPrintAndParseLong() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
 		formatter.setStyle(DateFormat.LONG);
-
 		Date date = getDate(2009, Calendar.JUNE, 1);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("June 1, 2009");
 		assertThat(formatter.parse("June 1, 2009", Locale.US)).isEqualTo(date);
 	}
 
 	@Test
-	void shouldPrintAndParseFull() throws Exception {
+	public void shouldPrintAndParseFull() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
 		formatter.setStyle(DateFormat.FULL);
-
 		Date date = getDate(2009, Calendar.JUNE, 1);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("Monday, June 1, 2009");
 		assertThat(formatter.parse("Monday, June 1, 2009", Locale.US)).isEqualTo(date);
 	}
 
 	@Test
-	void shouldPrintAndParseIsoDate() throws Exception {
+	public void shouldPrintAndParseISODate() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
 		formatter.setIso(ISO.DATE);
-
 		Date date = getDate(2009, Calendar.JUNE, 1, 14, 23, 5, 3);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("2009-06-01");
 		assertThat(formatter.parse("2009-6-01", Locale.US))
@@ -119,56 +117,79 @@ class DateFormatterTests {
 	}
 
 	@Test
-	void shouldPrintAndParseIsoTime() throws Exception {
+	public void shouldPrintAndParseISOTime() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
 		formatter.setIso(ISO.TIME);
-
 		Date date = getDate(2009, Calendar.JANUARY, 1, 14, 23, 5, 3);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("14:23:05.003Z");
 		assertThat(formatter.parse("14:23:05.003Z", Locale.US))
 				.isEqualTo(getDate(1970, Calendar.JANUARY, 1, 14, 23, 5, 3));
-
-		date = getDate(2009, Calendar.JANUARY, 1, 14, 23, 5, 0);
-		assertThat(formatter.print(date, Locale.US)).isEqualTo("14:23:05.000Z");
-		assertThat(formatter.parse("14:23:05Z", Locale.US))
-				.isEqualTo(getDate(1970, Calendar.JANUARY, 1, 14, 23, 5, 0).toInstant());
 	}
 
 	@Test
-	void shouldPrintAndParseIsoDateTime() throws Exception {
+	public void shouldPrintAndParseISODateTime() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
 		formatter.setIso(ISO.DATE_TIME);
-
 		Date date = getDate(2009, Calendar.JUNE, 1, 14, 23, 5, 3);
 		assertThat(formatter.print(date, Locale.US)).isEqualTo("2009-06-01T14:23:05.003Z");
 		assertThat(formatter.parse("2009-06-01T14:23:05.003Z", Locale.US)).isEqualTo(date);
-
-		date = getDate(2009, Calendar.JUNE, 1, 14, 23, 5, 0);
-		assertThat(formatter.print(date, Locale.US)).isEqualTo("2009-06-01T14:23:05.000Z");
-		assertThat(formatter.parse("2009-06-01T14:23:05Z", Locale.US)).isEqualTo(date.toInstant());
 	}
 
 	@Test
-	void shouldThrowOnUnsupportedStylePattern() {
+	public void shouldSupportJodaStylePatterns() throws Exception {
+		String[] chars = { "S", "M", "-" };
+		for (String d : chars) {
+			for (String t : chars) {
+				String style = d + t;
+				if (!style.equals("--")) {
+					Date date = getDate(2009, Calendar.JUNE, 10, 14, 23, 0, 0);
+					if (t.equals("-")) {
+						date = getDate(2009, Calendar.JUNE, 10);
+					}
+					else if (d.equals("-")) {
+						date = getDate(1970, Calendar.JANUARY, 1, 14, 23, 0, 0);
+					}
+					testJodaStylePatterns(style, Locale.US, date);
+				}
+			}
+		}
+	}
+
+	private void testJodaStylePatterns(String style, Locale locale, Date date) throws Exception {
+		DateFormatter formatter = new DateFormatter();
+		formatter.setTimeZone(UTC);
+		formatter.setStylePattern(style);
+		DateTimeFormatter jodaFormatter = DateTimeFormat.forStyle(style).withLocale(locale).withZone(DateTimeZone.UTC);
+		String jodaPrinted = jodaFormatter.print(date.getTime());
+		assertThat(formatter.print(date, locale))
+				.as("Unable to print style pattern " + style)
+				.isEqualTo(jodaPrinted);
+		assertThat(formatter.parse(jodaPrinted, locale))
+				.as("Unable to parse style pattern " + style)
+				.isEqualTo(date);
+	}
+
+	@Test
+	public void shouldThrowOnUnsupportedStylePattern() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setStylePattern("OO");
-
-		assertThatIllegalStateException().isThrownBy(() -> formatter.parse("2009", Locale.US))
-				.withMessageContaining("Unsupported style pattern 'OO'");
+		assertThatIllegalStateException().isThrownBy(() ->
+				formatter.parse("2009", Locale.US))
+			.withMessageContaining("Unsupported style pattern 'OO'");
 	}
 
 	@Test
-	void shouldUseCorrectOrder() {
+	public void shouldUseCorrectOrder() throws Exception {
 		DateFormatter formatter = new DateFormatter();
 		formatter.setTimeZone(UTC);
 		formatter.setStyle(DateFormat.SHORT);
 		formatter.setStylePattern("L-");
 		formatter.setIso(ISO.DATE_TIME);
 		formatter.setPattern("yyyy");
-
 		Date date = getDate(2009, Calendar.JUNE, 1, 14, 23, 5, 3);
+
 		assertThat(formatter.print(date, Locale.US)).as("uses pattern").isEqualTo("2009");
 
 		formatter.setPattern("");

spring-context/src/test/java/org/springframework/format/datetime/DateFormattingTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -52,7 +52,7 @@ import static org.assertj.core.api.Assertions.assertThat;
  * @author Juergen Hoeller
  * @author Sam Brannen
  */
-class DateFormattingTests {
+public class DateFormattingTests {
 
 	private final FormattingConversionService conversionService = new FormattingConversionService();
 

spring-context/src/test/java/org/springframework/format/datetime/standard/DateTimeFormattingTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -105,7 +105,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localDate", "10/31/09");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("localDate")).isEqualTo("10/31/09");
 	}
 
@@ -117,7 +117,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localDate", "October 31, 2009");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("localDate")).isEqualTo("October 31, 2009");
 	}
 
@@ -129,7 +129,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localDate", "20091031");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("localDate")).isEqualTo("20091031");
 	}
 
@@ -138,7 +138,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localDate", new String[] {"10/31/09"});
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 	}
 
 	@Test
@@ -146,7 +146,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("styleLocalDate", "Oct 31, 2009");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("styleLocalDate")).isEqualTo("Oct 31, 2009");
 	}
 
@@ -164,7 +164,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("children[0].styleLocalDate", "Oct 31, 2009");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("children[0].styleLocalDate")).isEqualTo("Oct 31, 2009");
 	}
 
@@ -174,7 +174,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("styleLocalDate", "Oct 31, 2009");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("styleLocalDate")).isEqualTo("Oct 31, 2009");
 	}
 
@@ -193,7 +193,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localDate", new GregorianCalendar(2009, 9, 31, 0, 0));
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("localDate")).isEqualTo("10/31/09");
 	}
 
@@ -202,7 +202,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localTime", "12:00 PM");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("localTime")).isEqualTo("12:00 PM");
 	}
 
@@ -214,7 +214,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localTime", "12:00:00 PM");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("localTime")).isEqualTo("12:00:00 PM");
 	}
 
@@ -226,7 +226,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localTime", "130000");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("localTime")).isEqualTo("130000");
 	}
 
@@ -235,7 +235,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("styleLocalTime", "12:00:00 PM");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("styleLocalTime")).isEqualTo("12:00:00 PM");
 	}
 
@@ -244,7 +244,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localTime", new GregorianCalendar(1970, 0, 0, 12, 0));
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("localTime")).isEqualTo("12:00 PM");
 	}
 
@@ -253,9 +253,10 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localDateTime", LocalDateTime.of(2009, 10, 31, 12, 0));
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		String value = binder.getBindingResult().getFieldValue("localDateTime").toString();
-		assertThat(value).startsWith("10/31/09").endsWith("12:00 PM");
+		assertThat(value.startsWith("10/31/09")).isTrue();
+		assertThat(value.endsWith("12:00 PM")).isTrue();
 	}
 
 	@Test
@@ -263,9 +264,10 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("styleLocalDateTime", LocalDateTime.of(2009, 10, 31, 12, 0));
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		String value = binder.getBindingResult().getFieldValue("styleLocalDateTime").toString();
-		assertThat(value).startsWith("Oct 31, 2009").endsWith("12:00:00 PM");
+		assertThat(value.startsWith("Oct 31, 2009")).isTrue();
+		assertThat(value.endsWith("12:00:00 PM")).isTrue();
 	}
 
 	@Test
@@ -273,9 +275,10 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localDateTime", new GregorianCalendar(2009, 9, 31, 12, 0));
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		String value = binder.getBindingResult().getFieldValue("localDateTime").toString();
-		assertThat(value).startsWith("10/31/09").endsWith("12:00 PM");
+		assertThat(value.startsWith("10/31/09")).isTrue();
+		assertThat(value.endsWith("12:00 PM")).isTrue();
 	}
 
 	@Test
@@ -286,9 +289,10 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("localDateTime", LocalDateTime.of(2009, 10, 31, 12, 0));
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		String value = binder.getBindingResult().getFieldValue("localDateTime").toString();
-		assertThat(value).startsWith("Oct 31, 2009").endsWith("12:00:00 PM");
+		assertThat(value.startsWith("Oct 31, 2009")).isTrue();
+		assertThat(value.endsWith("12:00:00 PM")).isTrue();
 	}
 
 	@Test
@@ -296,7 +300,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("patternLocalDateTime", "10/31/09 12:00 PM");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("patternLocalDateTime")).isEqualTo("10/31/09 12:00 PM");
 	}
 
@@ -313,7 +317,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("isoLocalDate", "2009-10-31");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("isoLocalDate")).isEqualTo("2009-10-31");
 	}
 
@@ -352,7 +356,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("isoLocalTime", "12:00:00");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("isoLocalTime")).isEqualTo("12:00:00");
 	}
 
@@ -361,7 +365,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("isoLocalTime", "12:00:00.000-05:00");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("isoLocalTime")).isEqualTo("12:00:00");
 	}
 
@@ -370,7 +374,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("isoLocalDateTime", "2009-10-31T12:00:00");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("isoLocalDateTime")).isEqualTo("2009-10-31T12:00:00");
 	}
 
@@ -379,7 +383,7 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("isoLocalDateTime", "2009-10-31T12:00:00.000Z");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
 		assertThat(binder.getBindingResult().getFieldValue("isoLocalDateTime")).isEqualTo("2009-10-31T12:00:00");
 	}
 
@@ -388,8 +392,8 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("instant", "2009-10-31T12:00:00.000Z");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
-		assertThat(binder.getBindingResult().getFieldValue("instant").toString()).startsWith("2009-10-31T12:00");
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+		assertThat(binder.getBindingResult().getFieldValue("instant").toString().startsWith("2009-10-31T12:00")).isTrue();
 	}
 
 	@Test
@@ -401,8 +405,8 @@ class DateTimeFormattingTests {
 			MutablePropertyValues propertyValues = new MutablePropertyValues();
 			propertyValues.add("instant", new Date(109, 9, 31, 12, 0));
 			binder.bind(propertyValues);
-			assertThat(binder.getBindingResult().getErrorCount()).isZero();
-			assertThat(binder.getBindingResult().getFieldValue("instant").toString()).startsWith("2009-10-31");
+			assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+			assertThat(binder.getBindingResult().getFieldValue("instant").toString().startsWith("2009-10-31")).isTrue();
 		}
 		finally {
 			TimeZone.setDefault(defaultZone);
@@ -414,8 +418,8 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("period", "P6Y3M1D");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
-		assertThat(binder.getBindingResult().getFieldValue("period").toString()).isEqualTo("P6Y3M1D");
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+		assertThat(binder.getBindingResult().getFieldValue("period").toString().equals("P6Y3M1D")).isTrue();
 	}
 
 	@Test
@@ -423,8 +427,8 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("duration", "PT8H6M12.345S");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
-		assertThat(binder.getBindingResult().getFieldValue("duration").toString()).isEqualTo("PT8H6M12.345S");
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+		assertThat(binder.getBindingResult().getFieldValue("duration").toString().equals("PT8H6M12.345S")).isTrue();
 	}
 
 	@Test
@@ -432,8 +436,8 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("year", "2007");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
-		assertThat(binder.getBindingResult().getFieldValue("year").toString()).isEqualTo("2007");
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+		assertThat(binder.getBindingResult().getFieldValue("year").toString().equals("2007")).isTrue();
 	}
 
 	@Test
@@ -441,8 +445,8 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("month", "JULY");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
-		assertThat(binder.getBindingResult().getFieldValue("month").toString()).isEqualTo("JULY");
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+		assertThat(binder.getBindingResult().getFieldValue("month").toString().equals("JULY")).isTrue();
 	}
 
 	@Test
@@ -450,8 +454,8 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("month", "July");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
-		assertThat(binder.getBindingResult().getFieldValue("month").toString()).isEqualTo("JULY");
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+		assertThat(binder.getBindingResult().getFieldValue("month").toString().equals("JULY")).isTrue();
 	}
 
 	@Test
@@ -459,8 +463,8 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("yearMonth", "2007-12");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
-		assertThat(binder.getBindingResult().getFieldValue("yearMonth").toString()).isEqualTo("2007-12");
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+		assertThat(binder.getBindingResult().getFieldValue("yearMonth").toString().equals("2007-12")).isTrue();
 	}
 
 	@Test
@@ -468,11 +472,10 @@ class DateTimeFormattingTests {
 		MutablePropertyValues propertyValues = new MutablePropertyValues();
 		propertyValues.add("monthDay", "--12-03");
 		binder.bind(propertyValues);
-		assertThat(binder.getBindingResult().getErrorCount()).isZero();
-		assertThat(binder.getBindingResult().getFieldValue("monthDay").toString()).isEqualTo("--12-03");
+		assertThat(binder.getBindingResult().getErrorCount()).isEqualTo(0);
+		assertThat(binder.getBindingResult().getFieldValue("monthDay").toString().equals("--12-03")).isTrue();
 	}
 
-
 	@Nested
 	class FallbackPatternTests {
 
@@ -484,7 +487,7 @@ class DateTimeFormattingTests {
 			propertyValues.add(propertyName, propertyValue);
 			binder.bind(propertyValues);
 			BindingResult bindingResult = binder.getBindingResult();
-			assertThat(bindingResult.getErrorCount()).isZero();
+			assertThat(bindingResult.getErrorCount()).isEqualTo(0);
 			assertThat(bindingResult.getFieldValue(propertyName)).isEqualTo("3/2/21");
 		}
 
@@ -496,12 +499,11 @@ class DateTimeFormattingTests {
 			propertyValues.add(propertyName, propertyValue);
 			binder.bind(propertyValues);
 			BindingResult bindingResult = binder.getBindingResult();
-			assertThat(bindingResult.getErrorCount()).isZero();
+			assertThat(bindingResult.getErrorCount()).isEqualTo(0);
 			assertThat(bindingResult.getFieldValue(propertyName)).isEqualTo("2021-03-02");
 		}
 
 		@ParameterizedTest(name = "input date: {0}")
-		// @ValueSource(strings = {"12:00:00\u202FPM", "12:00:00", "12:00"})
 		@ValueSource(strings = {"12:00:00 PM", "12:00:00", "12:00"})
 		void styleLocalTime(String propertyValue) {
 			String propertyName = "styleLocalTimeWithFallbackPatterns";
@@ -509,8 +511,7 @@ class DateTimeFormattingTests {
 			propertyValues.add(propertyName, propertyValue);
 			binder.bind(propertyValues);
 			BindingResult bindingResult = binder.getBindingResult();
-			assertThat(bindingResult.getErrorCount()).isZero();
-			// assertThat(bindingResult.getFieldValue(propertyName)).asString().matches("12:00:00\\SPM");
+			assertThat(bindingResult.getErrorCount()).isEqualTo(0);
 			assertThat(bindingResult.getFieldValue(propertyName)).isEqualTo("12:00:00 PM");
 		}
 
@@ -522,7 +523,7 @@ class DateTimeFormattingTests {
 			propertyValues.add(propertyName, propertyValue);
 			binder.bind(propertyValues);
 			BindingResult bindingResult = binder.getBindingResult();
-			assertThat(bindingResult.getErrorCount()).isZero();
+			assertThat(bindingResult.getErrorCount()).isEqualTo(0);
 			assertThat(bindingResult.getFieldValue(propertyName)).isEqualTo("2021-03-02T12:00:00");
 		}
 
@@ -564,10 +565,10 @@ class DateTimeFormattingTests {
 		@DateTimeFormat(style = "M-")
 		private LocalDate styleLocalDate;
 
-		@DateTimeFormat(style = "S-", fallbackPatterns = {"yyyy-MM-dd", "yyyyMMdd", "yyyy.MM.dd"})
+		@DateTimeFormat(style = "S-", fallbackPatterns = { "yyyy-MM-dd", "yyyyMMdd", "yyyy.MM.dd" })
 		private LocalDate styleLocalDateWithFallbackPatterns;
 
-		@DateTimeFormat(pattern = "yyyy-MM-dd", fallbackPatterns = {"M/d/yy", "yyyyMMdd", "yyyy.MM.dd"})
+		@DateTimeFormat(pattern = "yyyy-MM-dd", fallbackPatterns = { "M/d/yy", "yyyyMMdd", "yyyy.MM.dd" })
 		private LocalDate patternLocalDateWithFallbackPatterns;
 
 		private LocalTime localTime;
@@ -575,7 +576,7 @@ class DateTimeFormattingTests {
 		@DateTimeFormat(style = "-M")
 		private LocalTime styleLocalTime;
 
-		@DateTimeFormat(style = "-M", fallbackPatterns = {"HH:mm:ss", "HH:mm"})
+		@DateTimeFormat(style = "-M", fallbackPatterns = { "HH:mm:ss", "HH:mm"})
 		private LocalTime styleLocalTimeWithFallbackPatterns;
 
 		private LocalDateTime localDateTime;
@@ -595,7 +596,7 @@ class DateTimeFormattingTests {
 		@DateTimeFormat(iso = ISO.DATE_TIME)
 		private LocalDateTime isoLocalDateTime;
 
-		@DateTimeFormat(iso = ISO.DATE_TIME, fallbackPatterns = {"yyyy-MM-dd HH:mm:ss", "M/d/yy HH:mm"})
+		@DateTimeFormat(iso = ISO.DATE_TIME, fallbackPatterns = { "yyyy-MM-dd HH:mm:ss", "M/d/yy HH:mm"})
 		private LocalDateTime isoLocalDateTimeWithFallbackPatterns;
 
 		private Instant instant;
@@ -614,6 +615,7 @@ class DateTimeFormattingTests {
 
 		private final List<DateTimeBean> children = new ArrayList<>();
 
+
 		public LocalDate getLocalDate() {
 			return this.localDate;
 		}

spring-context/src/test/java/org/springframework/format/datetime/standard/InstantFormatterTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * 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.
@@ -19,7 +19,6 @@ package org.springframework.format.datetime.standard;
 import java.text.ParseException;
 import java.time.Instant;
 import java.time.format.DateTimeFormatter;
-import java.util.Locale;
 import java.util.Random;
 import java.util.stream.Stream;
 
@@ -50,12 +49,13 @@ class InstantFormatterTests {
 
 	private final InstantFormatter instantFormatter = new InstantFormatter();
 
-
 	@ParameterizedTest
 	@ArgumentsSource(ISOSerializedInstantProvider.class)
 	void should_parse_an_ISO_formatted_string_representation_of_an_Instant(String input) throws ParseException {
 		Instant expected = DateTimeFormatter.ISO_INSTANT.parse(input, Instant::from);
-		Instant actual = instantFormatter.parse(input, Locale.US);
+
+		Instant actual = instantFormatter.parse(input, null);
+
 		assertThat(actual).isEqualTo(expected);
 	}
 
@@ -63,7 +63,9 @@ class InstantFormatterTests {
 	@ArgumentsSource(RFC1123SerializedInstantProvider.class)
 	void should_parse_an_RFC1123_formatted_string_representation_of_an_Instant(String input) throws ParseException {
 		Instant expected = DateTimeFormatter.RFC_1123_DATE_TIME.parse(input, Instant::from);
-		Instant actual = instantFormatter.parse(input, Locale.US);
+
+		Instant actual = instantFormatter.parse(input, null);
+
 		assertThat(actual).isEqualTo(expected);
 	}
 
@@ -71,11 +73,12 @@ class InstantFormatterTests {
 	@ArgumentsSource(RandomInstantProvider.class)
 	void should_serialize_an_Instant_using_ISO_format_and_ignoring_Locale(Instant input) {
 		String expected = DateTimeFormatter.ISO_INSTANT.format(input);
-		String actual = instantFormatter.print(input, Locale.US);
+
+		String actual = instantFormatter.print(input, null);
+
 		assertThat(actual).isEqualTo(expected);
 	}
 
-
 	private static class RandomInstantProvider implements ArgumentsProvider {
 
 		private static final long DATA_SET_SIZE = 10;
@@ -97,7 +100,6 @@ class InstantFormatterTests {
 		}
 	}
 
-
 	private static class ISOSerializedInstantProvider extends RandomInstantProvider {
 
 		@Override
@@ -106,7 +108,6 @@ class InstantFormatterTests {
 		}
 	}
 
-
 	private static class RFC1123SerializedInstantProvider extends RandomInstantProvider {
 
 		// RFC-1123 supports only 4-digit years

spring-context/src/test/resources/org/springframework/aop/aspectj/OverloadedAdviceTests.xml

@@ -18,6 +18,4 @@
 
 	<bean id="testBean" class="org.springframework.beans.testfixture.beans.TestBean"/>
 
-	<bean id="testBean2" class="org.springframework.beans.testfixture.beans.TestBean"/>
-
 </beans>

spring-core/src/main/java/org/springframework/core/BridgeMethodResolver.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -57,11 +57,11 @@ public final class BridgeMethodResolver {
 
 
 	/**
-	 * Find the local original method for the supplied {@link Method bridge Method}.
+	 * Find the original method for the supplied {@link Method bridge Method}.
 	 * <p>It is safe to call this method passing in a non-bridge {@link Method} instance.
 	 * In such a case, the supplied {@link Method} instance is returned directly to the caller.
 	 * Callers are <strong>not</strong> required to check for bridging before calling this method.
-	 * @param bridgeMethod the method to introspect against its declaring class
+	 * @param bridgeMethod the method to introspect
 	 * @return the original method (either the bridged method or the passed-in method
 	 * if no more specific one could be found)
 	 */
@@ -73,7 +73,8 @@ public final class BridgeMethodResolver {
 		if (bridgedMethod == null) {
 			// Gather all methods with matching name and parameter size.
 			List<Method> candidateMethods = new ArrayList<>();
-			MethodFilter filter = (candidateMethod -> isBridgedCandidateFor(candidateMethod, bridgeMethod));
+			MethodFilter filter = candidateMethod ->
+					isBridgedCandidateFor(candidateMethod, bridgeMethod);
 			ReflectionUtils.doWithMethods(bridgeMethod.getDeclaringClass(), candidateMethods::add, filter);
 			if (!candidateMethods.isEmpty()) {
 				bridgedMethod = candidateMethods.size() == 1 ?
@@ -94,10 +95,10 @@ public final class BridgeMethodResolver {
 	 * Returns {@code true} if the supplied '{@code candidateMethod}' can be
 	 * considered a valid candidate for the {@link Method} that is {@link Method#isBridge() bridged}
 	 * by the supplied {@link Method bridge Method}. This method performs inexpensive
-	 * checks and can be used to quickly filter for a set of possible matches.
+	 * checks and can be used quickly to filter for a set of possible matches.
 	 */
 	private static boolean isBridgedCandidateFor(Method candidateMethod, Method bridgeMethod) {
-		return (!candidateMethod.isBridge() &&
+		return (!candidateMethod.isBridge() && !candidateMethod.equals(bridgeMethod) &&
 				candidateMethod.getName().equals(bridgeMethod.getName()) &&
 				candidateMethod.getParameterCount() == bridgeMethod.getParameterCount());
 	}
@@ -120,8 +121,8 @@ public final class BridgeMethodResolver {
 				return candidateMethod;
 			}
 			else if (previousMethod != null) {
-				sameSig = sameSig && Arrays.equals(
-						candidateMethod.getGenericParameterTypes(), previousMethod.getGenericParameterTypes());
+				sameSig = sameSig &&
+						Arrays.equals(candidateMethod.getGenericParameterTypes(), previousMethod.getGenericParameterTypes());
 			}
 			previousMethod = candidateMethod;
 		}
@@ -162,8 +163,7 @@ public final class BridgeMethodResolver {
 				}
 			}
 			// A non-array type: compare the type itself.
-			if (!ClassUtils.resolvePrimitiveIfNecessary(candidateParameter).equals(
-					ClassUtils.resolvePrimitiveIfNecessary(genericParameter.toClass()))) {
+			if (!ClassUtils.resolvePrimitiveIfNecessary(candidateParameter).equals(ClassUtils.resolvePrimitiveIfNecessary(genericParameter.toClass()))) {
 				return false;
 			}
 		}
@@ -226,8 +226,8 @@ public final class BridgeMethodResolver {
 	/**
 	 * Compare the signatures of the bridge method and the method which it bridges. If
 	 * the parameter and return types are the same, it is a 'visibility' bridge method
-	 * introduced in Java 6 to fix <a href="https://bugs.openjdk.org/browse/JDK-6342411">
-	 * JDK-6342411</a>.
+	 * introduced in Java 6 to fix https://bugs.openjdk.org/browse/JDK-6342411.
+	 * See also https://stas-blogspot.blogspot.com/2010/03/java-bridge-methods-explained.html
 	 * @return whether signatures match as described
 	 */
 	public static boolean isVisibilityBridgeMethodPair(Method bridgeMethod, Method bridgedMethod) {

spring-core/src/main/java/org/springframework/core/annotation/AnnotationUtils.java

@@ -1052,16 +1052,16 @@ public abstract class AnnotationUtils {
 			return null;
 		}
 		try {
-			for (Method method : annotation.annotationType().getDeclaredMethods()) {
-				if (method.getName().equals(attributeName) && method.getParameterCount() == 0) {
-					return invokeAnnotationMethod(method, annotation);
-				}
-			}
+			Method method = annotation.annotationType().getDeclaredMethod(attributeName);
+			return invokeAnnotationMethod(method, annotation);
+		}
+		catch (NoSuchMethodException ex) {
+			return null;
 		}
 		catch (Throwable ex) {
 			handleValueRetrievalFailure(annotation, ex);
+			return null;
 		}
-		return null;
 	}
 
 	/**

spring-core/src/main/java/org/springframework/core/convert/support/ArrayToArrayConverter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -34,7 +34,6 @@ import org.springframework.util.ObjectUtils;
  *
  * @author Keith Donald
  * @author Phillip Webb
- * @author Sam Brannen
  * @since 3.0
  */
 final class ArrayToArrayConverter implements ConditionalGenericConverter {
@@ -65,7 +64,7 @@ final class ArrayToArrayConverter implements ConditionalGenericConverter {
 	public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
 		if (this.conversionService instanceof GenericConversionService) {
 			TypeDescriptor targetElement = targetType.getElementTypeDescriptor();
-			if (targetElement != null && targetType.getType().isInstance(source) &&
+			if (targetElement != null &&
 					((GenericConversionService) this.conversionService).canBypassConvert(
 							sourceType.getElementTypeDescriptor(), targetElement)) {
 				return source;

spring-core/src/test/java/org/springframework/core/convert/converter/DefaultConversionServiceTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -626,27 +626,9 @@ class DefaultConversionServiceTests {
 		assertThat(result[2]).isEqualTo(3);
 	}
 
-	@Test  // gh-33212
-	void convertIntArrayToObjectArray() {
-		Object[] result = conversionService.convert(new int[] {1, 2}, Object[].class);
-		assertThat(result).containsExactly(1, 2);
-	}
-
 	@Test
-	void convertIntArrayToFloatArray() {
-		Float[] result = conversionService.convert(new int[] {1, 2}, Float[].class);
-		assertThat(result).containsExactly(1.0F, 2.0F);
-	}
-
-	@Test
-	void convertIntArrayToPrimitiveFloatArray() {
-		float[] result = conversionService.convert(new int[] {1, 2}, float[].class);
-		assertThat(result).containsExactly(1.0F, 2.0F);
-	}
-
-	@Test
-	void convertPrimitiveByteArrayToByteWrapperArray() {
-		byte[] byteArray = {1, 2, 3};
+	void convertByteArrayToWrapperArray() {
+		byte[] byteArray = new byte[] {1, 2, 3};
 		Byte[] converted = conversionService.convert(byteArray, Byte[].class);
 		assertThat(converted).isEqualTo(new Byte[]{1, 2, 3});
 	}

spring-expression/src/main/java/org/springframework/expression/EvaluationContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -132,18 +132,4 @@ public interface EvaluationContext {
 	@Nullable
 	Object lookupVariable(String name);
 
-	/**
-	 * Determine if assignment is enabled within expressions evaluated by this evaluation
-	 * context.
-	 * <p>If this method returns {@code false}, the assignment ({@code =}), increment
-	 * ({@code ++}), and decrement ({@code --}) operators are disabled.
-	 * <p>By default, this method returns {@code true}. Concrete implementations may override
-	 * this <em>default</em> method to disable assignment.
-	 * @return {@code true} if assignment is enabled; {@code false} otherwise
-	 * @since 5.3.38
-	 */
-	default boolean isAssignmentEnabled() {
-		return true;
-	}
-
 }

spring-expression/src/main/java/org/springframework/expression/spel/ast/Assign.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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,8 +19,6 @@ package org.springframework.expression.spel.ast;
 import org.springframework.expression.EvaluationException;
 import org.springframework.expression.TypedValue;
 import org.springframework.expression.spel.ExpressionState;
-import org.springframework.expression.spel.SpelEvaluationException;
-import org.springframework.expression.spel.SpelMessage;
 
 /**
  * Represents assignment. An alternative to calling {@code setValue}
@@ -41,9 +39,6 @@ public class Assign extends SpelNodeImpl {
 
 	@Override
 	public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
-		if (!state.getEvaluationContext().isAssignmentEnabled()) {
-			throw new SpelEvaluationException(getStartPosition(), SpelMessage.NOT_ASSIGNABLE, toStringAST());
-		}
 		return this.children[0].setValueInternal(state, () -> this.children[1].getValueInternal(state));
 	}
 

spring-expression/src/main/java/org/springframework/expression/spel/ast/ConstructorReference.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -268,13 +268,6 @@ public class ConstructorReference extends SpelNodeImpl {
 		}
 
 		String type = (String) intendedArrayType;
-
-		if (state.getEvaluationContext().getConstructorResolvers().isEmpty()) {
-			// No constructor resolver -> no array construction either (as of 5.3.38)
-			throw new SpelEvaluationException(getStartPosition(), SpelMessage.CONSTRUCTOR_NOT_FOUND,
-					type + "[]", "[]");
-		}
-
 		Class<?> componentType;
 		TypeCode arrayTypeCode = TypeCode.forName(type);
 		if (arrayTypeCode == TypeCode.OBJECT) {

spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -226,8 +226,6 @@ public class Indexer extends SpelNodeImpl {
 			cf.loadTarget(mv);
 		}
 
-		SpelNodeImpl index = this.children[0];
-
 		if (this.indexedType == IndexedType.ARRAY) {
 			int insn;
 			if ("D".equals(this.exitTypeDescriptor)) {
@@ -264,14 +262,18 @@ public class Indexer extends SpelNodeImpl {
 						//depthPlusOne(exitTypeDescriptor)+"Ljava/lang/Object;");
 				insn = AALOAD;
 			}
-
-			generateIndexCode(mv, cf, index, int.class);
+			SpelNodeImpl index = this.children[0];
+			cf.enterCompilationScope();
+			index.generateCode(mv, cf);
+			cf.exitCompilationScope();
 			mv.visitInsn(insn);
 		}
 
 		else if (this.indexedType == IndexedType.LIST) {
 			mv.visitTypeInsn(CHECKCAST, "java/util/List");
-			generateIndexCode(mv, cf, index, int.class);
+			cf.enterCompilationScope();
+			this.children[0].generateCode(mv, cf);
+			cf.exitCompilationScope();
 			mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "get", "(I)Ljava/lang/Object;", true);
 		}
 
@@ -279,13 +281,15 @@ public class Indexer extends SpelNodeImpl {
 			mv.visitTypeInsn(CHECKCAST, "java/util/Map");
 			// Special case when the key is an unquoted string literal that will be parsed as
 			// a property/field reference
-			if (index instanceof PropertyOrFieldReference) {
+			if ((this.children[0] instanceof PropertyOrFieldReference)) {
 				PropertyOrFieldReference reference = (PropertyOrFieldReference) this.children[0];
 				String mapKeyName = reference.getName();
 				mv.visitLdcInsn(mapKeyName);
 			}
 			else {
-				generateIndexCode(mv, cf, index, Object.class);
+				cf.enterCompilationScope();
+				this.children[0].generateCode(mv, cf);
+				cf.exitCompilationScope();
 			}
 			mv.visitMethodInsn(
 					INVOKEINTERFACE, "java/util/Map", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", true);
@@ -321,11 +325,6 @@ public class Indexer extends SpelNodeImpl {
 		cf.pushDescriptor(this.exitTypeDescriptor);
 	}
 
-	private void generateIndexCode(MethodVisitor mv, CodeFlow cf, SpelNodeImpl indexNode, Class<?> indexType) {
-		String indexDesc = CodeFlow.toDescriptor(indexType);
-		generateCodeForArgument(mv, cf, indexNode, indexDesc);
-	}
-
 	@Override
 	public String toStringAST() {
 		StringJoiner sj = new StringJoiner(",", "[", "]");
@@ -634,8 +633,6 @@ public class Indexer extends SpelNodeImpl {
 				throw new SpelEvaluationException(getStartPosition(), ex,
 						SpelMessage.EXCEPTION_DURING_PROPERTY_WRITE, this.name, ex.getMessage());
 			}
-			throw new SpelEvaluationException(getStartPosition(),
-					SpelMessage.INDEXING_NOT_SUPPORTED_FOR_TYPE, this.targetObjectTypeDescriptor.toString());
 		}
 
 		@Override

spring-expression/src/main/java/org/springframework/expression/spel/ast/OpDec.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * 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.
@@ -34,7 +34,6 @@ import org.springframework.util.Assert;
  * @author Andy Clement
  * @author Juergen Hoeller
  * @author Giovanni Dall'Oglio Risso
- * @author Sam Brannen
  * @since 3.2
  */
 public class OpDec extends Operator {
@@ -51,10 +50,6 @@ public class OpDec extends Operator {
 
 	@Override
 	public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
-		if (!state.getEvaluationContext().isAssignmentEnabled()) {
-			throw new SpelEvaluationException(getStartPosition(), SpelMessage.OPERAND_NOT_DECREMENTABLE, toStringAST());
-		}
-
 		SpelNodeImpl operand = getLeftOperand();
 
 		// The operand is going to be read and then assigned to, we don't want to evaluate it twice.

spring-expression/src/main/java/org/springframework/expression/spel/ast/OpInc.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * 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.
@@ -34,7 +34,6 @@ import org.springframework.util.Assert;
  * @author Andy Clement
  * @author Juergen Hoeller
  * @author Giovanni Dall'Oglio Risso
- * @author Sam Brannen
  * @since 3.2
  */
 public class OpInc extends Operator {
@@ -51,10 +50,6 @@ public class OpInc extends Operator {
 
 	@Override
 	public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
-		if (!state.getEvaluationContext().isAssignmentEnabled()) {
-			throw new SpelEvaluationException(getStartPosition(), SpelMessage.OPERAND_NOT_INCREMENTABLE, toStringAST());
-		}
-
 		SpelNodeImpl operand = getLeftOperand();
 		ValueRef valueRef = operand.getValueRef(state);
 
@@ -109,7 +104,7 @@ public class OpInc extends Operator {
 			}
 		}
 
-		// set the new value
+		// set the name value
 		try {
 			valueRef.setValue(newValue.getValue());
 		}

spring-expression/src/main/java/org/springframework/expression/spel/support/SimpleEvaluationContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -51,26 +51,25 @@ import org.springframework.lang.Nullable;
  * SpEL language syntax, e.g. excluding references to Java types, constructors,
  * and bean references.
  *
- * <p>When creating a {@code SimpleEvaluationContext} you need to choose the level of
- * support that you need for data binding in SpEL expressions:
+ * <p>When creating a {@code SimpleEvaluationContext} you need to choose the
+ * level of support that you need for property access in SpEL expressions:
  * <ul>
- * <li>Data binding for read-only access</li>
- * <li>Data binding for read and write access</li>
- * <li>A custom {@code PropertyAccessor} (typically not reflection-based), potentially
- * combined with a {@link DataBindingPropertyAccessor}</li>
+ * <li>A custom {@code PropertyAccessor} (typically not reflection-based),
+ * potentially combined with a {@link DataBindingPropertyAccessor}</li>
+ * <li>Data binding properties for read-only access</li>
+ * <li>Data binding properties for read and write</li>
  * </ul>
  *
- * <p>Conveniently, {@link SimpleEvaluationContext#forReadOnlyDataBinding()} enables
- * read-only access to properties via {@link DataBindingPropertyAccessor}. Similarly,
- * {@link SimpleEvaluationContext#forReadWriteDataBinding()} enables read and write access
- * to properties. Alternatively, configure custom accessors via
- * {@link SimpleEvaluationContext#forPropertyAccessors}, potentially
- * {@linkplain Builder#withAssignmentDisabled() disable assignment}, and optionally
+ * <p>Conveniently, {@link SimpleEvaluationContext#forReadOnlyDataBinding()}
+ * enables read access to properties via {@link DataBindingPropertyAccessor};
+ * same for {@link SimpleEvaluationContext#forReadWriteDataBinding()} when
+ * write access is needed as well. Alternatively, configure custom accessors
+ * via {@link SimpleEvaluationContext#forPropertyAccessors}, and potentially
  * activate method resolution and/or a type converter through the builder.
  *
  * <p>Note that {@code SimpleEvaluationContext} is typically not configured
  * with a default root object. Instead it is meant to be created once and
- * used repeatedly through {@code getValue} calls on a predefined
+ * used repeatedly through {@code getValue} calls on a pre-compiled
  * {@link org.springframework.expression.Expression} with both an
  * {@code EvaluationContext} and a root object as arguments:
  * {@link org.springframework.expression.Expression#getValue(EvaluationContext, Object)}.
@@ -82,9 +81,9 @@ import org.springframework.lang.Nullable;
  * @author Juergen Hoeller
  * @author Sam Brannen
  * @since 4.3.15
+ * @see #forPropertyAccessors
  * @see #forReadOnlyDataBinding()
  * @see #forReadWriteDataBinding()
- * @see #forPropertyAccessors
  * @see StandardEvaluationContext
  * @see StandardTypeConverter
  * @see DataBindingPropertyAccessor
@@ -110,17 +109,14 @@ public final class SimpleEvaluationContext implements EvaluationContext {
 
 	private final Map<String, Object> variables = new HashMap<>();
 
-	private final boolean assignmentEnabled;
-
 
 	private SimpleEvaluationContext(List<PropertyAccessor> accessors, List<MethodResolver> resolvers,
-			@Nullable TypeConverter converter, @Nullable TypedValue rootObject, boolean assignmentEnabled) {
+			@Nullable TypeConverter converter, @Nullable TypedValue rootObject) {
 
 		this.propertyAccessors = accessors;
 		this.methodResolvers = resolvers;
 		this.typeConverter = (converter != null ? converter : new StandardTypeConverter());
 		this.rootObject = (rootObject != null ? rootObject : TypedValue.NULL);
-		this.assignmentEnabled = assignmentEnabled;
 	}
 
 
@@ -228,35 +224,15 @@ public final class SimpleEvaluationContext implements EvaluationContext {
 		return this.variables.get(name);
 	}
 
-	/**
-	 * Determine if assignment is enabled within expressions evaluated by this evaluation
-	 * context.
-	 * <p>If this method returns {@code false}, the assignment ({@code =}), increment
-	 * ({@code ++}), and decrement ({@code --}) operators are disabled.
-	 * @return {@code true} if assignment is enabled; {@code false} otherwise
-	 * @since 5.3.38
-	 * @see #forReadOnlyDataBinding()
-	 * @see Builder#withAssignmentDisabled()
-	 */
-	@Override
-	public boolean isAssignmentEnabled() {
-		return this.assignmentEnabled;
-	}
 
 	/**
 	 * Create a {@code SimpleEvaluationContext} for the specified {@link PropertyAccessor}
-	 * delegates: typically a custom {@code PropertyAccessor} specific to a use case &mdash;
-	 * for example, for attribute resolution in a custom data structure &mdash; potentially
-	 * combined with a {@link DataBindingPropertyAccessor} if property dereferences are
-	 * needed as well.
-	 * <p>By default, assignment is enabled within expressions evaluated by the context
-	 * created via this factory method; however, assignment can be disabled via
-	 * {@link Builder#withAssignmentDisabled()}.
+	 * delegates: typically a custom {@code PropertyAccessor} specific to a use case
+	 * (e.g. attribute resolution in a custom data structure), potentially combined with
+	 * a {@link DataBindingPropertyAccessor} if property dereferences are needed as well.
 	 * @param accessors the accessor delegates to use
 	 * @see DataBindingPropertyAccessor#forReadOnlyAccess()
 	 * @see DataBindingPropertyAccessor#forReadWriteAccess()
-	 * @see #isAssignmentEnabled()
-	 * @see Builder#withAssignmentDisabled()
 	 */
 	public static Builder forPropertyAccessors(PropertyAccessor... accessors) {
 		for (PropertyAccessor accessor : accessors) {
@@ -271,28 +247,18 @@ public final class SimpleEvaluationContext implements EvaluationContext {
 	/**
 	 * Create a {@code SimpleEvaluationContext} for read-only access to
 	 * public properties via {@link DataBindingPropertyAccessor}.
-	 * <p>Assignment is disabled within expressions evaluated by the context created via
-	 * this factory method.
 	 * @see DataBindingPropertyAccessor#forReadOnlyAccess()
 	 * @see #forPropertyAccessors
-	 * @see #isAssignmentEnabled()
-	 * @see Builder#withAssignmentDisabled()
 	 */
 	public static Builder forReadOnlyDataBinding() {
-		return new Builder(DataBindingPropertyAccessor.forReadOnlyAccess()).withAssignmentDisabled();
+		return new Builder(DataBindingPropertyAccessor.forReadOnlyAccess());
 	}
 
 	/**
 	 * Create a {@code SimpleEvaluationContext} for read-write access to
 	 * public properties via {@link DataBindingPropertyAccessor}.
-	 * <p>By default, assignment is enabled within expressions evaluated by the context
-	 * created via this factory method. Assignment can be disabled via
-	 * {@link Builder#withAssignmentDisabled()}; however, it is preferable to use
-	 * {@link #forReadOnlyDataBinding()} if you desire read-only access.
 	 * @see DataBindingPropertyAccessor#forReadWriteAccess()
 	 * @see #forPropertyAccessors
-	 * @see #isAssignmentEnabled()
-	 * @see Builder#withAssignmentDisabled()
 	 */
 	public static Builder forReadWriteDataBinding() {
 		return new Builder(DataBindingPropertyAccessor.forReadWriteAccess());
@@ -302,7 +268,7 @@ public final class SimpleEvaluationContext implements EvaluationContext {
 	/**
 	 * Builder for {@code SimpleEvaluationContext}.
 	 */
-	public static final class Builder {
+	public static class Builder {
 
 		private final List<PropertyAccessor> accessors;
 
@@ -314,24 +280,10 @@ public final class SimpleEvaluationContext implements EvaluationContext {
 		@Nullable
 		private TypedValue rootObject;
 
-		private boolean assignmentEnabled = true;
-
-
-		private Builder(PropertyAccessor... accessors) {
+		public Builder(PropertyAccessor... accessors) {
 			this.accessors = Arrays.asList(accessors);
 		}
 
-
-		/**
-		 * Disable assignment within expressions evaluated by this evaluation context.
-		 * @since 5.3.38
-		 * @see SimpleEvaluationContext#isAssignmentEnabled()
-		 */
-		public Builder withAssignmentDisabled() {
-			this.assignmentEnabled = false;
-			return this;
-		}
-
 		/**
 		 * Register the specified {@link MethodResolver} delegates for
 		 * a combination of property access and method resolution.
@@ -363,6 +315,7 @@ public final class SimpleEvaluationContext implements EvaluationContext {
 			return this;
 		}
 
+
 		/**
 		 * Register a custom {@link ConversionService}.
 		 * <p>By default a {@link StandardTypeConverter} backed by a
@@ -374,7 +327,6 @@ public final class SimpleEvaluationContext implements EvaluationContext {
 			this.typeConverter = new StandardTypeConverter(conversionService);
 			return this;
 		}
-
 		/**
 		 * Register a custom {@link TypeConverter}.
 		 * <p>By default a {@link StandardTypeConverter} backed by a
@@ -410,8 +362,7 @@ public final class SimpleEvaluationContext implements EvaluationContext {
 		}
 
 		public SimpleEvaluationContext build() {
-			return new SimpleEvaluationContext(this.accessors, this.resolvers, this.typeConverter, this.rootObject,
-					this.assignmentEnabled);
+			return new SimpleEvaluationContext(this.accessors, this.resolvers, this.typeConverter, this.rootObject);
 		}
 	}
 

spring-expression/src/test/java/org/springframework/expression/spel/ArrayConstructorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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,21 +18,17 @@ package org.springframework.expression.spel;
 
 import org.junit.jupiter.api.Test;
 
-import org.springframework.expression.EvaluationContext;
 import org.springframework.expression.Expression;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
-import org.springframework.expression.spel.support.SimpleEvaluationContext;
 import org.springframework.util.ObjectUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
 /**
  * Test construction of arrays.
  *
  * @author Andy Clement
  * @author Sam Brannen
- * @author Juergen Hoeller
  */
 class ArrayConstructorTests extends AbstractExpressionTests {
 
@@ -101,7 +97,7 @@ class ArrayConstructorTests extends AbstractExpressionTests {
 	void typeArrayConstructors() {
 		evaluate("new String[]{'a','b','c','d'}[1]", "b", String.class);
 		evaluateAndCheckError("new String[]{'a','b','c','d'}.size()", SpelMessage.METHOD_NOT_FOUND, 30, "size()",
-				"java.lang.String[]");
+			"java.lang.String[]");
 		evaluate("new String[]{'a','b','c','d'}.length", 4, Integer.class);
 	}
 
@@ -114,18 +110,10 @@ class ArrayConstructorTests extends AbstractExpressionTests {
 	void multiDimensionalArrays() {
 		evaluate("new String[2][2]", "[Ljava.lang.String;[2]{[2]{null,null},[2]{null,null}}", String[][].class);
 		evaluate("new String[3][2][1]",
-				"[[Ljava.lang.String;[3]{[2]{[1]{null},[1]{null}},[2]{[1]{null},[1]{null}},[2]{[1]{null},[1]{null}}}",
-				String[][][].class);
+			"[[Ljava.lang.String;[3]{[2]{[1]{null},[1]{null}},[2]{[1]{null},[1]{null}},[2]{[1]{null},[1]{null}}}",
+			String[][][].class);
 	}
 
-	@Test
-	void noArrayConstruction() {
-		EvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();
-		assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() ->
-				parser.parseExpression("new int[2]").getValue(context));
-	}
-
-
 	private void evaluateArrayBuildingExpression(String expression, String expectedToString) {
 		SpelExpressionParser parser = new SpelExpressionParser();
 		Expression e = parser.parseExpression(expression);

spring-expression/src/test/java/org/springframework/expression/spel/CompilableMapAccessor.java

@@ -1,117 +0,0 @@
-/*
- * Copyright 2002-2024 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;
-
-import java.util.Map;
-
-import org.springframework.asm.MethodVisitor;
-import org.springframework.expression.AccessException;
-import org.springframework.expression.EvaluationContext;
-import org.springframework.expression.TypedValue;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
-
-/**
- * This is a local COPY of {@link org.springframework.context.expression.MapAccessor}.
- *
- * @author Juergen Hoeller
- * @author Andy Clement
- * @since 4.1
- */
-public class CompilableMapAccessor implements CompilablePropertyAccessor {
-
-	@Override
-	public Class<?>[] getSpecificTargetClasses() {
-		return new Class<?>[] {Map.class};
-	}
-
-	@Override
-	public boolean canRead(EvaluationContext context, @Nullable Object target, String name) throws AccessException {
-		return (target instanceof Map && ((Map<?, ?>) target).containsKey(name));
-	}
-
-	@Override
-	public TypedValue read(EvaluationContext context, @Nullable Object target, String name) throws AccessException {
-		Assert.state(target instanceof Map, "Target must be of type Map");
-		Map<?, ?> map = (Map<?, ?>) target;
-		Object value = map.get(name);
-		if (value == null && !map.containsKey(name)) {
-			throw new MapAccessException(name);
-		}
-		return new TypedValue(value);
-	}
-
-	@Override
-	public boolean canWrite(EvaluationContext context, @Nullable Object target, String name) throws AccessException {
-		return true;
-	}
-
-	@Override
-	@SuppressWarnings("unchecked")
-	public void write(EvaluationContext context, @Nullable Object target, String name, @Nullable Object newValue)
-			throws AccessException {
-
-		Assert.state(target instanceof Map, "Target must be a Map");
-		Map<Object, Object> map = (Map<Object, Object>) target;
-		map.put(name, newValue);
-	}
-
-	@Override
-	public boolean isCompilable() {
-		return true;
-	}
-
-	@Override
-	public Class<?> getPropertyType() {
-		return Object.class;
-	}
-
-	@Override
-	public void generateCode(String propertyName, MethodVisitor mv, CodeFlow cf) {
-		String descriptor = cf.lastDescriptor();
-		if (descriptor == null || !descriptor.equals("Ljava/util/Map")) {
-			if (descriptor == null) {
-				cf.loadTarget(mv);
-			}
-			CodeFlow.insertCheckCast(mv, "Ljava/util/Map");
-		}
-		mv.visitLdcInsn(propertyName);
-		mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "get","(Ljava/lang/Object;)Ljava/lang/Object;",true);
-	}
-
-
-	/**
-	 * Exception thrown from {@code read} in order to reset a cached
-	 * PropertyAccessor, allowing other accessors to have a try.
-	 */
-	@SuppressWarnings("serial")
-	private static class MapAccessException extends AccessException {
-
-		private final String key;
-
-		public MapAccessException(String key) {
-			super("");
-			this.key = key;
-		}
-
-		@Override
-		public String getMessage() {
-			return "Map does not contain a value for key '" + this.key + "'";
-		}
-	}
-
-}

spring-expression/src/test/java/org/springframework/expression/spel/PropertyAccessTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -21,7 +21,6 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
-import org.assertj.core.api.ThrowableTypeAssert;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.core.convert.TypeDescriptor;
@@ -84,11 +83,11 @@ public class PropertyAccessTests extends AbstractExpressionTests {
 	void accessingOnNullObject() {
 		SpelExpression expr = (SpelExpression) parser.parseExpression("madeup");
 		EvaluationContext context = new StandardEvaluationContext(null);
-		assertThatSpelEvaluationException()
+		assertThatExceptionOfType(SpelEvaluationException.class)
 			.isThrownBy(() -> expr.getValue(context))
 			.extracting(SpelEvaluationException::getMessageCode).isEqualTo(SpelMessage.PROPERTY_OR_FIELD_NOT_READABLE_ON_NULL);
 		assertThat(expr.isWritable(context)).isFalse();
-		assertThatSpelEvaluationException()
+		assertThatExceptionOfType(SpelEvaluationException.class)
 			.isThrownBy(() -> expr.setValue(context, "abc"))
 			.extracting(SpelEvaluationException::getMessageCode).isEqualTo(SpelMessage.PROPERTY_OR_FIELD_NOT_WRITABLE_ON_NULL);
 	}
@@ -118,7 +117,8 @@ public class PropertyAccessTests extends AbstractExpressionTests {
 		assertThat((int) i).isEqualTo(99);
 
 		// Cannot set it to a string value
-		assertThatSpelEvaluationException().isThrownBy(() -> flibbleexpr.setValue(ctx, "not allowed"));
+		assertThatExceptionOfType(EvaluationException.class).isThrownBy(() ->
+				flibbleexpr.setValue(ctx, "not allowed"));
 		// message will be: EL1063E:(pos 20): A problem occurred whilst attempting to set the property
 		// 'flibbles': 'Cannot set flibbles to an object of type 'class java.lang.String''
 		// System.out.println(e.getMessage());
@@ -173,7 +173,8 @@ public class PropertyAccessTests extends AbstractExpressionTests {
 	@Test
 	void noGetClassAccess() {
 		EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
-		assertThatSpelEvaluationException().isThrownBy(() -> parser.parseExpression("'a'.class.name").getValue(context));
+		assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() ->
+				parser.parseExpression("'a'.class.name").getValue(context));
 	}
 
 	@Test
@@ -186,13 +187,8 @@ public class PropertyAccessTests extends AbstractExpressionTests {
 		target.setName("p2");
 		assertThat(expr.getValue(context, target)).isEqualTo("p2");
 
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("name='p3'").getValue(context, target))
-				.extracting(SpelEvaluationException::getMessageCode).isEqualTo(SpelMessage.NOT_ASSIGNABLE);
-
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("['name']='p4'").getValue(context, target))
-				.extracting(SpelEvaluationException::getMessageCode).isEqualTo(SpelMessage.NOT_ASSIGNABLE);
+		assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() ->
+				parser.parseExpression("name='p3'").getValue(context, target));
 	}
 
 	@Test
@@ -205,9 +201,8 @@ public class PropertyAccessTests extends AbstractExpressionTests {
 		RecordPerson target2 = new RecordPerson("p2");
 		assertThat(expr.getValue(context, target2)).isEqualTo("p2");
 
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("name='p3'").getValue(context, target2))
-				.extracting(SpelEvaluationException::getMessageCode).isEqualTo(SpelMessage.NOT_ASSIGNABLE);
+		assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() ->
+				parser.parseExpression("name='p3'").getValue(context, target2));
 	}
 
 	@Test
@@ -253,7 +248,7 @@ public class PropertyAccessTests extends AbstractExpressionTests {
 	void propertyAccessWithoutMethodResolver() {
 		EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
 		Person target = new Person("p1");
-		assertThatSpelEvaluationException().isThrownBy(() ->
+		assertThatExceptionOfType(SpelEvaluationException.class).isThrownBy(() ->
 				parser.parseExpression("name.substring(1)").getValue(context, target));
 	}
 
@@ -279,17 +274,12 @@ public class PropertyAccessTests extends AbstractExpressionTests {
 	void propertyAccessWithArrayIndexOutOfBounds() {
 		EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
 		Expression expression = parser.parseExpression("stringArrayOfThreeItems[3]");
-		assertThatSpelEvaluationException()
+		assertThatExceptionOfType(SpelEvaluationException.class)
 			.isThrownBy(() -> expression.getValue(context, new Inventor()))
 			.extracting(SpelEvaluationException::getMessageCode).isEqualTo(SpelMessage.ARRAY_INDEX_OUT_OF_BOUNDS);
 	}
 
 
-	private ThrowableTypeAssert<SpelEvaluationException> assertThatSpelEvaluationException() {
-		return assertThatExceptionOfType(SpelEvaluationException.class);
-	}
-
-
 	// This can resolve the property 'flibbles' on any String (very useful...)
 	private static class StringyPropertyAccessor implements PropertyAccessor {
 

spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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,8 +20,6 @@ import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -29,10 +27,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.StringTokenizer;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
-import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.asm.MethodVisitor;
@@ -60,7 +55,6 @@ import static org.assertj.core.api.InstanceOfAssertFactories.BOOLEAN;
  * Checks SpelCompiler behavior. This should cover compilation all compiled node types.
  *
  * @author Andy Clement
- * @author Sam Brannen
  * @since 4.1
  */
 public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@@ -135,488 +129,6 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
 	private SpelNodeImpl ast;
 
 
-	@Nested
-	class VariableReferenceTests {
-
-		@Test
-		void userDefinedVariable() {
-			EvaluationContext ctx = new StandardEvaluationContext();
-			ctx.setVariable("target", "abc");
-			expression = parser.parseExpression("#target");
-			assertThat(expression.getValue(ctx)).isEqualTo("abc");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(ctx)).isEqualTo("abc");
-			ctx.setVariable("target", "123");
-			assertThat(expression.getValue(ctx)).isEqualTo("123");
-
-			// Changing the variable type from String to Integer results in a
-			// ClassCastException in the compiled code.
-			ctx.setVariable("target", 42);
-			assertThatExceptionOfType(SpelEvaluationException.class)
-				.isThrownBy(() -> expression.getValue(ctx))
-				.withCauseInstanceOf(ClassCastException.class);
-
-			ctx.setVariable("target", "abc");
-			expression = parser.parseExpression("#target.charAt(0)");
-			assertThat(expression.getValue(ctx)).isEqualTo('a');
-			assertCanCompile(expression);
-			assertThat(expression.getValue(ctx)).isEqualTo('a');
-			ctx.setVariable("target", "1");
-			assertThat(expression.getValue(ctx)).isEqualTo('1');
-
-			// Changing the variable type from String to Integer results in a
-			// ClassCastException in the compiled code.
-			ctx.setVariable("target", 42);
-			assertThatExceptionOfType(SpelEvaluationException.class)
-				.isThrownBy(() -> expression.getValue(ctx))
-				.withCauseInstanceOf(ClassCastException.class);
-		}
-
-	}
-
-	@Nested
-	class IndexingTests {
-
-		@Test
-		void indexIntoPrimitiveShortArray() {
-			short[] shorts = { (short) 33, (short) 44, (short) 55 };
-
-			expression = parser.parseExpression("[2]");
-
-			assertThat(expression.getValue(shorts)).isEqualTo((short) 55);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(shorts)).isEqualTo((short) 55);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("S");
-		}
-
-		@Test
-		void indexIntoPrimitiveByteArray() {
-			byte[] bytes = { (byte) 2, (byte) 3, (byte) 4 };
-
-			expression = parser.parseExpression("[2]");
-
-			assertThat(expression.getValue(bytes)).isEqualTo((byte) 4);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(bytes)).isEqualTo((byte) 4);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("B");
-		}
-
-		@Test
-		void indexIntoPrimitiveIntArray() {
-			int[] ints = { 8, 9, 10 };
-
-			expression = parser.parseExpression("[2]");
-
-			assertThat(expression.getValue(ints)).isEqualTo(10);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(ints)).isEqualTo(10);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("I");
-		}
-
-		@Test
-		void indexIntoPrimitiveLongArray() {
-			long[] longs = { 2L, 3L, 4L };
-
-			expression = parser.parseExpression("[0]");
-
-			assertThat(expression.getValue(longs)).isEqualTo(2L);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(longs)).isEqualTo(2L);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("J");
-		}
-
-		@Test
-		void indexIntoPrimitiveFloatArray() {
-			float[] floats = { 6.0f, 7.0f, 8.0f };
-
-			expression = parser.parseExpression("[0]");
-
-			assertThat(expression.getValue(floats)).isEqualTo(6.0f);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(floats)).isEqualTo(6.0f);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("F");
-		}
-
-		@Test
-		void indexIntoPrimitiveDoubleArray() {
-			double[] doubles = { 3.0d, 4.0d, 5.0d };
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(expression.getValue(doubles)).isEqualTo(4.0d);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(doubles)).isEqualTo(4.0d);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("D");
-		}
-
-		@Test
-		void indexIntoPrimitiveCharArray() {
-			char[] chars = { 'a', 'b', 'c' };
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(expression.getValue(chars)).isEqualTo('b');
-			assertCanCompile(expression);
-			assertThat(expression.getValue(chars)).isEqualTo('b');
-			assertThat(getAst().getExitDescriptor()).isEqualTo("C");
-		}
-
-		@Test
-		void indexIntoStringArray() {
-			String[] strings = { "a", "b", "c" };
-
-			expression = parser.parseExpression("[0]");
-
-			assertThat(expression.getValue(strings)).isEqualTo("a");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(strings)).isEqualTo("a");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
-		}
-
-		@Test
-		void indexIntoNumberArray() {
-			Number[] numbers = { 2, 8, 9 };
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(expression.getValue(numbers)).isEqualTo(8);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(numbers)).isEqualTo(8);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Number");
-		}
-
-		@Test
-		void indexInto2DPrimitiveIntArray() {
-			int[][] array = new int[][] {
-				{ 1, 2, 3 },
-				{ 4, 5, 6 }
-			};
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(stringify(expression.getValue(array))).isEqualTo("4 5 6");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(array))).isEqualTo("4 5 6");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("[I");
-
-			expression = parser.parseExpression("[1][2]");
-
-			assertThat(stringify(expression.getValue(array))).isEqualTo("6");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(array))).isEqualTo("6");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("I");
-		}
-
-		@Test
-		void indexInto2DStringArray() {
-			String[][] array = new String[][] {
-				{ "a", "b", "c" },
-				{ "d", "e", "f" }
-			};
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(stringify(expression.getValue(array))).isEqualTo("d e f");
-			assertCanCompile(expression);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("[Ljava/lang/String");
-			assertThat(stringify(expression.getValue(array))).isEqualTo("d e f");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("[Ljava/lang/String");
-
-			expression = parser.parseExpression("[1][2]");
-
-			assertThat(stringify(expression.getValue(array))).isEqualTo("f");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(array))).isEqualTo("f");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
-		}
-
-		@Test
-		@SuppressWarnings("unchecked")
-		void indexIntoArrayOfListOfString() {
-			List<String>[] array = new List[] {
-				Arrays.asList("a", "b", "c"),
-				Arrays.asList("d", "e", "f")
-			};
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(stringify(expression.getValue(array))).isEqualTo("d e f");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(array))).isEqualTo("d e f");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/util/List");
-
-			expression = parser.parseExpression("[1][2]");
-
-			assertThat(stringify(expression.getValue(array))).isEqualTo("f");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(array))).isEqualTo("f");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		@Test
-		@SuppressWarnings("unchecked")
-		void indexIntoArrayOfMap() {
-			Map<String, String>[] array = new Map[] { Collections.singletonMap("key", "value1") };
-
-			expression = parser.parseExpression("[0]");
-
-			assertThat(stringify(expression.getValue(array))).isEqualTo("{key=value1}");
-			assertCanCompile(expression);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/util/Map");
-			assertThat(stringify(expression.getValue(array))).isEqualTo("{key=value1}");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/util/Map");
-
-			expression = parser.parseExpression("[0]['key']");
-
-			assertThat(stringify(expression.getValue(array))).isEqualTo("value1");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(array))).isEqualTo("value1");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		@Test
-		void indexIntoListOfString() {
-			List<String> list = Arrays.asList("aaa", "bbb", "ccc");
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(expression.getValue(list)).isEqualTo("bbb");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(list)).isEqualTo("bbb");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		@Test
-		void indexIntoListOfInteger() {
-			List<Integer> list = Arrays.asList(123, 456, 789);
-
-			expression = parser.parseExpression("[2]");
-
-			assertThat(expression.getValue(list)).isEqualTo(789);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(list)).isEqualTo(789);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		@Test
-		void indexIntoListOfStringArray() {
-			List<String[]> list = Arrays.asList(
-				new String[] { "a", "b", "c" },
-				new String[] { "d", "e", "f" }
-			);
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(stringify(expression.getValue(list))).isEqualTo("d e f");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(list))).isEqualTo("d e f");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-
-			expression = parser.parseExpression("[1][0]");
-
-			assertThat(stringify(expression.getValue(list))).isEqualTo("d");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(list))).isEqualTo("d");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
-		}
-
-		@Test
-		void indexIntoListOfIntegerArray() {
-			List<Integer[]> list = Arrays.asList(
-				new Integer[] { 1, 2, 3 },
-				new Integer[] { 4, 5, 6 }
-			);
-
-			expression = parser.parseExpression("[0]");
-
-			assertThat(stringify(expression.getValue(list))).isEqualTo("1 2 3");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(list))).isEqualTo("1 2 3");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-
-			expression = parser.parseExpression("[0][1]");
-
-			assertThat(expression.getValue(list)).isEqualTo(2);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(list)).isEqualTo(2);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Integer");
-		}
-
-		@Test
-		void indexIntoListOfListOfString() {
-			List<List<String>> list = Arrays.asList(
-					Arrays.asList("a", "b", "c"),
-					Arrays.asList("d", "e", "f")
-			);
-
-			expression = parser.parseExpression("[1]");
-
-			assertThat(stringify(expression.getValue(list))).isEqualTo("d e f");
-			assertCanCompile(expression);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-			assertThat(stringify(expression.getValue(list))).isEqualTo("d e f");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-
-			expression = parser.parseExpression("[1][2]");
-
-			assertThat(stringify(expression.getValue(list))).isEqualTo("f");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(list))).isEqualTo("f");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		@Test
-		void indexIntoMap() {
-			Map<String, Integer> map = Collections.singletonMap("aaa", 111);
-
-			expression = parser.parseExpression("['aaa']");
-
-			assertThat(expression.getValue(map)).isEqualTo(111);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(map)).isEqualTo(111);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		@Test
-		void indexIntoMapOfListOfString() {
-			Map<String, List<String>> map = Collections.singletonMap("foo", Arrays.asList("a", "b", "c"));
-
-			expression = parser.parseExpression("['foo']");
-
-			assertThat(stringify(expression.getValue(map))).isEqualTo("a b c");
-			assertCanCompile(expression);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-			assertThat(stringify(expression.getValue(map))).isEqualTo("a b c");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-
-			expression = parser.parseExpression("['foo'][2]");
-
-			assertThat(stringify(expression.getValue(map))).isEqualTo("c");
-			assertCanCompile(expression);
-			assertThat(stringify(expression.getValue(map))).isEqualTo("c");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		@Test
-		void indexIntoObject() {
-			TestClass6 tc = new TestClass6();
-
-			// field access
-			expression = parser.parseExpression("['orange']");
-
-			assertThat(expression.getValue(tc)).isEqualTo("value1");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(tc)).isEqualTo("value1");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
-
-			// field access
-			expression = parser.parseExpression("['peach']");
-
-			assertThat(expression.getValue(tc)).isEqualTo(34L);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(tc)).isEqualTo(34L);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("J");
-
-			// property access (getter)
-			expression = parser.parseExpression("['banana']");
-
-			assertThat(expression.getValue(tc)).isEqualTo("value3");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(tc)).isEqualTo("value3");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/String");
-		}
-
-		@Test  // gh-32694, gh-32908
-		void indexIntoArrayUsingIntegerWrapper() {
-			context.setVariable("array", new int[] {1, 2, 3, 4});
-			context.setVariable("index", 2);
-
-			expression = parser.parseExpression("#array[#index]");
-
-			assertThat(expression.getValue(context)).isEqualTo(3);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(context)).isEqualTo(3);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("I");
-		}
-
-		@Test  // gh-32694, gh-32908
-		void indexIntoListUsingIntegerWrapper() {
-			context.setVariable("list", Arrays.asList(1, 2, 3, 4));
-			context.setVariable("index", 2);
-
-			expression = parser.parseExpression("#list[#index]");
-
-			assertThat(expression.getValue(context)).isEqualTo(3);
-			assertCanCompile(expression);
-			assertThat(expression.getValue(context)).isEqualTo(3);
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		@Test  // gh-32903
-		void indexIntoMapUsingPrimitiveLiteral() {
-			Map<Object, String> map = new HashMap<>();
-			map.put(false, "0");    // BooleanLiteral
-			map.put(1, "ABC");      // IntLiteral
-			map.put(2L, "XYZ");     // LongLiteral
-			map.put(9.99F, "~10");  // FloatLiteral
-			map.put(3.14159, "PI"); // RealLiteral
-			context.setVariable("map", map);
-
-			// BooleanLiteral
-			expression = parser.parseExpression("#map[false]");
-			assertThat(expression.getValue(context)).isEqualTo("0");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(context)).isEqualTo("0");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-
-			// IntLiteral
-			expression = parser.parseExpression("#map[1]");
-			assertThat(expression.getValue(context)).isEqualTo("ABC");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(context)).isEqualTo("ABC");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-
-			// LongLiteral
-			expression = parser.parseExpression("#map[2L]");
-			assertThat(expression.getValue(context)).isEqualTo("XYZ");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(context)).isEqualTo("XYZ");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-
-			// FloatLiteral
-			expression = parser.parseExpression("#map[9.99F]");
-			assertThat(expression.getValue(context)).isEqualTo("~10");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(context)).isEqualTo("~10");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-
-			// RealLiteral
-			expression = parser.parseExpression("#map[3.14159]");
-			assertThat(expression.getValue(context)).isEqualTo("PI");
-			assertCanCompile(expression);
-			assertThat(expression.getValue(context)).isEqualTo("PI");
-			assertThat(getAst().getExitDescriptor()).isEqualTo("Ljava/lang/Object");
-		}
-
-		private String stringify(Object object) {
-			Stream<? extends Object> stream;
-			if (object instanceof Collection) {
-				stream = ((Collection<?>) object).stream();
-			}
-			else if (object instanceof Object[]) {
-				stream = Arrays.stream((Object[]) object);
-			}
-			else if (object instanceof int[]) {
-				stream = Arrays.stream((int[]) object).mapToObj(Integer::valueOf);
-			}
-			else {
-				return String.valueOf(object);
-			}
-			return stream.map(Object::toString).collect(Collectors.joining(" "));
-		}
-
-	}
-
 	@Test
 	void typeReference() {
 		expression = parse("T(String)");
@@ -5796,6 +5308,84 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
 	}
 
 
+	static class CompilableMapAccessor implements CompilablePropertyAccessor {
+
+		@Override
+		public boolean canRead(EvaluationContext context, Object target, String name) throws AccessException {
+			Map<?,?> map = (Map<?,?>) target;
+			return map.containsKey(name);
+		}
+
+		@Override
+		public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException {
+			Map<?,?> map = (Map<?,?>) target;
+			Object value = map.get(name);
+			if (value == null && !map.containsKey(name)) {
+				throw new MapAccessException(name);
+			}
+			return new TypedValue(value);
+		}
+
+		@Override
+		public boolean canWrite(EvaluationContext context, Object target, String name) throws AccessException {
+			return true;
+		}
+
+		@Override
+		@SuppressWarnings("unchecked")
+		public void write(EvaluationContext context, Object target, String name, Object newValue) throws AccessException {
+			Map<String, Object> map = (Map<String, Object>) target;
+			map.put(name, newValue);
+		}
+
+		@Override
+		public Class<?>[] getSpecificTargetClasses() {
+			return new Class<?>[] {Map.class};
+		}
+
+		@Override
+		public boolean isCompilable() {
+			return true;
+		}
+
+		@Override
+		public Class<?> getPropertyType() {
+			return Object.class;
+		}
+
+		@Override
+		public void generateCode(String propertyName, MethodVisitor mv, CodeFlow cf) {
+			String descriptor = cf.lastDescriptor();
+			if (descriptor == null) {
+				cf.loadTarget(mv);
+			}
+			mv.visitLdcInsn(propertyName);
+			mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "get","(Ljava/lang/Object;)Ljava/lang/Object;",true);
+		}
+	}
+
+
+	/**
+	 * Exception thrown from {@code read} in order to reset a cached
+	 * PropertyAccessor, allowing other accessors to have a try.
+	 */
+	@SuppressWarnings("serial")
+	private static class MapAccessException extends AccessException {
+
+		private final String key;
+
+		public MapAccessException(String key) {
+			super(null);
+			this.key = key;
+		}
+
+		@Override
+		public String getMessage() {
+			return "Map does not contain a value for key '" + this.key + "'";
+		}
+	}
+
+
 	public static class Greeter {
 
 		public String getWorld() {

spring-expression/src/test/java/org/springframework/expression/spel/support/SimpleEvaluationContextTests.java

@@ -1,530 +0,0 @@
-/*
- * Copyright 2002-2024 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.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.assertj.core.api.ThrowableTypeAssert;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.expression.Expression;
-import org.springframework.expression.spel.CompilableMapAccessor;
-import org.springframework.expression.spel.SpelEvaluationException;
-import org.springframework.expression.spel.SpelMessage;
-import org.springframework.expression.spel.standard.SpelExpressionParser;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.assertj.core.api.Assertions.entry;
-
-/**
- * Tests for {@link SimpleEvaluationContext}.
- *
- * <p>Some of the use cases in this test class are duplicated elsewhere within the test
- * suite; however, we include them here to consistently focus on related features in this
- * test class.
- *
- * @author Sam Brannen
- */
-class SimpleEvaluationContextTests {
-
-	private final SpelExpressionParser parser = new SpelExpressionParser();
-
-	private final Model model = new Model();
-
-
-	@Test
-	void forReadWriteDataBinding() {
-		SimpleEvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();
-
-		assertReadWriteMode(context);
-	}
-
-	@Test
-	void forReadOnlyDataBinding() {
-		SimpleEvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
-
-		assertCommonReadOnlyModeBehavior(context);
-
-		// WRITE -- via assignment operator
-
-		// Variable
-		assertAssignmentDisabled(context, "#myVar = 'rejected'");
-
-		// Property
-		assertAssignmentDisabled(context, "name = 'rejected'");
-		assertIncrementDisabled(context, "count++");
-		assertIncrementDisabled(context, "++count");
-		assertDecrementDisabled(context, "count--");
-		assertDecrementDisabled(context, "--count");
-
-		// Array Index
-		assertAssignmentDisabled(context, "array[0] = 'rejected'");
-		assertIncrementDisabled(context, "numbers[0]++");
-		assertIncrementDisabled(context, "++numbers[0]");
-		assertDecrementDisabled(context, "numbers[0]--");
-		assertDecrementDisabled(context, "--numbers[0]");
-
-		// List Index
-		assertAssignmentDisabled(context, "list[0] = 'rejected'");
-
-		// Map Index -- key as String
-		assertAssignmentDisabled(context, "map['red'] = 'rejected'");
-
-		// Map Index -- key as pseudo property name
-		assertAssignmentDisabled(context, "map[yellow] = 'rejected'");
-
-		// String Index
-		assertAssignmentDisabled(context, "name[0] = 'rejected'");
-
-		// Object Index
-		assertAssignmentDisabled(context, "['name'] = 'rejected'");
-	}
-
-	@Test
-	void forPropertyAccessorsInReadWriteMode() {
-		SimpleEvaluationContext context = SimpleEvaluationContext
-				.forPropertyAccessors(new CompilableMapAccessor(), DataBindingPropertyAccessor.forReadWriteAccess())
-				.build();
-
-		assertReadWriteMode(context);
-
-		// Map -- with key as property name supported by CompilableMapAccessor
-
-		Expression expression;
-		expression = parser.parseExpression("map.yellow");
-		expression.setValue(context, model, "pineapple");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("pineapple");
-
-		expression = parser.parseExpression("map.yellow = 'banana'");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("banana");
-		expression = parser.parseExpression("map.yellow");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("banana");
-	}
-
-	/**
-	 * We call this "mixed" read-only mode, because write access via PropertyAccessors is
-	 * disabled, but write access via the Indexer is not disabled.
-	 */
-	@Test
-	void forPropertyAccessorsInMixedReadOnlyMode() {
-		SimpleEvaluationContext context = SimpleEvaluationContext
-				.forPropertyAccessors(new CompilableMapAccessor(), DataBindingPropertyAccessor.forReadOnlyAccess())
-				.build();
-
-		assertCommonReadOnlyModeBehavior(context);
-
-		// Map -- with key as property name supported by CompilableMapAccessor
-
-		Expression expression;
-		expression = parser.parseExpression("map.yellow");
-		expression.setValue(context, model, "pineapple");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("pineapple");
-
-		expression = parser.parseExpression("map.yellow = 'banana'");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("banana");
-		expression = parser.parseExpression("map.yellow");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("banana");
-
-		// WRITE -- via assignment operator
-
-		// Variable
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("#myVar = 'rejected'").getValue(context, model))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.VARIABLE_ASSIGNMENT_NOT_SUPPORTED));
-
-		// Property
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("name = 'rejected'").getValue(context, model))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.PROPERTY_OR_FIELD_NOT_WRITABLE));
-
-		// Array Index
-		parser.parseExpression("array[0]").setValue(context, model, "foo");
-		assertThat(model.array).containsExactly("foo");
-
-		// List Index
-		parser.parseExpression("list[0]").setValue(context, model, "cat");
-		assertThat(model.list).containsExactly("cat");
-
-		// Map Index -- key as String
-		parser.parseExpression("map['red']").setValue(context, model, "cherry");
-		assertThat(model.map).containsOnly(entry("red", "cherry"), entry("yellow", "banana"));
-
-		// Map Index -- key as pseudo property name
-		parser.parseExpression("map[yellow]").setValue(context, model, "lemon");
-		assertThat(model.map).containsOnly(entry("red", "cherry"), entry("yellow", "lemon"));
-
-		// String Index
-		// The Indexer does not support writes when indexing into a String.
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("name[0] = 'rejected'").getValue(context, model))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.INDEXING_NOT_SUPPORTED_FOR_TYPE));
-
-		// Object Index
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("['name'] = 'rejected'").getValue(context, model))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.INDEXING_NOT_SUPPORTED_FOR_TYPE));
-
-		// WRITE -- via increment and decrement operators
-
-		assertIncrementAndDecrementWritesForIndexedStructures(context);
-	}
-
-	@Test
-	void forPropertyAccessorsWithAssignmentDisabled() {
-		SimpleEvaluationContext context = SimpleEvaluationContext
-				.forPropertyAccessors(new CompilableMapAccessor(), DataBindingPropertyAccessor.forReadOnlyAccess())
-				.withAssignmentDisabled()
-				.build();
-
-		assertCommonReadOnlyModeBehavior(context);
-
-		// Map -- with key as property name supported by CompilableMapAccessor
-
-		Expression expression;
-		expression = parser.parseExpression("map.yellow");
-		// setValue() is supported even though assignment is not.
-		expression.setValue(context, model, "pineapple");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("pineapple");
-
-		// WRITE -- via assignment operator
-
-		// Variable
-		assertAssignmentDisabled(context, "#myVar = 'rejected'");
-
-		// Property
-		assertAssignmentDisabled(context, "name = 'rejected'");
-		assertAssignmentDisabled(context, "map.yellow = 'rejected'");
-		assertIncrementDisabled(context, "count++");
-		assertIncrementDisabled(context, "++count");
-		assertDecrementDisabled(context, "count--");
-		assertDecrementDisabled(context, "--count");
-
-		// Array Index
-		assertAssignmentDisabled(context, "array[0] = 'rejected'");
-		assertIncrementDisabled(context, "numbers[0]++");
-		assertIncrementDisabled(context, "++numbers[0]");
-		assertDecrementDisabled(context, "numbers[0]--");
-		assertDecrementDisabled(context, "--numbers[0]");
-
-		// List Index
-		assertAssignmentDisabled(context, "list[0] = 'rejected'");
-
-		// Map Index -- key as String
-		assertAssignmentDisabled(context, "map['red'] = 'rejected'");
-
-		// Map Index -- key as pseudo property name
-		assertAssignmentDisabled(context, "map[yellow] = 'rejected'");
-
-		// String Index
-		assertAssignmentDisabled(context, "name[0] = 'rejected'");
-
-		// Object Index
-		assertAssignmentDisabled(context, "['name'] = 'rejected'");
-	}
-
-
-	private void assertReadWriteMode(SimpleEvaluationContext context) {
-		// Variables can always be set programmatically within an EvaluationContext.
-		context.setVariable("myVar", "enigma");
-
-		// WRITE -- via setValue()
-
-		// Property
-		parser.parseExpression("name").setValue(context, model, "test");
-		assertThat(model.name).isEqualTo("test");
-		parser.parseExpression("count").setValue(context, model, 42);
-		assertThat(model.count).isEqualTo(42);
-
-		// Array Index
-		parser.parseExpression("array[0]").setValue(context, model, "foo");
-		assertThat(model.array).containsExactly("foo");
-
-		// List Index
-		parser.parseExpression("list[0]").setValue(context, model, "cat");
-		assertThat(model.list).containsExactly("cat");
-
-		// Map Index -- key as String
-		parser.parseExpression("map['red']").setValue(context, model, "cherry");
-		assertThat(model.map).containsOnly(entry("red", "cherry"), entry("yellow", "replace me"));
-
-		// Map Index -- key as pseudo property name
-		parser.parseExpression("map[yellow]").setValue(context, model, "lemon");
-		assertThat(model.map).containsOnly(entry("red", "cherry"), entry("yellow", "lemon"));
-
-		// READ
-		assertReadAccess(context);
-
-		// WRITE -- via assignment operator
-
-		// Variable assignment is always disabled in a SimpleEvaluationContext.
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("#myVar = 'rejected'").getValue(context, model))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.VARIABLE_ASSIGNMENT_NOT_SUPPORTED));
-
-		Expression expression;
-
-		// Property
-		expression = parser.parseExpression("name = 'changed'");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("changed");
-		expression = parser.parseExpression("name");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("changed");
-
-		// Array Index
-		expression = parser.parseExpression("array[0] = 'bar'");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("bar");
-		expression = parser.parseExpression("array[0]");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("bar");
-
-		// List Index
-		expression = parser.parseExpression("list[0] = 'dog'");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("dog");
-		expression = parser.parseExpression("list[0]");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("dog");
-
-		// Map Index -- key as String
-		expression = parser.parseExpression("map['red'] = 'strawberry'");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("strawberry");
-		expression = parser.parseExpression("map['red']");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("strawberry");
-
-		// Map Index -- key as pseudo property name
-		expression = parser.parseExpression("map[yellow] = 'banana'");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("banana");
-		expression = parser.parseExpression("map[yellow]");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("banana");
-
-		// String Index
-		// The Indexer does not support writes when indexing into a String.
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("name[0] = 'rejected'").getValue(context, model))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.INDEXING_NOT_SUPPORTED_FOR_TYPE));
-
-		// Object Index
-		expression = parser.parseExpression("['name'] = 'new name'");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("new name");
-		expression = parser.parseExpression("['name']");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("new name");
-
-		// WRITE -- via increment and decrement operators
-
-		assertIncrementAndDecrementWritesForProperties(context);
-		assertIncrementAndDecrementWritesForIndexedStructures(context);
-	}
-
-	private void assertCommonReadOnlyModeBehavior(SimpleEvaluationContext context) {
-		// Variables can always be set programmatically within an EvaluationContext.
-		context.setVariable("myVar", "enigma");
-
-		// WRITE -- via setValue()
-
-		// Note: forReadOnlyDataBinding() disables programmatic writes via setValue() for
-		// properties but allows programmatic writes via setValue() for indexed structures.
-
-		// Property
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("name").setValue(context, model, "test"))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.PROPERTY_OR_FIELD_NOT_WRITABLE));
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression("count").setValue(context, model, 42))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.PROPERTY_OR_FIELD_NOT_WRITABLE));
-
-		// Array Index
-		parser.parseExpression("array[0]").setValue(context, model, "foo");
-		assertThat(model.array).containsExactly("foo");
-
-		// List Index
-		parser.parseExpression("list[0]").setValue(context, model, "cat");
-		assertThat(model.list).containsExactly("cat");
-
-		// Map Index -- key as String
-		parser.parseExpression("map['red']").setValue(context, model, "cherry");
-		assertThat(model.map).containsOnly(entry("red", "cherry"), entry("yellow", "replace me"));
-
-		// Map Index -- key as pseudo property name
-		parser.parseExpression("map[yellow]").setValue(context, model, "lemon");
-		assertThat(model.map).containsOnly(entry("red", "cherry"), entry("yellow", "lemon"));
-
-		// Since the setValue() attempts for "name" and "count" failed above, we have to set
-		// them directly for assertReadAccess().
-		model.name = "test";
-		model.count = 42;
-
-		// READ
-		assertReadAccess(context);
-	}
-
-	private void assertReadAccess(SimpleEvaluationContext context) {
-		Expression expression;
-
-		// Variable
-		expression = parser.parseExpression("#myVar");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("enigma");
-
-		// Property
-		expression = parser.parseExpression("name");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("test");
-		expression = parser.parseExpression("count");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(42);
-
-		// Array Index
-		expression = parser.parseExpression("array[0]");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("foo");
-
-		// List Index
-		expression = parser.parseExpression("list[0]");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("cat");
-
-		// Map Index -- key as String
-		expression = parser.parseExpression("map['red']");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("cherry");
-
-		// Map Index -- key as pseudo property name
-		expression = parser.parseExpression("map[yellow]");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("lemon");
-
-		// String Index
-		expression = parser.parseExpression("name[0]");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("t");
-
-		// Object Index
-		expression = parser.parseExpression("['name']");
-		assertThat(expression.getValue(context, model, String.class)).isEqualTo("test");
-	}
-
-	private void assertIncrementAndDecrementWritesForProperties(SimpleEvaluationContext context) {
-		Expression expression;
-		expression = parser.parseExpression("count++");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(42);
-		expression = parser.parseExpression("count");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(43);
-
-		expression = parser.parseExpression("++count");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(44);
-		expression = parser.parseExpression("count");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(44);
-
-		expression = parser.parseExpression("count--");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(44);
-		expression = parser.parseExpression("count");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(43);
-
-		expression = parser.parseExpression("--count");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(42);
-		expression = parser.parseExpression("count");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(42);
-	}
-
-	private void assertIncrementAndDecrementWritesForIndexedStructures(SimpleEvaluationContext context) {
-		Expression expression;
-		expression = parser.parseExpression("numbers[0]++");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(99);
-		expression = parser.parseExpression("numbers[0]");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(100);
-
-		expression = parser.parseExpression("++numbers[0]");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(101);
-		expression = parser.parseExpression("numbers[0]");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(101);
-
-		expression = parser.parseExpression("numbers[0]--");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(101);
-		expression = parser.parseExpression("numbers[0]");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(100);
-
-		expression = parser.parseExpression("--numbers[0]");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(99);
-		expression = parser.parseExpression("numbers[0]");
-		assertThat(expression.getValue(context, model, Integer.class)).isEqualTo(99);
-	}
-
-	private ThrowableTypeAssert<SpelEvaluationException> assertThatSpelEvaluationException() {
-		return assertThatExceptionOfType(SpelEvaluationException.class);
-	}
-
-	private void assertAssignmentDisabled(SimpleEvaluationContext context, String expression) {
-		assertEvaluationException(context, expression, SpelMessage.NOT_ASSIGNABLE);
-	}
-
-	private void assertIncrementDisabled(SimpleEvaluationContext context, String expression) {
-		assertEvaluationException(context, expression, SpelMessage.OPERAND_NOT_INCREMENTABLE);
-	}
-
-	private void assertDecrementDisabled(SimpleEvaluationContext context, String expression) {
-		assertEvaluationException(context, expression, SpelMessage.OPERAND_NOT_DECREMENTABLE);
-	}
-
-	private void assertEvaluationException(SimpleEvaluationContext context, String expression, SpelMessage spelMessage) {
-		assertThatSpelEvaluationException()
-				.isThrownBy(() -> parser.parseExpression(expression).getValue(context, model))
-				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(spelMessage));
-	}
-
-
-	static class Model {
-
-		private String name = "replace me";
-		private int count = 0;
-		private final String[] array = {"replace me"};
-		private final int[] numbers = {99};
-		private final List<String> list = new ArrayList<>();
-		private final Map<String, String> map = new HashMap<>();
-
-		Model() {
-			this.list.add("replace me");
-			this.map.put("red", "replace me");
-			this.map.put("yellow", "replace me");
-		}
-
-		public String getName() {
-			return this.name;
-		}
-
-		public void setName(String name) {
-			this.name = name;
-		}
-
-		public int getCount() {
-			return this.count;
-		}
-
-		public void setCount(int count) {
-			this.count = count;
-		}
-
-		public String[] getArray() {
-			return this.array;
-		}
-
-		public int[] getNumbers() {
-			return this.numbers;
-		}
-
-		public List<String> getList() {
-			return this.list;
-		}
-
-		public Map<String, String> getMap() {
-			return this.map;
-		}
-
-	}
-
-}

spring-orm/src/main/java/org/springframework/orm/jpa/persistenceunit/PersistenceUnitReader.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -154,7 +154,7 @@ final class PersistenceUnitReader {
 	/**
 	 * Validate the given stream and return a valid DOM document for parsing.
 	 */
-	Document buildDocument(ErrorHandler handler, InputStream stream)
+	protected Document buildDocument(ErrorHandler handler, InputStream stream)
 			throws ParserConfigurationException, SAXException, IOException {
 
 		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
@@ -168,7 +168,9 @@ final class PersistenceUnitReader {
 	/**
 	 * Parse the validated document and add entries to the given unit info list.
 	 */
-	void parseDocument(Resource resource, Document document, List<SpringPersistenceUnitInfo> infos) throws IOException {
+	protected List<SpringPersistenceUnitInfo> parseDocument(
+			Resource resource, Document document, List<SpringPersistenceUnitInfo> infos) throws IOException {
+
 		Element persistence = document.getDocumentElement();
 		String version = persistence.getAttribute(PERSISTENCE_VERSION);
 		URL rootUrl = determinePersistenceUnitRootUrl(resource);
@@ -177,12 +179,14 @@ final class PersistenceUnitReader {
 		for (Element unit : units) {
 			infos.add(parsePersistenceUnitInfo(unit, version, rootUrl));
 		}
+
+		return infos;
 	}
 
 	/**
 	 * Parse the unit info DOM element.
 	 */
-	SpringPersistenceUnitInfo parsePersistenceUnitInfo(
+	protected SpringPersistenceUnitInfo parsePersistenceUnitInfo(
 			Element persistenceUnit, String version, @Nullable URL rootUrl) throws IOException {
 
 		SpringPersistenceUnitInfo unitInfo = new SpringPersistenceUnitInfo();
@@ -249,7 +253,7 @@ final class PersistenceUnitReader {
 	/**
 	 * Parse the {@code property} XML elements.
 	 */
-	void parseProperties(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) {
+	protected void parseProperties(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) {
 		Element propRoot = DomUtils.getChildElementByTagName(persistenceUnit, PROPERTIES);
 		if (propRoot == null) {
 			return;
@@ -265,7 +269,7 @@ final class PersistenceUnitReader {
 	/**
 	 * Parse the {@code class} XML elements.
 	 */
-	void parseManagedClasses(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) {
+	protected void parseManagedClasses(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) {
 		List<Element> classes = DomUtils.getChildElementsByTagName(persistenceUnit, MANAGED_CLASS_NAME);
 		for (Element element : classes) {
 			String value = DomUtils.getTextValue(element).trim();
@@ -278,7 +282,7 @@ final class PersistenceUnitReader {
 	/**
 	 * Parse the {@code mapping-file} XML elements.
 	 */
-	void parseMappingFiles(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) {
+	protected void parseMappingFiles(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) {
 		List<Element> files = DomUtils.getChildElementsByTagName(persistenceUnit, MAPPING_FILE_NAME);
 		for (Element element : files) {
 			String value = DomUtils.getTextValue(element).trim();
@@ -291,7 +295,7 @@ final class PersistenceUnitReader {
 	/**
 	 * Parse the {@code jar-file} XML elements.
 	 */
-	void parseJarFiles(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) throws IOException {
+	protected void parseJarFiles(Element persistenceUnit, SpringPersistenceUnitInfo unitInfo) throws IOException {
 		List<Element> jars = DomUtils.getChildElementsByTagName(persistenceUnit, JAR_FILE_URL);
 		for (Element element : jars) {
 			String value = DomUtils.getTextValue(element).trim();

spring-web/src/main/java/org/springframework/http/ETag.java

@@ -1,161 +0,0 @@
-/*
- * Copyright 2002-2024 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.http;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-
-import org.springframework.util.StringUtils;
-
-/**
- * Represents an ETag for HTTP conditional requests.
- *
- * @author Rossen Stoyanchev
- * @since 5.3.38
- * @see <a href="https://datatracker.ietf.org/doc/html/rfc7232">RFC 7232</a>
- */
-public class ETag {
-
-	private static final Log logger = LogFactory.getLog(ETag.class);
-
-	private static final ETag WILDCARD = new ETag("*", false);
-
-
-	private final String tag;
-
-	private final boolean weak;
-
-
-	public ETag(String tag, boolean weak) {
-		this.tag = tag;
-		this.weak = weak;
-	}
-
-
-	public String tag() {
-		return this.tag;
-	}
-
-	public boolean weak() {
-		return this.weak;
-	}
-
-	/**
-	 * Whether this a wildcard tag matching to any entity tag value.
-	 */
-	public boolean isWildcard() {
-		return (this == WILDCARD);
-	}
-
-	/**
-	 * Return the fully formatted tag including "W/" prefix and quotes.
-	 */
-	public String formattedTag() {
-		if (this == WILDCARD) {
-			return "*";
-		}
-		return (this.weak ? "W/" : "") + "\"" + this.tag + "\"";
-	}
-
-	@Override
-	public String toString() {
-		return formattedTag();
-	}
-
-
-	/**
-	 * Parse entity tags from an "If-Match" or "If-None-Match" header.
-	 * @param source the source string to parse
-	 * @return the parsed ETags
-	 */
-	public static List<ETag> parse(String source) {
-
-		List<ETag> result = new ArrayList<>();
-		State state = State.BEFORE_QUOTES;
-		int startIndex = -1;
-		boolean weak = false;
-
-		for (int i = 0; i < source.length(); i++) {
-			char c = source.charAt(i);
-
-			if (state == State.IN_QUOTES) {
-				if (c == '"') {
-					String tag = source.substring(startIndex, i);
-					if (StringUtils.hasText(tag)) {
-						result.add(new ETag(tag, weak));
-					}
-					state = State.AFTER_QUOTES;
-					startIndex = -1;
-					weak = false;
-				}
-				continue;
-			}
-
-			if (Character.isWhitespace(c)) {
-				continue;
-			}
-
-			if (c == ',') {
-				state = State.BEFORE_QUOTES;
-				continue;
-			}
-
-			if (state == State.BEFORE_QUOTES) {
-				if (c == '*') {
-					result.add(WILDCARD);
-					state = State.AFTER_QUOTES;
-					continue;
-				}
-				if (c == '"') {
-					state = State.IN_QUOTES;
-					startIndex = i + 1;
-					continue;
-				}
-				if (c == 'W' && source.length() > i + 2) {
-					if (source.charAt(i + 1) == '/' && source.charAt(i + 2) == '"') {
-						state = State.IN_QUOTES;
-						i = i + 2;
-						startIndex = i + 1;
-						weak = true;
-						continue;
-					}
-				}
-			}
-
-			if (logger.isDebugEnabled()) {
-				logger.debug("Unexpected char at index " + i);
-			}
-		}
-
-		if (state != State.IN_QUOTES && logger.isDebugEnabled()) {
-			logger.debug("Expected closing '\"'");
-		}
-
-		return result;
-	}
-
-
-	private enum State {
-
-		BEFORE_QUOTES, IN_QUOTES, AFTER_QUOTES
-
-	}
-
-}

spring-web/src/main/java/org/springframework/http/HttpHeaders.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 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,6 +40,8 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.StringJoiner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 import org.springframework.lang.Nullable;
@@ -391,6 +393,12 @@ public class HttpHeaders implements MultiValueMap<String, String>, Serializable
 	 */
 	public static final HttpHeaders EMPTY = new ReadOnlyHttpHeaders(new LinkedMultiValueMap<>());
 
+	/**
+	 * Pattern matching ETag multiple field values in headers such as "If-Match", "If-None-Match".
+	 * @see <a href="https://tools.ietf.org/html/rfc7232#section-2.3">Section 2.3 of RFC 7232</a>
+	 */
+	private static final Pattern ETAG_HEADER_VALUE_PATTERN = Pattern.compile("\\*|\\s*((W\\/)?(\"[^\"]*\"))\\s*,?");
+
 	private static final DecimalFormatSymbols DECIMAL_FORMAT_SYMBOLS = new DecimalFormatSymbols(Locale.ENGLISH);
 
 	private static final ZoneId GMT = ZoneId.of("GMT");
@@ -1029,8 +1037,9 @@ public class HttpHeaders implements MultiValueMap<String, String>, Serializable
 	 */
 	public void setETag(@Nullable String etag) {
 		if (etag != null) {
-			Assert.isTrue(etag.startsWith("\"") || etag.startsWith("W/\""), "ETag does not start with W/\" or \"");
-			Assert.isTrue(etag.endsWith("\""), "ETag does not end with \"");
+			Assert.isTrue(etag.startsWith("\"") || etag.startsWith("W/"),
+					"Invalid ETag: does not start with W/ or \"");
+			Assert.isTrue(etag.endsWith("\""), "Invalid ETag: does not end with \"");
 			set(ETAG, etag);
 		}
 		else {
@@ -1560,27 +1569,35 @@ public class HttpHeaders implements MultiValueMap<String, String>, Serializable
 
 	/**
 	 * Retrieve a combined result from the field values of the ETag header.
-	 * @param name the header name
+	 * @param headerName the header name
 	 * @return the combined result
 	 * @throws IllegalArgumentException if parsing fails
 	 * @since 4.3
 	 */
-	protected List<String> getETagValuesAsList(String name) {
-		List<String> values = get(name);
-		if (values == null) {
-			return Collections.emptyList();
-		}
-		List<String> result = new ArrayList<>();
-		for (String value : values) {
-			if (value != null) {
-				List<ETag> tags = ETag.parse(value);
-				Assert.notEmpty(tags, "Could not parse header '" + name + "' with value '" + value + "'");
-				for (ETag tag : tags) {
-					result.add(tag.formattedTag());
+	protected List<String> getETagValuesAsList(String headerName) {
+		List<String> values = get(headerName);
+		if (values != null) {
+			List<String> result = new ArrayList<>();
+			for (String value : values) {
+				if (value != null) {
+					Matcher matcher = ETAG_HEADER_VALUE_PATTERN.matcher(value);
+					while (matcher.find()) {
+						if ("*".equals(matcher.group())) {
+							result.add(matcher.group());
+						}
+						else {
+							result.add(matcher.group(1));
+						}
+					}
+					if (result.isEmpty()) {
+						throw new IllegalArgumentException(
+								"Could not parse header '" + headerName + "' with value '" + value + "'");
+					}
 				}
 			}
+			return result;
 		}
-		return result;
+		return Collections.emptyList();
 	}
 
 	/**

spring-web/src/main/java/org/springframework/http/converter/xml/SourceHttpMessageConverter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -93,7 +93,7 @@ public class SourceHttpMessageConverter<T extends Source> extends AbstractHttpMe
 
 	/**
 	 * Sets the {@link #setSupportedMediaTypes(java.util.List) supportedMediaTypes}
-	 * to {@code text/xml} and {@code application/xml}, and {@code application/*+xml}.
+	 * to {@code text/xml} and {@code application/xml}, and {@code application/*-xml}.
 	 */
 	public SourceHttpMessageConverter() {
 		super(MediaType.APPLICATION_XML, MediaType.TEXT_XML, new MediaType("application", "*+xml"));

spring-web/src/main/java/org/springframework/web/context/request/ServletWebRequest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -26,12 +26,13 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.TimeZone;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 
-import org.springframework.http.ETag;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
@@ -53,6 +54,12 @@ public class ServletWebRequest extends ServletRequestAttributes implements Nativ
 
 	private static final List<String> SAFE_METHODS = Arrays.asList("GET", "HEAD");
 
+	/**
+	 * Pattern matching ETag multiple field values in headers such as "If-Match", "If-None-Match".
+	 * @see <a href="https://tools.ietf.org/html/rfc7232#section-2.3">Section 2.3 of RFC 7232</a>
+	 */
+	private static final Pattern ETAG_HEADER_VALUE_PATTERN = Pattern.compile("\\*|\\s*((W\\/)?(\"[^\"]*\"))\\s*,?");
+
 	/**
 	 * Date formats as specified in the HTTP RFC.
 	 * @see <a href="https://tools.ietf.org/html/rfc7231#section-7.1.1.1">Section 7.1.1.1 of RFC 7231</a>
@@ -282,10 +289,11 @@ public class ServletWebRequest extends ServletRequestAttributes implements Nativ
 			etag = etag.substring(2);
 		}
 		while (ifNoneMatch.hasMoreElements()) {
+			String clientETags = ifNoneMatch.nextElement();
+			Matcher etagMatcher = ETAG_HEADER_VALUE_PATTERN.matcher(clientETags);
 			// Compare weak/strong ETags as per https://tools.ietf.org/html/rfc7232#section-2.3
-			for (ETag requestedETag : ETag.parse(ifNoneMatch.nextElement())) {
-				String tag = requestedETag.tag();
-				if (StringUtils.hasLength(tag) && etag.equals(padEtagIfNecessary(tag))) {
+			while (etagMatcher.find()) {
+				if (StringUtils.hasLength(etagMatcher.group()) && etag.equals(etagMatcher.group(3))) {
 					this.notModified = true;
 					break;
 				}

spring-web/src/test/java/org/springframework/http/HttpHeadersTests.java

@@ -192,17 +192,11 @@ public class HttpHeadersTests {
 	}
 
 	@Test
-	void illegalETagWithoutQuotes() {
+	void illegalETag() {
 		String eTag = "v2.6";
 		assertThatIllegalArgumentException().isThrownBy(() -> headers.setETag(eTag));
 	}
 
-	@Test
-	void illegalWeakETagWithoutLeadingQuote() {
-		String etag = "W/v2.6\"";
-		assertThatIllegalArgumentException().isThrownBy(() -> headers.setETag(etag));
-	}
-
 	@Test
 	void ifMatch() {
 		String ifMatch = "\"v2.6\"";

src/docs/asciidoc/core/core-beans.adoc

@@ -4547,7 +4547,7 @@ dataSource.url=jdbc:mysql:mydb
 ----
 
 This example file can be used with a container definition that contains a bean called
-`dataSource` that has `driverClassName` and `url` properties.
+`dataSource` that has `driver` and `url` properties.
 
 Compound property names are also supported, as long as every component of the path
 except the final property being overridden is already non-null (presumably initialized

src/docs/asciidoc/integration.adoc

@@ -2396,7 +2396,7 @@ your `@Configuration` classes, as the following example shows:
 By default, the infrastructure looks for a bean named `jmsListenerContainerFactory`
 as the source for the factory to use to create message listener containers. In this
 case (and ignoring the JMS infrastructure setup), you can invoke the `processOrder`
-method with a core pool size of three threads and a maximum pool size of ten threads.
+method with a core poll size of three threads and a maximum pool size of ten threads.
 
 You can customize the listener container factory to use for each annotation or you can
 configure an explicit default by implementing the `JmsListenerConfigurer` interface.