tree 15d679ef9c2dd90ba4d45572517a4f6b53c7b205
parent fd6223fb43e1c5e56362c3d5bf2a467dbbd879ea
parent d6e9dae3fd9dd9db1d421b86815330e8bda171d9
author Matthias Benkard <code@mulk.eu> 1673372788 +0000
committer Matthias Benkard <code@mulk.eu> 1673372788 +0000

Update junit5 monorepo to v5.9.2 (mulk/jgvariant!20)

This MR contains the following updates:

| Package | Type | Update | Change |
|---|---|---|---|
| [org.junit.jupiter:junit-jupiter-api](https://junit.org/junit5/) ([source](https://github.com/junit-team/junit5)) | test | patch | `5.9.1` -> `5.9.2` |
| [org.junit.jupiter:junit-jupiter-engine](https://junit.org/junit5/) ([source](https://github.com/junit-team/junit5)) | test | patch | `5.9.1` -> `5.9.2` |

---

### Configuration

📅 **Schedule**: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you are satisfied.

♻ **Rebasing**: Whenever MR is behind base branch, or you tick the rebase/retry checkbox.

🔕 **Ignore**: Close this MR and you won't be reminded about these updates again.

---

 - [ ] <!-- rebase-check -->If you want to rebase/retry this MR, check this box

---

This MR has been generated by [Renovate Bot](https://github.com/renovatebot/renovate).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzNC4yNC4wIiwidXBkYXRlZEluVmVyIjoiMzQuMjQuMCJ9-->