tree 84c28c54bb64ae535be9180588e5867a79ae6347
parent fea78528304bc48083fb500c106219f2e5181316
parent 711978a0450ef5080b9b30a9a4243f626d0a35c2
author Moritz <mosum@google.com> 1734702686 +0100
committer GitHub <noreply@github.com> 1734702686 +0100
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJnZXZeCRC1aQ7uu5UhlAAAEnwQAH7JiLNLLdzIpc9iTXuaEy5u
 nOcEGzCCEz5J4janC3eoe8TwmFFxM8VKfAPufaDpvoRv3qq7NBuAQQdDpgf+YpRa
 4o0AO3KCNA+xTQM9ebM6eIa2VGh8T2mGnTkBsi4Li2gymcii9eLCRvz+3ob8929e
 xya70GEWGp9CZSLoPUYcRnjstGNTsFnPzCl98r/FSgGgeiKS2V1TU8RB54f3hHen
 j4IcJHNn42S+G/xVgd7spl24AlKIX0mhwN8+J13DBKpDCc5Obhyz4CLJvgJS2xbQ
 9EndlMGmLSnyvsRVoSk/3+Sx/WIAx1g0mESy5AkCTUaggMXPP6st3ltjfGebiB8+
 PI3yS9S/e+kmL4wQXhJd7+1Xrx35rxmMcy3SCLutjxF5L6Od7yEdSOUPE9uSI2ol
 cCw8ff7MkKOyP37zuzmxrlK2xLh3ZXY7JXAeEo5iL+1C8JBvmZ2KrJPZPafgwyft
 gtsr9KGkbkQF7HUaRKVfMOt5vhPTQgwHHQLNb3m9hZuYp+6MECP5tbbqHFMh88RN
 neIr9WAsCEjSebENSIp2/8G74dAuutIstiliexEnAxrNUPrc7+9yaVv0zbMFCGyY
 yAd7KM0ytnVdi0w9q94MKYHq2kA4OEBWd6EpWe4n3+KX6O7LCgN0Q8xAmpjijQLO
 xdj/M3unA+Wkhub+uZTL
 =g1yU
 -----END PGP SIGNATURE-----
 

Merge `package:test_descriptor` (#2424)

- [x] Move and fix workflow files, labeler.yaml, and badges in the
README.md
- [x] Rev the version of the package, so that pub.dev points to the
correct site
- [x] Add a line to the changelog:
```
* Move to `dart-lang/test` monorepo.
```

- [x] Add the package to the top-level readme of the monorepo:
```
| [test_descriptor](pkgs/test_descriptor/) | An API for defining and verifying files and directory structures. | [![package issues](https://img.shields.io/badge/package:test_descriptor-4774bc)](https://github.com/dart-lang/tools/issues?q=is%3Aissue+is%3Aopen+label%3Apackage%3Atest_descriptor) | [![pub package](https://img.shields.io/pub/v/test_descriptor.svg)](https://pub.dev/packages/test_descriptor) |
```

- [ ] **Important!** Merge the PR with 'Create a merge commit' (enabling
then disabling the `Allow merge commits` admin setting)
- [x] Update the auto-publishing settings on
https://pub.dev/packages/test_descriptor/admin
- [x] Add the following text to
https://github.com/dart-lang/test_descriptor/:'

```
> [!IMPORTANT]  
> This repo has moved to https://github.com/dart-lang/test/tree/master/pkgs/test_descriptor
```

- [ ] Publish using the autopublish workflow
- [x] Push tags to GitHub using
```
git tag --list 'test_descriptor*' | xargs git push origin
```

- [x] Close open PRs in dart-lang/test_descriptor with the following
message:

```
Closing as the [dart-lang/test_descriptor](https://github.com/dart-lang/test_descriptor) repository is merged into the [dart-lang/test](https://github.com/dart-lang/test) monorepo. Please re-open this PR there!
```
      
- [x] Transfer issues by running
```
dart run pkgs/repo_manage/bin/report.dart transfer-issues --source-repo dart-lang/test_descriptor --target-repo dart-lang/test --add-label package:test_descriptor --apply-changes
```

- [ ] Archive https://github.com/dart-lang/test_descriptor/


---

- [x] I’ve reviewed the contributor guide and applied the relevant
portions to this PR.

<details>
  <summary>Contribution guidelines:</summary><br>

- See our [contributor
guide](https://github.com/dart-lang/.github/blob/main/CONTRIBUTING.md)
for general expectations for PRs.
- Larger or significant changes should be discussed in an issue before
creating a PR.
- Contributions to our repos should follow the [Dart style
guide](https://dart.dev/guides/language/effective-dart) and use `dart
format`.
- Most changes should add an entry to the changelog and may need to [rev
the pubspec package
version](https://github.com/dart-lang/sdk/blob/main/docs/External-Package-Maintenance.md#making-a-change).
- Changes to packages require [corresponding
tests](https://github.com/dart-lang/.github/blob/main/CONTRIBUTING.md#Testing).

Note that many Dart repos have a weekly cadence for reviewing PRs -
please allow for some latency before initial review feedback.
</details>