From a2fd167d474394a5f35ea05866718c96bcebd03b Mon Sep 17 00:00:00 2001 From: Rain Date: Sun, 8 Dec 2024 22:52:25 +0000 Subject: [PATCH] [fixtures] remove uuid vendor, replace with cargo fetch setup script We need to pull in some more crates, and vendoring everything is annoying. We would like to do one fetch in the beginning of the test run, though, and this is an ideal place to use (and dogfood) a setup script. --- .config/nextest.toml | 11 + fixtures/nextest-tests/.cargo/config | 6 - .../vendor/uuid/.cargo-checksum.json | 1 - .../vendor/uuid/CODE_OF_CONDUCT.md | 78 - .../nextest-tests/vendor/uuid/CONTRIBUTING.md | 140 -- fixtures/nextest-tests/vendor/uuid/COPYRIGHT | 8 - fixtures/nextest-tests/vendor/uuid/Cargo.lock | 616 ------- fixtures/nextest-tests/vendor/uuid/Cargo.toml | 194 --- .../nextest-tests/vendor/uuid/LICENSE-APACHE | 201 --- .../nextest-tests/vendor/uuid/LICENSE-MIT | 26 - fixtures/nextest-tests/vendor/uuid/README.md | 99 -- .../vendor/uuid/benches/format_str.rs | 66 - .../vendor/uuid/benches/parse_str.rs | 50 - .../nextest-tests/vendor/uuid/benches/v4.rs | 11 - .../vendor/uuid/examples/random_uuid.rs | 15 - .../vendor/uuid/examples/sortable_uuid.rs | 15 - .../vendor/uuid/examples/uuid_macro.rs | 19 - .../vendor/uuid/examples/windows_guid.rs | 112 -- .../nextest-tests/vendor/uuid/src/builder.rs | 905 ---------- .../nextest-tests/vendor/uuid/src/error.rs | 172 -- .../nextest-tests/vendor/uuid/src/external.rs | 6 - .../uuid/src/external/arbitrary_support.rs | 41 - .../vendor/uuid/src/external/serde_support.rs | 313 ---- .../vendor/uuid/src/external/slog_support.rs | 37 - fixtures/nextest-tests/vendor/uuid/src/fmt.rs | 1038 ----------- fixtures/nextest-tests/vendor/uuid/src/lib.rs | 1549 ----------------- .../nextest-tests/vendor/uuid/src/macros.rs | 99 -- fixtures/nextest-tests/vendor/uuid/src/md5.rs | 14 - .../nextest-tests/vendor/uuid/src/parser.rs | 521 ------ fixtures/nextest-tests/vendor/uuid/src/rng.rs | 39 - .../nextest-tests/vendor/uuid/src/sha1.rs | 14 - .../vendor/uuid/src/timestamp.rs | 409 ----- fixtures/nextest-tests/vendor/uuid/src/v1.rs | 175 -- fixtures/nextest-tests/vendor/uuid/src/v3.rs | 151 -- fixtures/nextest-tests/vendor/uuid/src/v4.rs | 63 - fixtures/nextest-tests/vendor/uuid/src/v5.rs | 162 -- fixtures/nextest-tests/vendor/uuid/src/v6.rs | 177 -- fixtures/nextest-tests/vendor/uuid/src/v7.rs | 124 -- fixtures/nextest-tests/vendor/uuid/src/v8.rs | 57 - .../nextest-tests/vendor/uuid/tests/macros.rs | 11 - .../tests/ui/compile_fail/invalid_parse.rs | 45 - .../ui/compile_fail/invalid_parse.stderr | 197 --- .../uuid/tests/ui/compile_pass/renamed.rs | 11 - .../uuid/tests/ui/compile_pass/valid.rs | 20 - 44 files changed, 11 insertions(+), 8007 deletions(-) delete mode 100644 fixtures/nextest-tests/vendor/uuid/.cargo-checksum.json delete mode 100644 fixtures/nextest-tests/vendor/uuid/CODE_OF_CONDUCT.md delete mode 100644 fixtures/nextest-tests/vendor/uuid/CONTRIBUTING.md delete mode 100644 fixtures/nextest-tests/vendor/uuid/COPYRIGHT delete mode 100644 fixtures/nextest-tests/vendor/uuid/Cargo.lock delete mode 100644 fixtures/nextest-tests/vendor/uuid/Cargo.toml delete mode 100644 fixtures/nextest-tests/vendor/uuid/LICENSE-APACHE delete mode 100644 fixtures/nextest-tests/vendor/uuid/LICENSE-MIT delete mode 100644 fixtures/nextest-tests/vendor/uuid/README.md delete mode 100644 fixtures/nextest-tests/vendor/uuid/benches/format_str.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/benches/parse_str.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/benches/v4.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/examples/random_uuid.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/examples/sortable_uuid.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/examples/uuid_macro.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/examples/windows_guid.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/builder.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/error.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/external.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/external/arbitrary_support.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/external/serde_support.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/external/slog_support.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/fmt.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/lib.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/macros.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/md5.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/parser.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/rng.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/sha1.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/timestamp.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/v1.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/v3.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/v4.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/v5.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/v6.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/v7.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/src/v8.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/tests/macros.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/tests/ui/compile_fail/invalid_parse.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/tests/ui/compile_fail/invalid_parse.stderr delete mode 100644 fixtures/nextest-tests/vendor/uuid/tests/ui/compile_pass/renamed.rs delete mode 100644 fixtures/nextest-tests/vendor/uuid/tests/ui/compile_pass/valid.rs diff --git a/.config/nextest.toml b/.config/nextest.toml index 576d32a6277..281b696168a 100644 --- a/.config/nextest.toml +++ b/.config/nextest.toml @@ -1,3 +1,5 @@ +experimental = ["setup-scripts"] + [profile.default] final-status-level = "slow" @@ -10,6 +12,10 @@ slow-timeout = { period = "60s", terminate-after = 3 } test-group = "my-group" junit.store-success-output = true +[[profile.default.scripts]] +filter = 'package(integration-tests) or binary_id(nextest-runner::integration)' +setup = "cargo-fetch-fixture" + [profile.ci] # Don't fail fast in CI to run the full test suite. fail-fast = false @@ -50,3 +56,8 @@ max-threads = 8 [test-groups.unused-group] max-threads = 8 + +[script.cargo-fetch-fixture] +command = "cargo fetch --manifest-path fixtures/nextest-tests/Cargo.toml" +capture-stdout = true +capture-stderr = true diff --git a/fixtures/nextest-tests/.cargo/config b/fixtures/nextest-tests/.cargo/config index e488659dd31..ec83437d292 100644 --- a/fixtures/nextest-tests/.cargo/config +++ b/fixtures/nextest-tests/.cargo/config @@ -7,12 +7,6 @@ runner = "android-runner -x" [target.'cfg(all(target_arch = "x86_64", target_os = "linux", target_env = "musl"))'] runner = ["passthrough", "--ensure-this-arg-is-sent"] -[source.crates-io] -replace-with = "vendored-sources" - -[source.vendored-sources] -directory = "vendor" - [env] CONFIG_WORKSPACE_DIR = { value = "", relative = true } diff --git a/fixtures/nextest-tests/vendor/uuid/.cargo-checksum.json b/fixtures/nextest-tests/vendor/uuid/.cargo-checksum.json deleted file mode 100644 index 9f2b3910f6e..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{"CODE_OF_CONDUCT.md":"b360d72c37ca9eee599c13d4f7f4b95707c6414634e67befc6a63c1d430d299c","CONTRIBUTING.md":"be72ea4c22c397964f6f44b10562c4ad485dc1cc24b3dcca951e49907439d9ac","COPYRIGHT":"b4b2c0de2a05de3372d5c828128413ce82bb7dba2272487b7729f09cc3d3519d","Cargo.lock":"e25ce18dff59f15a04b2d0a287932be55dbf7b442fb89a5d7aa8af4c6297d408","Cargo.toml":"289ea2434dbce761286fa95be642d17d42c446281ddb99eed2992acef91997da","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"436bc5a105d8e57dcd8778730f3754f7bf39c14d2f530e4cde4bd2d17a83ec3d","README.md":"bed2d3bead9621da11987b46a641cd2f55125392e2cdce0f7d3e2a817c03c304","benches/format_str.rs":"f1320973392ce1cd0f0988747c6b4253d3b4ce34cf742dd558efad86f88a81e5","benches/parse_str.rs":"4e9e2f881c609ccdce502a6490e6b5f06cd8954e44f8a1b98d6c0e22f53a15d5","benches/v4.rs":"f59d7180882e12cb09761d941d7bece9690a97f7f29181e2692b38012b6363d7","examples/random_uuid.rs":"9f2282adaa253c803ca58b1ce1c50eb61aaf904a47aec10b777963a6f5ecf9ff","examples/sortable_uuid.rs":"bff06efa3bf3ced72dd4b27d470417bba4887f5110d79cda52688329aa922cea","examples/uuid_macro.rs":"75178c9756da545f94e31f9d322e9a97d8f76a08326f26f2d014088cb42e4ebf","examples/windows_guid.rs":"2e2a21779aec9772a7f0c9ec475b5dc44835640cb104352134986e809f0f7f59","src/builder.rs":"3b3626a94686e8d9a6ffaf2ecfcc3a8710ca93af93f73fba892286744364e919","src/error.rs":"84a66ccb850ec00400f7b07d6713f35b7b871f42d5fc2bc5e9888e458d8369d8","src/external.rs":"9843b6893a7f07591abbbf8588da36f241563fe71e5e445fa500fdd7b65791e3","src/external/arbitrary_support.rs":"0cb7df4e7104672134118030ffed2ec87bcc566dba5b091a8df5127639696f04","src/external/serde_support.rs":"97e7a39e322d7a7172c0a5bac1918aa3e2624a0ba253a75cd083f3fa940980df","src/external/slog_support.rs":"53c6251e424bdc9b6ba35defb4c723d4d34d44053badbf98e1c7c3e7c83fbb5e","src/fmt.rs":"2ebcaa8c6f7ff13203de54ee1afda0fcc022c765fa1656c23ec50b92a4ea9976","src/lib.rs":"d91de38716a7abca299527b92a267497e1dec1f606c6e8f6cc2b8c30b45e6bbe","src/macros.rs":"52d5d98ea7807f06507588964233a500145b918f1d1c9cda9135e8ecae629709","src/md5.rs":"227a753edc428499108e6f25074bbeb6a80d55f52e18c717a1d88831ae77066a","src/parser.rs":"06c4bfdd6b74db9469a516f7015d328b1f1bd2750f609423c47e308bf98e8706","src/rng.rs":"b9f69610560aa5b5d9b2eaa16fb2239515bd163da126cf5c392e5fb9b0296c3e","src/sha1.rs":"e1a9657e11f1ed1ede33c0655f9c2641059b7c24f17be4ac425c930cc216e019","src/timestamp.rs":"31e4338f6695e2f1e736ba6d958a7ef6200d15e6a58c4229d8b0ca99691900a6","src/v1.rs":"784f8bee32039de761444ef0ed9e70035f8ff7d16beea3ab39bd7b30e0104fea","src/v3.rs":"d797bac7ba71c489a67cb6d0dbd23931fc151fd51994272215edf768ae9b54d2","src/v4.rs":"76d2e5cdc4935f06c6f3b9a34076a6795129698f6887556c4dbe4753dbef56ce","src/v5.rs":"76e4cbb4695ae7904334e089cb549e7c4382ea74045d437d0b4231ce4a64b17d","src/v6.rs":"38717015364f85aad712b27d1ce91ed9f4c9968957424233dad8ceef7ea221f3","src/v7.rs":"86a2db956f6e2d38d20bcc2b64b2f5dc512471717dfedbd21f9c7b07d065a9c0","src/v8.rs":"21a6e05bcfc1fd835df416d40e6403eef951f79abc36c170e4e767fbd197c43f","tests/macros.rs":"5dc3b4a3f0fdcedb47f680f0534d4074bab3a4b26257d8a4f89e9eaad3e6bca7","tests/ui/compile_fail/invalid_parse.rs":"eb81a6a1be99bcce58afa15e2cacab3e7d64f628d3eb31897d2a13feffb2032f","tests/ui/compile_fail/invalid_parse.stderr":"a0d2f080cf64a965028b2044f775d4f75fc541f560ec75baf783231590cd429e","tests/ui/compile_pass/renamed.rs":"f2bd73151e605035051d3aaf572133861457e6d199d0ff7ede748fc6c0f44c7b","tests/ui/compile_pass/valid.rs":"a0cfeeae38dc78151ecc21ad801e56d61993a7e393e0943a6b06f2811e004135"},"package":"feb41e78f93363bb2df8b0e86a2ca30eed7806ea16ea0c790d757cf93f79be83"} \ No newline at end of file diff --git a/fixtures/nextest-tests/vendor/uuid/CODE_OF_CONDUCT.md b/fixtures/nextest-tests/vendor/uuid/CODE_OF_CONDUCT.md deleted file mode 100644 index 43ff03c15ff..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/CODE_OF_CONDUCT.md +++ /dev/null @@ -1,78 +0,0 @@ -# Contributor Covenant Code of Conduct - -The latest version of the CODE OF CONDUCT can be found [here]. - -[here]: https://github.com/uuid-rs/conduct - -## Our Pledge - -In the interest of fostering an open and welcoming environment, we as -contributors and maintainers pledge to making participation in our project and -our community a harassment-free experience for everyone, regardless of age, body -size, disability, ethnicity, gender identity and expression, level of experience, -education, socio-economic status, nationality, personal appearance, race, -religion, or sexual identity and orientation. - -## Our Standards - -Examples of behavior that contributes to creating a positive environment -include: - -* Using welcoming and inclusive language -* Being respectful of differing viewpoints and experiences -* Gracefully accepting constructive criticism -* Focusing on what is best for the community -* Showing empathy towards other community members - -Examples of unacceptable behavior by participants include: - -* The use of sexualized language or imagery and unwelcome sexual attention or - advances -* Trolling, insulting/derogatory comments, and personal or political attacks -* Public or private harassment -* Publishing others' private information, such as a physical or electronic - address, without explicit permission -* Other conduct which could reasonably be considered inappropriate in a - professional setting - -## Our Responsibilities - -Project maintainers are responsible for clarifying the standards of acceptable -behavior and are expected to take appropriate and fair corrective action in -response to any instances of unacceptable behavior. - -Project maintainers have the right and responsibility to remove, edit, or -reject comments, commits, code, wiki edits, issues, and other contributions -that are not aligned to this Code of Conduct, or to ban temporarily or -permanently any contributor for other behaviors that they deem inappropriate, -threatening, offensive, or harmful. - -## Scope - -This Code of Conduct applies both within project spaces and in public spaces -when an individual is representing the project or its community. Examples of -representing a project or community include using an official project e-mail -address, posting via an official social media account, or acting as an appointed -representative at an online or offline event. Representation of a project may be -further defined and clarified by project maintainers. - -## Enforcement - -Instances of abusive, harassing, or otherwise unacceptable behavior may be -reported by contacting one of the project maintainers through details available -on their GitHub profile. All complaints will be reviewed and investigated and will -result in a response that is deemed necessary and appropriate to the circumstances. -The project team is obligated to maintain confidentiality with regard to the -reporter of an incident. Further details of specific enforcement policies may -be posted separately. - -Project maintainers who do not follow or enforce the Code of Conduct in good -faith may face temporary or permanent repercussions as determined by other -members of the project's leadership. - -## Attribution - -This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, -available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html - -[homepage]: https://www.contributor-covenant.org diff --git a/fixtures/nextest-tests/vendor/uuid/CONTRIBUTING.md b/fixtures/nextest-tests/vendor/uuid/CONTRIBUTING.md deleted file mode 100644 index 1025171af8f..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/CONTRIBUTING.md +++ /dev/null @@ -1,140 +0,0 @@ -Contributing to Uuid ---- -[Contributing to Uuid]: #contributing-to-uuid - -Thank you for your interest in contributing to the Uuid Project! - -* [Feature Requests](#feature-requests) -* [Bug Reports](#bug-reports) -* [Pull Requests](#pull-requests) -* [Writing Documentation](#writing-documentation) -* [Issue Triage](#issue-triage) -* [Out-of-tree Contributions](#out-of-tree-contributions) -* [Helpful Links](#helpful-links) - -For any questions, please make a post on [Discussions] or [users.rust-lang.org][u-r-l-o]. - -> All contributors need to follow our [Code of Conduct]. - -[Code of Conduct]: CODE_OF_CONDUCT.md - -# Feature Requests -[Feature Requests]: #feature-requests - -The `uuid` crate is stable so features that require breaking changes can't be -accepted. There are bound to be usability gaps that can be filled with non-breaking -features though! - -If you have the chance, please [search existing issues], as there is a chance -that someone has already requested your feature. - -File your feature request with a descriptive title, as this helps others find -your request. - -You can request your feature by following [this link][Feature Request Link] and -filling it in. - -> We welcome pull requests for your own feature requests. Discussion should stay -on the relevant issue to make it easier to find. - -## Adding new unstable dependencies - -If a feature introduces a new unstable dependency then it needs to be private. -That means traits and types from the unstable library can't be visible in `uuid`'s -own public API. - -To implement unstable traits, see the precedent set by the `zerocopy-unstable` feature. -It implements a public unstable trait on `Uuid`, but uses the `uuid_unstable` cfg flag. - -[Feature Request Link]: https://github.com/uuid-rs/uuid/issues/new?template=Feature_request.md - -# Bug Reports -[Bug Reports]: #bug-reports - -While no one likes bugs, they are an unfortunate reality in software. Remember -we can't fix bugs we don't know about, so don't be shy about reporting. - -If you have the chance, please [search existing issues], as there is a chance -that someone has already reported your error. This isn't strictly needed, as -sometimes you might not what exactly you are looking for. - -File your issue with a descriptive title, as this helps others find your issue. - -Reporting a bug is as easy as following [this link][Bug Report Link] and -filling it in. - -Sometimes a backtrace may be needed. In that case, set `RUST_BACKTRACE` -environment variable to `1`. For example: - -```bash -$ RUST_BACKTRACE=1 cargo build -``` - -> We welcome pull requests for your own bug reports, provided they have been -discussed. - -[Bug Report Link]: https://github.com/uuid-rs/uuid/issues/new?template=Bug_report.md - -# Pull Requests -[Pull Requests]: #pull-requests - -Pull requests(PRs) are the primary mechanism we use to change Uuid. GitHub itself -has some [great documentation] on using the Pull Request feature. We use the -"fork and pull" model described [here][fnp], where contributors push changes to -their personal fork and create pull requests to bring those changes into the -source repository. - -Unless the changes are fairly minor (like documentation changes or tiny -patches), we require PRs to relevant issues. - -Please open PRs against the `main` branch. - -When you feel that the PR is ready, please ping one of the maintainers so -they can review your changes. - -[great documentation]: https://help.github.com/articles/about-pull-requests/ -[fnp]: https://help.github.com/articles/about-collaborative-development-models/ - -# Writing Documentation -[Writing Documentation]: #writing-documentation - -Documentation is an important part of Uuid. Lackluster or incorrect -documentation can cause headaches for the users of `uuid`. Therefore, -improvements to documentation are always welcome. - -We follow the documentation style guidelines as given by [RFC 1574]. - -[RFC 1574]: https://github.com/rust-lang/rfcs/blob/main/text/1574-more-api-documentation-conventions.md#appendix-a-full-conventions-text - -# Issue Triage -[Issue Triage]: #issue-triage - -Sometimes, an issue might stay open even after the relevant bug has been fixed. -Other times, the bug report may become invalid. Or we may just forget about the -bug. - -You can help to go through old bug reports and check if they are still valid. -You can follow [this link][lrus] to look for issues like this. - -[lrus]: https://github.com/uuid-rs/uuid/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc - -# Fuzzing -We use [`cargo fuzz`] to fuzz test various parts of `uuid`. See their guide -for more details on what fuzzing is and how to run the tests yourself. - -# Helpful Links -[Helpful Links]: #helpful-links - -For people new to Uuid, and just starting to contribute, or even for more -seasoned developers, some useful places to look for information are: - -* The Wikipedia entry on [Universally Unique Identifier][wiki-uuid]. -* [RFC 4122] which gives the specification of Uuids. - -[wiki-uuid]: https://en.wikipedia.org/wiki/Universally_unique_identifier -[RFC 4122]: https://www.ietf.org/rfc/rfc4122.txt - -[u-r-l-o]: https://users.rust-lang.org -[Discussions]: https://github.com/uuid-rs/uuid/discussions -[search existing issues]: https://github.com/uuid-rs/uuid/search?q=&type=Issues&utf8=%E2%9C%93 -[`cargo fuzz`]: https://rust-fuzz.github.io/book/cargo-fuzz.html diff --git a/fixtures/nextest-tests/vendor/uuid/COPYRIGHT b/fixtures/nextest-tests/vendor/uuid/COPYRIGHT deleted file mode 100644 index 925929c167c..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/COPYRIGHT +++ /dev/null @@ -1,8 +0,0 @@ -The Uuid Project is copyright 2013-2014, The Rust Project Developers and -copyright 2018, The Uuid Developers. - -Licensed under the Apache License, Version 2.0 or the MIT License , at your option. All files in the project -carrying such notice may not be copied, modified, or distributed except -according to those terms. diff --git a/fixtures/nextest-tests/vendor/uuid/Cargo.lock b/fixtures/nextest-tests/vendor/uuid/Cargo.lock deleted file mode 100644 index aa5c86542d6..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/Cargo.lock +++ /dev/null @@ -1,616 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "arbitrary" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a7924531f38b1970ff630f03eb20a2fde69db5c590c93b0f3482e95dcc5fd60" - -[[package]] -name = "atomic" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b88d82667eca772c4aa12f0f1348b3ae643424c8876448f3f7bd5787032e234c" -dependencies = [ - "autocfg", -] - -[[package]] -name = "autocfg" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" - -[[package]] -name = "bincode" -version = "1.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" -dependencies = [ - "serde", -] - -[[package]] -name = "block-buffer" -version = "0.10.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e" -dependencies = [ - "generic-array", -] - -[[package]] -name = "bumpalo" -version = "3.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1ad822118d20d2c234f427000d5acc36eabe1e29a348c89b63dd60b13f28e5d" - -[[package]] -name = "byteorder" -version = "1.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "console_error_panic_hook" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" -dependencies = [ - "cfg-if", - "wasm-bindgen", -] - -[[package]] -name = "crypto-common" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" -dependencies = [ - "generic-array", - "typenum", -] - -[[package]] -name = "digest" -version = "0.10.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c" -dependencies = [ - "block-buffer", - "crypto-common", -] - -[[package]] -name = "generic-array" -version = "0.14.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9" -dependencies = [ - "typenum", - "version_check", -] - -[[package]] -name = "getrandom" -version = "0.2.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6" -dependencies = [ - "cfg-if", - "js-sys", - "libc", - "wasi", - "wasm-bindgen", -] - -[[package]] -name = "glob" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" - -[[package]] -name = "itoa" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc" - -[[package]] -name = "js-sys" -version = "0.3.60" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47" -dependencies = [ - "wasm-bindgen", -] - -[[package]] -name = "libc" -version = "0.2.134" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "329c933548736bc49fd575ee68c89e8be4d260064184389a5b77517cddd99ffb" - -[[package]] -name = "log" -version = "0.4.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "md-5" -version = "0.10.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6365506850d44bff6e2fbcb5176cf63650e48bd45ef2fe2665ae1570e0f4b9ca" -dependencies = [ - "digest", -] - -[[package]] -name = "once_cell" -version = "1.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1" - -[[package]] -name = "ppv-lite86" -version = "0.2.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872" - -[[package]] -name = "proc-macro2" -version = "1.0.46" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94e2ef8dbfc347b10c094890f778ee2e36ca9bb4262e86dc99cd217e35f3470b" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quote" -version = "1.0.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "rand" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" -dependencies = [ - "libc", - "rand_chacha", - "rand_core", -] - -[[package]] -name = "rand_chacha" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" -dependencies = [ - "ppv-lite86", - "rand_core", -] - -[[package]] -name = "rand_core" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" -dependencies = [ - "getrandom", -] - -[[package]] -name = "rustversion" -version = "1.0.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8" - -[[package]] -name = "ryu" -version = "1.0.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09" - -[[package]] -name = "scoped-tls" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2" - -[[package]] -name = "serde" -version = "1.0.145" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "728eb6351430bccb993660dfffc5a72f91ccc1295abaa8ce19b27ebe4f75568b" - -[[package]] -name = "serde_derive" -version = "1.0.145" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81fa1584d3d1bcacd84c277a0dfe21f5b0f6accf4a23d04d4c6d61f1af522b4c" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "serde_json" -version = "1.0.85" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e55a28e3aaef9d5ce0506d0a14dbba8054ddc7e499ef522dd8b26859ec9d4a44" -dependencies = [ - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "serde_test" -version = "1.0.145" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c17d2112159132660b4c5399e274f676fb75a2f8d70b7468f18f045b71138ed" -dependencies = [ - "serde", -] - -[[package]] -name = "sha1_smol" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012" - -[[package]] -name = "slog" -version = "2.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8347046d4ebd943127157b94d63abb990fcf729dc4e9978927fdf4ac3c998d06" - -[[package]] -name = "syn" -version = "1.0.102" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fcd952facd492f9be3ef0d0b7032a6e442ee9b361d4acc2b1d0c4aaa5f613a1" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "synstructure" -version = "0.12.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f" -dependencies = [ - "proc-macro2", - "quote", - "syn", - "unicode-xid", -] - -[[package]] -name = "termcolor" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "toml" -version = "0.5.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7" -dependencies = [ - "serde", -] - -[[package]] -name = "trybuild" -version = "1.0.70" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95f85ea8716eb36835f1f685d3511013906246e87077e322a587957091f84426" -dependencies = [ - "glob", - "once_cell", - "serde", - "serde_derive", - "serde_json", - "termcolor", - "toml", -] - -[[package]] -name = "typenum" -version = "1.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987" - -[[package]] -name = "unicode-ident" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3" - -[[package]] -name = "unicode-xid" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c" - -[[package]] -name = "uuid" -version = "1.2.1" -dependencies = [ - "arbitrary", - "atomic", - "bincode", - "getrandom", - "md-5", - "rand", - "rustversion", - "serde", - "serde_derive", - "serde_json", - "serde_test", - "sha1_smol", - "slog", - "trybuild", - "uuid-macro-internal", - "wasm-bindgen", - "wasm-bindgen-test", - "windows-sys", - "zerocopy", -] - -[[package]] -name = "uuid-macro-internal" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44cc305b0c375fa2f078537bbe564516cb1946c1defa4041aa0e3f9cd5e07c4a" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "version_check" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" - -[[package]] -name = "wasi" -version = "0.11.0+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" - -[[package]] -name = "wasm-bindgen" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268" -dependencies = [ - "cfg-if", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142" -dependencies = [ - "bumpalo", - "log", - "once_cell", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23639446165ca5a5de86ae1d8896b737ae80319560fbaa4c2887b7da6e7ebd7d" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c" -dependencies = [ - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f" - -[[package]] -name = "wasm-bindgen-test" -version = "0.3.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09d2fff962180c3fadf677438054b1db62bee4aa32af26a45388af07d1287e1d" -dependencies = [ - "console_error_panic_hook", - "js-sys", - "scoped-tls", - "wasm-bindgen", - "wasm-bindgen-futures", - "wasm-bindgen-test-macro", -] - -[[package]] -name = "wasm-bindgen-test-macro" -version = "0.3.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4683da3dfc016f704c9f82cf401520c4f1cb3ee440f7f52b3d6ac29506a49ca7" -dependencies = [ - "proc-macro2", - "quote", -] - -[[package]] -name = "web-sys" -version = "0.3.60" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-util" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" -dependencies = [ - "winapi", -] - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "windows-sys" -version = "0.42.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7" -dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.42.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41d2aa71f6f0cbe00ae5167d90ef3cfe66527d6f613ca78ac8024c3ccab9a19e" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.42.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd0f252f5a35cac83d6311b2e795981f5ee6e67eb1f9a7f64eb4500fbc4dcdb4" - -[[package]] -name = "windows_i686_gnu" -version = "0.42.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbeae19f6716841636c28d695375df17562ca208b2b7d0dc47635a50ae6c5de7" - -[[package]] -name = "windows_i686_msvc" -version = "0.42.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84c12f65daa39dd2babe6e442988fc329d6243fdce47d7d2d155b8d874862246" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.42.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf7b1b21b5362cbc318f686150e5bcea75ecedc74dd157d874d754a2ca44b0ed" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.42.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09d525d2ba30eeb3297665bd434a54297e4170c7f1a44cad4ef58095b4cd2028" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.42.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f40009d85759725a34da6d89a94e63d7bdc50a862acf0dbc7c8e488f1edcb6f5" - -[[package]] -name = "zerocopy" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "332f188cc1bcf1fe1064b8c58d150f497e697f49774aa846f2dc949d9a25f236" -dependencies = [ - "byteorder", - "zerocopy-derive", -] - -[[package]] -name = "zerocopy-derive" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0fbc82b82efe24da867ee52e015e58178684bd9dd64c34e66bdf21da2582a9f" -dependencies = [ - "proc-macro2", - "syn", - "synstructure", -] diff --git a/fixtures/nextest-tests/vendor/uuid/Cargo.toml b/fixtures/nextest-tests/vendor/uuid/Cargo.toml deleted file mode 100644 index cadb44cb14d..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/Cargo.toml +++ /dev/null @@ -1,194 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2018" -name = "uuid" -version = "1.2.1" -authors = [ - "Ashley Mannix", - "Christopher Armstrong", - "Dylan DPC", - "Hunar Roop Kahlon", -] -exclude = [".github/**"] -description = "A library to generate and parse UUIDs." -homepage = "https://github.com/uuid-rs/uuid" -documentation = "https://docs.rs/uuid" -readme = "README.md" -keywords = [ - "guid", - "unique", - "uuid", -] -categories = [ - "data-structures", - "no-std", - "parser-implementations", - "wasm", -] -license = "Apache-2.0 OR MIT" -repository = "https://github.com/uuid-rs/uuid" - -[package.metadata.docs.rs] -rustc-args = [ - "--cfg", - "uuid_unstable", -] -rustdoc-args = [ - "--cfg", - "uuid_unstable", -] -targets = ["x86_64-unknown-linux-gnu"] -features = [ - "serde", - "arbitrary", - "slog", - "v1", - "v3", - "v4", - "v5", - "v6", - "v7", - "v8", -] - -[package.metadata.playground] -features = [ - "serde", - "v1", - "v3", - "v4", - "v5", - "v6", - "v7", - "v8", -] - -[dependencies.arbitrary] -version = "=1.1.3" -optional = true - -[dependencies.atomic] -version = "0.5" -optional = true -default-features = false -package = "atomic" - -[dependencies.getrandom] -version = "0.2" -optional = true -package = "getrandom" - -[dependencies.md-5] -version = "0.10" -optional = true -default-features = false -package = "md-5" - -[dependencies.rand] -version = "0.8" -optional = true -package = "rand" - -[dependencies.serde] -version = "1.0.56" -optional = true -default-features = false - -[dependencies.sha1_smol] -version = "1" -optional = true -default-features = false -package = "sha1_smol" - -[dependencies.slog] -version = "2" -optional = true - -[dependencies.uuid-macro-internal] -version = "1.2.1" -optional = true -package = "uuid-macro-internal" - -[dependencies.wasm-bindgen] -version = "0.2" -optional = true -package = "wasm-bindgen" - -[dependencies.zerocopy] -version = "0.6" -optional = true - -[dev-dependencies.bincode] -version = "1.0" - -[dev-dependencies.rustversion] -version = "1" - -[dev-dependencies.serde_derive] -version = "1.0.79" - -[dev-dependencies.serde_json] -version = "1.0" - -[dev-dependencies.serde_test] -version = "1.0.56" - -[dev-dependencies.trybuild] -version = "1.0.52" - -[features] -default = ["std"] -fast-rng = [ - "rng", - "rand", -] -js = [ - "wasm-bindgen", - "getrandom", - "getrandom/js", -] -macro-diagnostics = ["uuid-macro-internal"] -md5 = ["md-5"] -rng = ["getrandom"] -sha1 = ["sha1_smol"] -std = [] -v1 = ["atomic"] -v3 = ["md5"] -v4 = ["rng"] -v5 = ["sha1"] -v6 = ["atomic"] -v7 = [ - "atomic", - "rng", -] -v8 = [] - -[target."cfg(target_arch = \"wasm32\")".dev-dependencies.wasm-bindgen] -version = "0.2" -package = "wasm-bindgen" - -[target."cfg(target_arch = \"wasm32\")".dev-dependencies.wasm-bindgen-test] -version = "0.3" - -[target."cfg(windows)".dev-dependencies.windows-sys] -version = "0.42.0" -features = ["Win32_System_Com"] - -[badges.is-it-maintained-issue-resolution] -repository = "uuid-rs/uuid" - -[badges.is-it-maintained-open-issues] -repository = "uuid-rs/uuid" - -[badges.maintenance] -status = "actively-developed" diff --git a/fixtures/nextest-tests/vendor/uuid/LICENSE-APACHE b/fixtures/nextest-tests/vendor/uuid/LICENSE-APACHE deleted file mode 100644 index 16fe87b06e8..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/fixtures/nextest-tests/vendor/uuid/LICENSE-MIT b/fixtures/nextest-tests/vendor/uuid/LICENSE-MIT deleted file mode 100644 index 99a3078e627..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/LICENSE-MIT +++ /dev/null @@ -1,26 +0,0 @@ -Copyright (c) 2014 The Rust Project Developers -Copyright (c) 2018 Ashley Mannix, Christopher Armstrong, Dylan DPC, Hunar Roop Kahlon - -Permission is hereby granted, free of charge, to any -person obtaining a copy of this software and associated -documentation files (the "Software"), to deal in the -Software without restriction, including without -limitation the rights to use, copy, modify, merge, -publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software -is furnished to do so, subject to the following -conditions: - -The above copyright notice and this permission notice -shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF -ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A -PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR -IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. diff --git a/fixtures/nextest-tests/vendor/uuid/README.md b/fixtures/nextest-tests/vendor/uuid/README.md deleted file mode 100644 index 92cf092dfee..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/README.md +++ /dev/null @@ -1,99 +0,0 @@ -# `uuid` - -[![Latest Version](https://img.shields.io/crates/v/uuid.svg)](https://crates.io/crates/uuid) -![Minimum rustc version](https://img.shields.io/badge/rustc-1.46.0+-yellow.svg) -[![Continuous integration](https://github.com/uuid-rs/uuid/actions/workflows/ci.yml/badge.svg)](https://github.com/uuid-rs/uuid/actions/workflows/ci.yml) - -Here's an example of a UUID: - -```text -67e55044-10b1-426f-9247-bb680e5fe0c8 -``` - -A UUID is a unique 128-bit value, stored as 16 octets, and regularly -formatted as a hex string in five groups. UUIDs are used to assign unique -identifiers to entities without requiring a central allocating authority. - -They are particularly useful in distributed systems, though can be used in -disparate areas, such as databases and network protocols. Typically a UUID -is displayed in a readable string form as a sequence of hexadecimal digits, -separated into groups by hyphens. - -The uniqueness property is not strictly guaranteed, however for all -practical purposes, it can be assumed that an unintentional collision would -be extremely unlikely. - -## Getting started - -Add the following to your `Cargo.toml`: - -```toml -[dependencies.uuid] -version = "1.2.1" -features = [ - "v4", # Lets you generate random UUIDs - "fast-rng", # Use a faster (but still sufficiently random) RNG - "macro-diagnostics", # Enable better diagnostics for compile-time UUIDs -] -``` - -When you want a UUID, you can generate one: - -```rust -use uuid::Uuid; - -let id = Uuid::new_v4(); -``` - -If you have a UUID value, you can use its string literal form inline: - -```rust -use uuid::{uuid, Uuid}; - -const ID: Uuid = uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"); -``` - -You can also parse UUIDs without needing any crate features: - -```rust -use uuid::{Uuid, Version}; - -let my_uuid = Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8")?; - -assert_eq!(Some(Version::Random), my_uuid.get_version()); -``` - -If you'd like to parse UUIDs _really_ fast, check out the [`uuid-simd`](https://github.com/nugine/uuid-simd) -library. - -For more details on using `uuid`, [see the library documentation](https://docs.rs/uuid/1.2.1/uuid). - -## Minimum Supported Rust Version (MSRV) - -The minimum supported Rust version for `uuid` is documented in -CI. It may be bumped in minor releases as necessary. - -## References - -* [`uuid` library docs](https://docs.rs/uuid/1.2.1/uuid). -* [Wikipedia: Universally Unique Identifier](http://en.wikipedia.org/wiki/Universally_unique_identifier). -* [RFC4122: A Universally Unique IDentifier (UUID) URN Namespace](http://tools.ietf.org/html/rfc4122). - ---- -# License - -Licensed under either of - -* Apache License, Version 2.0, (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0) -* MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT) - -at your option. - - -[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fuuid-rs%2Fuuid.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2Fuuid-rs%2Fuuid?ref=badge_large) - -## Contribution - -Unless you explicitly state otherwise, any contribution intentionally submitted -for inclusion in the work by you, as defined in the Apache-2.0 license, shall -be dual licensed as above, without any additional terms or conditions. \ No newline at end of file diff --git a/fixtures/nextest-tests/vendor/uuid/benches/format_str.rs b/fixtures/nextest-tests/vendor/uuid/benches/format_str.rs deleted file mode 100644 index fab89297bfb..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/benches/format_str.rs +++ /dev/null @@ -1,66 +0,0 @@ -#![feature(test)] -extern crate test; - -use std::io::Write; -use test::Bencher; -use uuid::Uuid; - -#[bench] -fn hyphenated(b: &mut Bencher) { - let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap(); - b.iter(|| { - let mut buffer = [0_u8; 36]; - write!(&mut buffer as &mut [_], "{:x}", uuid.hyphenated()).unwrap(); - buffer - }); -} - -#[bench] -fn simple(b: &mut Bencher) { - let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap(); - b.iter(|| { - let mut buffer = [0_u8; 32]; - write!(&mut buffer as &mut [_], "{:x}", uuid.simple()).unwrap(); - buffer - }) -} - -#[bench] -fn urn(b: &mut Bencher) { - let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap(); - b.iter(|| { - let mut buffer = [0_u8; 36 + 9]; - write!(&mut buffer as &mut [_], "{:x}", uuid.urn()).unwrap(); - buffer - }) -} - -#[bench] -fn encode_hyphen(b: &mut Bencher) { - let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap(); - b.iter(|| { - let mut buffer = [0_u8; 36]; - uuid.hyphenated().encode_lower(&mut buffer); - buffer - }); -} - -#[bench] -fn encode_simple(b: &mut Bencher) { - let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap(); - b.iter(|| { - let mut buffer = [0_u8; 32]; - uuid.simple().encode_lower(&mut buffer); - buffer - }) -} - -#[bench] -fn encode_urn(b: &mut Bencher) { - let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap(); - b.iter(|| { - let mut buffer = [0_u8; 36 + 9]; - uuid.urn().encode_lower(&mut buffer); - buffer - }) -} diff --git a/fixtures/nextest-tests/vendor/uuid/benches/parse_str.rs b/fixtures/nextest-tests/vendor/uuid/benches/parse_str.rs deleted file mode 100644 index e53ba242d36..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/benches/parse_str.rs +++ /dev/null @@ -1,50 +0,0 @@ -#![feature(test)] -extern crate test; - -use test::Bencher; -use uuid::Uuid; - -#[bench] -fn parse_nil(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("00000000000000000000000000000000")); -} - -#[bench] -fn parse_nil_hyphenated(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("00000000-0000-0000-0000-000000000000")); -} - -#[bench] -fn parse_random(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c8")); -} - -#[bench] -fn parse_random_hyphenated(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8")); -} - -#[bench] -fn parse_urn(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8")); -} - -#[bench] -fn parse_invalid_len(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4")) -} - -#[bench] -fn parse_invalid_character(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4")) -} - -#[bench] -fn parse_invalid_group_len(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("01020304-1112-2122-3132-41424344")); -} - -#[bench] -fn parse_invalid_groups(b: &mut Bencher) { - b.iter(|| Uuid::parse_str("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4")); -} diff --git a/fixtures/nextest-tests/vendor/uuid/benches/v4.rs b/fixtures/nextest-tests/vendor/uuid/benches/v4.rs deleted file mode 100644 index 61c3246b956..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/benches/v4.rs +++ /dev/null @@ -1,11 +0,0 @@ -#![cfg(feature = "v4")] -#![feature(test)] -extern crate test; - -use test::Bencher; -use uuid::Uuid; - -#[bench] -fn new_v4(b: &mut Bencher) { - b.iter(|| Uuid::new_v4()); -} diff --git a/fixtures/nextest-tests/vendor/uuid/examples/random_uuid.rs b/fixtures/nextest-tests/vendor/uuid/examples/random_uuid.rs deleted file mode 100644 index 897071c4686..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/examples/random_uuid.rs +++ /dev/null @@ -1,15 +0,0 @@ -//! Generating a random UUID. -//! -//! If you enable the `v4` feature you can generate random UUIDs. - -#[test] -#[cfg(feature = "v4")] -fn generate_random_uuid() { - use uuid::Uuid; - - let uuid = Uuid::new_v4(); - - assert_eq!(Some(uuid::Version::Random), uuid.get_version()); -} - -fn main() {} diff --git a/fixtures/nextest-tests/vendor/uuid/examples/sortable_uuid.rs b/fixtures/nextest-tests/vendor/uuid/examples/sortable_uuid.rs deleted file mode 100644 index dc12812533f..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/examples/sortable_uuid.rs +++ /dev/null @@ -1,15 +0,0 @@ -//! Generating a sortable UUID. -//! -//! If you enable the `v7` feature you can generate sortable UUIDs. - -#[test] -#[cfg(feature = "v7")] -fn generate_sortable_uuid() { - use uuid::Uuid; - - let uuid = Uuid::now_v7(); - - assert_eq!(Some(uuid::Version::SortRand), uuid.get_version()); -} - -fn main() {} diff --git a/fixtures/nextest-tests/vendor/uuid/examples/uuid_macro.rs b/fixtures/nextest-tests/vendor/uuid/examples/uuid_macro.rs deleted file mode 100644 index c4ff0484b57..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/examples/uuid_macro.rs +++ /dev/null @@ -1,19 +0,0 @@ -//! Using the `uuid!` macro. -//! -//! `uuid!` will parse encoded UUIDs at compile time instead of at runtime. -//! If you've got a fixed UUID string handy then consider using `uuid!` instead -//! of `Uuid::parse_str` or `str::parse`. -//! -//! If you enable the `macro-diagnostics` feature, you can see much better -//! error messages. - -#[test] -fn parse_uuid_at_compile_time() { - use uuid::uuid; - - let uuid = uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"); - - assert_eq!(Some(uuid::Version::Random), uuid.get_version()); -} - -fn main() {} diff --git a/fixtures/nextest-tests/vendor/uuid/examples/windows_guid.rs b/fixtures/nextest-tests/vendor/uuid/examples/windows_guid.rs deleted file mode 100644 index 6cbc10ed682..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/examples/windows_guid.rs +++ /dev/null @@ -1,112 +0,0 @@ -//! Converting between Windows GUIDs and UUIDs. -//! -//! Windows GUIDs are specified as using mixed endianness. -//! What you get will depend on the source of the GUID. -//! Functions like `CoCreateGuid` will generate a valid UUID so -//! the fields will be naturally ordered for `Uuid::from_fields`. -//! Other GUIDs might need to be passed to `Uuid::from_fields_le` -//! to have their ordering swapped. - -#[test] -#[cfg(windows)] -fn guid_to_uuid() { - use uuid::Uuid; - use windows_sys::core; - - let guid_in = core::GUID { - data1: 0x4a35229d, - data2: 0x5527, - data3: 0x4f30, - data4: [0x86, 0x47, 0x9d, 0xc5, 0x4e, 0x1e, 0xe1, 0xe8], - }; - - let uuid = Uuid::from_fields(guid_in.data1, guid_in.data2, guid_in.data3, &guid_in.data4); - - let guid_out = { - let fields = uuid.as_fields(); - - core::GUID { - data1: fields.0, - data2: fields.1, - data3: fields.2, - data4: *fields.3, - } - }; - - assert_eq!( - (guid_in.data1, guid_in.data2, guid_in.data3, guid_in.data4), - ( - guid_out.data1, - guid_out.data2, - guid_out.data3, - guid_out.data4 - ) - ); -} - -#[test] -#[cfg(windows)] -fn guid_to_uuid_le_encoded() { - use uuid::Uuid; - use windows_sys::core; - - // A GUID might not be encoded directly as a UUID - // If its fields are stored in little-endian order they might - // need to be flipped. Whether or not this is necessary depends - // on the source of the GUID - let guid_in = core::GUID { - data1: 0x9d22354a, - data2: 0x2755, - data3: 0x304f, - data4: [0x86, 0x47, 0x9d, 0xc5, 0x4e, 0x1e, 0xe1, 0xe8], - }; - - let uuid = Uuid::from_fields_le(guid_in.data1, guid_in.data2, guid_in.data3, &guid_in.data4); - - let guid_out = { - let fields = uuid.to_fields_le(); - - core::GUID { - data1: fields.0, - data2: fields.1, - data3: fields.2, - data4: *fields.3, - } - }; - - assert_eq!( - (guid_in.data1, guid_in.data2, guid_in.data3, guid_in.data4), - ( - guid_out.data1, - guid_out.data2, - guid_out.data3, - guid_out.data4 - ) - ); -} - -#[test] -#[cfg(windows)] -fn uuid_from_cocreateguid() { - use uuid::{Uuid, Variant, Version}; - use windows_sys::core; - use windows_sys::Win32::System::Com::CoCreateGuid; - - let mut guid = core::GUID { - data1: 0, - data2: 0, - data3: 0, - data4: [0u8; 8], - }; - - unsafe { - CoCreateGuid(&mut guid); - } - - let uuid = Uuid::from_fields(guid.data1, guid.data2, guid.data3, &guid.data4); - - assert_eq!(Variant::RFC4122, uuid.get_variant()); - assert_eq!(Some(Version::Random), uuid.get_version()); -} - -fn main() {} diff --git a/fixtures/nextest-tests/vendor/uuid/src/builder.rs b/fixtures/nextest-tests/vendor/uuid/src/builder.rs deleted file mode 100644 index 60aeb435ea2..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/builder.rs +++ /dev/null @@ -1,905 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. -// Copyright 2018 The Uuid Project Developers. -// -// See the COPYRIGHT file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! A Builder type for [`Uuid`]s. -//! -//! [`Uuid`]: ../struct.Uuid.html - -use crate::{error::*, timestamp, Bytes, Uuid, Variant, Version}; - -/// A builder for creating a UUID. -/// -/// This type is useful if you need to mutate individual fields of a [`Uuid`] -/// while constructing it. Since the [`Uuid`] type is `Copy`, it doesn't offer -/// any methods to mutate in place. They live on the `Builder` instead. -/// -/// The `Builder` type also always exposes APIs to construct [`Uuid`]s for any -/// version without needing crate features or additional dependencies. It's a -/// lower-level API than the methods on [`Uuid`]. -/// -/// # Examples -/// -/// Creating a version 4 UUID from externally generated random bytes: -/// -/// ``` -/// # use uuid::{Builder, Version, Variant}; -/// # let rng = || [ -/// # 70, 235, 208, 238, 14, 109, 67, 201, 185, 13, 204, 195, 90, -/// # 145, 63, 62, -/// # ]; -/// let random_bytes = rng(); -/// -/// let uuid = Builder::from_random_bytes(random_bytes).into_uuid(); -/// -/// assert_eq!(Some(Version::Random), uuid.get_version()); -/// assert_eq!(Variant::RFC4122, uuid.get_variant()); -/// ``` -#[allow(missing_copy_implementations)] -#[derive(Debug)] -pub struct Builder(Uuid); - -impl Uuid { - /// The 'nil UUID' (all zeros). - /// - /// The nil UUID is a special form of UUID that is specified to have all - /// 128 bits set to zero. - /// - /// # References - /// - /// * [Nil UUID in RFC4122](https://tools.ietf.org/html/rfc4122.html#section-4.1.7) - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Uuid; - /// let uuid = Uuid::nil(); - /// - /// assert_eq!( - /// "00000000-0000-0000-0000-000000000000", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn nil() -> Self { - Uuid::from_bytes([0; 16]) - } - - /// The 'max UUID' (all ones). - /// - /// The max UUID is a special form of UUID that is specified to have all - /// 128 bits set to one. - /// - /// # References - /// - /// * [Max UUID in Draft RFC: New UUID Formats, Version 4](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-5.4) - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Uuid; - /// let uuid = Uuid::max(); - /// - /// assert_eq!( - /// "ffffffff-ffff-ffff-ffff-ffffffffffff", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - #[cfg(uuid_unstable)] - pub const fn max() -> Self { - Uuid::from_bytes([0xFF; 16]) - } - - /// Creates a UUID from four field values. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Uuid; - /// let d1 = 0xa1a2a3a4; - /// let d2 = 0xb1b2; - /// let d3 = 0xc1c2; - /// let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - /// - /// let uuid = Uuid::from_fields(d1, d2, d3, &d4); - /// - /// assert_eq!( - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn from_fields(d1: u32, d2: u16, d3: u16, d4: &[u8; 8]) -> Uuid { - Uuid::from_bytes([ - (d1 >> 24) as u8, - (d1 >> 16) as u8, - (d1 >> 8) as u8, - d1 as u8, - (d2 >> 8) as u8, - d2 as u8, - (d3 >> 8) as u8, - d3 as u8, - d4[0], - d4[1], - d4[2], - d4[3], - d4[4], - d4[5], - d4[6], - d4[7], - ]) - } - - /// Creates a UUID from four field values in little-endian order. - /// - /// The bytes in the `d1`, `d2` and `d3` fields will be flipped to convert - /// into big-endian order. This is based on the endianness of the UUID, - /// rather than the target environment so bytes will be flipped on both - /// big and little endian machines. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Uuid; - /// let d1 = 0xa1a2a3a4; - /// let d2 = 0xb1b2; - /// let d3 = 0xc1c2; - /// let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - /// - /// let uuid = Uuid::from_fields_le(d1, d2, d3, &d4); - /// - /// assert_eq!( - /// "a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn from_fields_le(d1: u32, d2: u16, d3: u16, d4: &[u8; 8]) -> Uuid { - Uuid::from_bytes([ - d1 as u8, - (d1 >> 8) as u8, - (d1 >> 16) as u8, - (d1 >> 24) as u8, - (d2) as u8, - (d2 >> 8) as u8, - d3 as u8, - (d3 >> 8) as u8, - d4[0], - d4[1], - d4[2], - d4[3], - d4[4], - d4[5], - d4[6], - d4[7], - ]) - } - - /// Creates a UUID from a 128bit value. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Uuid; - /// let v = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128; - /// - /// let uuid = Uuid::from_u128(v); - /// - /// assert_eq!( - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn from_u128(v: u128) -> Self { - Uuid::from_bytes([ - (v >> 120) as u8, - (v >> 112) as u8, - (v >> 104) as u8, - (v >> 96) as u8, - (v >> 88) as u8, - (v >> 80) as u8, - (v >> 72) as u8, - (v >> 64) as u8, - (v >> 56) as u8, - (v >> 48) as u8, - (v >> 40) as u8, - (v >> 32) as u8, - (v >> 24) as u8, - (v >> 16) as u8, - (v >> 8) as u8, - v as u8, - ]) - } - - /// Creates a UUID from a 128bit value in little-endian order. - /// - /// The entire value will be flipped to convert into big-endian order. - /// This is based on the endianness of the UUID, rather than the target - /// environment so bytes will be flipped on both big and little endian - /// machines. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Uuid; - /// let v = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128; - /// - /// let uuid = Uuid::from_u128_le(v); - /// - /// assert_eq!( - /// "d8d7d6d5-d4d3-d2d1-c2c1-b2b1a4a3a2a1", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn from_u128_le(v: u128) -> Self { - Uuid::from_bytes([ - v as u8, - (v >> 8) as u8, - (v >> 16) as u8, - (v >> 24) as u8, - (v >> 32) as u8, - (v >> 40) as u8, - (v >> 48) as u8, - (v >> 56) as u8, - (v >> 64) as u8, - (v >> 72) as u8, - (v >> 80) as u8, - (v >> 88) as u8, - (v >> 96) as u8, - (v >> 104) as u8, - (v >> 112) as u8, - (v >> 120) as u8, - ]) - } - - /// Creates a UUID from two 64bit values. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Uuid; - /// let hi = 0xa1a2a3a4b1b2c1c2u64; - /// let lo = 0xd1d2d3d4d5d6d7d8u64; - /// - /// let uuid = Uuid::from_u64_pair(hi, lo); - /// - /// assert_eq!( - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn from_u64_pair(high_bits: u64, low_bits: u64) -> Self { - Uuid::from_bytes([ - (high_bits >> 56) as u8, - (high_bits >> 48) as u8, - (high_bits >> 40) as u8, - (high_bits >> 32) as u8, - (high_bits >> 24) as u8, - (high_bits >> 16) as u8, - (high_bits >> 8) as u8, - high_bits as u8, - (low_bits >> 56) as u8, - (low_bits >> 48) as u8, - (low_bits >> 40) as u8, - (low_bits >> 32) as u8, - (low_bits >> 24) as u8, - (low_bits >> 16) as u8, - (low_bits >> 8) as u8, - low_bits as u8, - ]) - } - - /// Creates a UUID using the supplied bytes. - /// - /// # Errors - /// - /// This function will return an error if `b` has any length other than 16. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # fn main() -> Result<(), uuid::Error> { - /// # use uuid::Uuid; - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Uuid::from_slice(&bytes)?; - /// - /// assert_eq!( - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// # Ok(()) - /// # } - /// ``` - pub fn from_slice(b: &[u8]) -> Result { - if b.len() != 16 { - return Err(Error(ErrorKind::ByteLength { len: b.len() })); - } - - let mut bytes: Bytes = [0; 16]; - bytes.copy_from_slice(b); - Ok(Uuid::from_bytes(bytes)) - } - - /// Creates a UUID using the supplied bytes in little endian order. - /// - /// The individual fields encoded in the buffer will be flipped. - /// - /// # Errors - /// - /// This function will return an error if `b` has any length other than 16. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # fn main() -> Result<(), uuid::Error> { - /// # use uuid::Uuid; - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Uuid::from_slice_le(&bytes)?; - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8" - /// ); - /// # Ok(()) - /// # } - /// ``` - pub fn from_slice_le(b: &[u8]) -> Result { - if b.len() != 16 { - return Err(Error(ErrorKind::ByteLength { len: b.len() })); - } - - let mut bytes: Bytes = [0; 16]; - bytes.copy_from_slice(b); - Ok(Uuid::from_bytes_le(bytes)) - } - - /// Creates a UUID using the supplied bytes. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # fn main() -> Result<(), uuid::Error> { - /// # use uuid::Uuid; - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Uuid::from_bytes(bytes); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8" - /// ); - /// # Ok(()) - /// # } - /// ``` - pub const fn from_bytes(bytes: Bytes) -> Uuid { - Uuid(bytes) - } - - /// Creates a UUID using the supplied bytes in little endian order. - /// - /// The individual fields encoded in the buffer will be flipped. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # fn main() -> Result<(), uuid::Error> { - /// # use uuid::Uuid; - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Uuid::from_bytes_le(bytes); - /// - /// assert_eq!( - /// "a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// # Ok(()) - /// # } - /// ``` - pub const fn from_bytes_le(b: Bytes) -> Uuid { - Uuid([ - b[3], b[2], b[1], b[0], b[5], b[4], b[7], b[6], b[8], b[9], b[10], b[11], b[12], b[13], - b[14], b[15], - ]) - } - - /// Creates a reference to a UUID from a reference to the supplied bytes. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # fn main() -> Result<(), uuid::Error> { - /// # use uuid::Uuid; - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Uuid::from_bytes_ref(&bytes); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8" - /// ); - /// - /// assert!(std::ptr::eq( - /// uuid as *const Uuid as *const u8, - /// &bytes as *const [u8; 16] as *const u8, - /// )); - /// # Ok(()) - /// # } - /// ``` - pub fn from_bytes_ref(bytes: &Bytes) -> &Uuid { - // SAFETY: `Bytes` and `Uuid` have the same ABI - unsafe { &*(bytes as *const Bytes as *const Uuid) } - } - - // NOTE: There is no `from_u128_ref` because in little-endian - // environments the value isn't properly encoded. Callers would - // need to use `.to_be()` themselves. -} - -impl Builder { - /// Creates a `Builder` using the supplied bytes. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Builder::from_bytes(bytes).into_uuid(); - /// - /// assert_eq!( - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn from_bytes(b: Bytes) -> Self { - Builder(Uuid::from_bytes(b)) - } - - /// Creates a `Builder` using the supplied bytes in little endian order. - /// - /// The individual fields encoded in the buffer will be flipped. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # fn main() -> Result<(), uuid::Error> { - /// # use uuid::{Builder, Uuid}; - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Builder::from_bytes_le(bytes).into_uuid(); - /// - /// assert_eq!( - /// "a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// # Ok(()) - /// # } - /// ``` - pub const fn from_bytes_le(b: Bytes) -> Self { - Builder(Uuid::from_bytes_le(b)) - } - - /// Creates a `Builder` for a version 1 UUID using the supplied timestamp and node ID. - pub const fn from_rfc4122_timestamp(ticks: u64, counter: u16, node_id: &[u8; 6]) -> Self { - Builder(timestamp::encode_rfc4122_timestamp(ticks, counter, node_id)) - } - - /// Creates a `Builder` for a version 3 UUID using the supplied MD5 hashed bytes. - pub const fn from_md5_bytes(md5_bytes: Bytes) -> Self { - Builder(Uuid::from_bytes(md5_bytes)) - .with_variant(Variant::RFC4122) - .with_version(Version::Md5) - } - - /// Creates a `Builder` for a version 4 UUID using the supplied random bytes. - /// - /// This method assumes the bytes are already sufficiently random, it will only - /// set the appropriate bits for the UUID version and variant. - /// - /// # Examples - /// - /// ``` - /// # use uuid::{Builder, Variant, Version}; - /// # let rng = || [ - /// # 70, 235, 208, 238, 14, 109, 67, 201, 185, 13, 204, 195, 90, - /// # 145, 63, 62, - /// # ]; - /// let random_bytes = rng(); - /// let uuid = Builder::from_random_bytes(random_bytes).into_uuid(); - /// - /// assert_eq!(Some(Version::Random), uuid.get_version()); - /// assert_eq!(Variant::RFC4122, uuid.get_variant()); - /// ``` - pub const fn from_random_bytes(random_bytes: Bytes) -> Self { - Builder(Uuid::from_bytes(random_bytes)) - .with_variant(Variant::RFC4122) - .with_version(Version::Random) - } - - /// Creates a `Builder` for a version 5 UUID using the supplied SHA-1 hashed bytes. - /// - /// This method assumes the bytes are already a SHA-1 hash, it will only set the appropriate - /// bits for the UUID version and variant. - pub const fn from_sha1_bytes(sha1_bytes: Bytes) -> Self { - Builder(Uuid::from_bytes(sha1_bytes)) - .with_variant(Variant::RFC4122) - .with_version(Version::Sha1) - } - - /// Creates a `Builder` for a version 6 UUID using the supplied timestamp and node ID. - /// - /// This method will encode the ticks, counter, and node ID in a sortable UUID. - #[cfg(uuid_unstable)] - pub const fn from_sorted_rfc4122_timestamp( - ticks: u64, - counter: u16, - node_id: &[u8; 6], - ) -> Self { - Builder(timestamp::encode_sorted_rfc4122_timestamp( - ticks, counter, node_id, - )) - } - - /// Creates a `Builder` for a version 7 UUID using the supplied Unix timestamp and random bytes. - /// - /// This method assumes the bytes are already sufficiently random. - /// - /// # Examples - /// - /// Creating a UUID using the current system timestamp: - /// - /// ``` - /// # use std::convert::TryInto; - /// use std::time::{Duration, SystemTime}; - /// # fn main() -> Result<(), Box> { - /// # use uuid::{Builder, Uuid, Variant, Version, Timestamp, NoContext}; - /// # let rng = || [ - /// # 70, 235, 208, 238, 14, 109, 67, 201, 185, 13 - /// # ]; - /// let ts = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?; - /// - /// let random_bytes = rng(); - /// - /// let uuid = Builder::from_unix_timestamp_millis(ts.as_millis().try_into()?, &random_bytes).into_uuid(); - /// - /// assert_eq!(Some(Version::SortRand), uuid.get_version()); - /// assert_eq!(Variant::RFC4122, uuid.get_variant()); - /// # Ok(()) - /// # } - /// ``` - #[cfg(uuid_unstable)] - pub const fn from_unix_timestamp_millis(millis: u64, random_bytes: &[u8; 10]) -> Self { - Builder(timestamp::encode_unix_timestamp_millis( - millis, - random_bytes, - )) - } - - /// Creates a `Builder` for a version 8 UUID using the supplied user-defined bytes. - /// - /// This method won't interpret the given bytes in any way, except to set the appropriate - /// bits for the UUID version and variant. - #[cfg(uuid_unstable)] - pub const fn from_custom_bytes(custom_bytes: Bytes) -> Self { - Builder::from_bytes(custom_bytes) - .with_variant(Variant::RFC4122) - .with_version(Version::Custom) - } - - /// Creates a `Builder` using the supplied bytes. - /// - /// # Errors - /// - /// This function will return an error if `b` has any length other than 16. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// # fn main() -> Result<(), uuid::Error> { - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Builder::from_slice(&bytes)?.into_uuid(); - /// - /// assert_eq!( - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// # Ok(()) - /// # } - /// ``` - pub fn from_slice(b: &[u8]) -> Result { - Ok(Builder(Uuid::from_slice(b)?)) - } - - /// Creates a `Builder` using the supplied bytes in little endian order. - /// - /// The individual fields encoded in the buffer will be flipped. - /// - /// # Errors - /// - /// This function will return an error if `b` has any length other than 16. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// # fn main() -> Result<(), uuid::Error> { - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// - /// let uuid = Builder::from_slice_le(&bytes)?.into_uuid(); - /// - /// assert_eq!( - /// "a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// # Ok(()) - /// # } - /// ``` - pub fn from_slice_le(b: &[u8]) -> Result { - Ok(Builder(Uuid::from_slice_le(b)?)) - } - - /// Creates a `Builder` from four field values. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// let d1 = 0xa1a2a3a4; - /// let d2 = 0xb1b2; - /// let d3 = 0xc1c2; - /// let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - /// - /// let uuid = Builder::from_fields(d1, d2, d3, &d4).into_uuid(); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8" - /// ); - /// ``` - pub const fn from_fields(d1: u32, d2: u16, d3: u16, d4: &[u8; 8]) -> Self { - Builder(Uuid::from_fields(d1, d2, d3, d4)) - } - - /// Creates a `Builder` from four field values. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// let d1 = 0xa1a2a3a4; - /// let d2 = 0xb1b2; - /// let d3 = 0xc1c2; - /// let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - /// - /// let uuid = Builder::from_fields_le(d1, d2, d3, &d4).into_uuid(); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8" - /// ); - /// ``` - pub const fn from_fields_le(d1: u32, d2: u16, d3: u16, d4: &[u8; 8]) -> Self { - Builder(Uuid::from_fields_le(d1, d2, d3, d4)) - } - - /// Creates a `Builder` from a 128bit value. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// let v = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128; - /// - /// let uuid = Builder::from_u128(v).into_uuid(); - /// - /// assert_eq!( - /// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn from_u128(v: u128) -> Self { - Builder(Uuid::from_u128(v)) - } - - /// Creates a UUID from a 128bit value in little-endian order. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// let v = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128; - /// - /// let uuid = Builder::from_u128_le(v).into_uuid(); - /// - /// assert_eq!( - /// "d8d7d6d5-d4d3-d2d1-c2c1-b2b1a4a3a2a1", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn from_u128_le(v: u128) -> Self { - Builder(Uuid::from_u128_le(v)) - } - - /// Creates a `Builder` with an initial [`Uuid::nil`]. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// let uuid = Builder::nil().into_uuid(); - /// - /// assert_eq!( - /// "00000000-0000-0000-0000-000000000000", - /// uuid.hyphenated().to_string(), - /// ); - /// ``` - pub const fn nil() -> Self { - Builder(Uuid::nil()) - } - - /// Specifies the variant of the UUID. - pub fn set_variant(&mut self, v: Variant) -> &mut Self { - *self = Builder(self.0).with_variant(v); - self - } - - /// Specifies the variant of the UUID. - pub const fn with_variant(mut self, v: Variant) -> Self { - let byte = (self.0).0[8]; - - (self.0).0[8] = match v { - Variant::NCS => byte & 0x7f, - Variant::RFC4122 => (byte & 0x3f) | 0x80, - Variant::Microsoft => (byte & 0x1f) | 0xc0, - Variant::Future => byte | 0xe0, - }; - - self - } - - /// Specifies the version number of the UUID. - pub fn set_version(&mut self, v: Version) -> &mut Self { - *self = Builder(self.0).with_version(v); - self - } - - /// Specifies the version number of the UUID. - pub const fn with_version(mut self, v: Version) -> Self { - (self.0).0[6] = ((self.0).0[6] & 0x0f) | ((v as u8) << 4); - - self - } - - /// Get a reference to the underlying [`Uuid`]. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// let builder = Builder::nil(); - /// - /// let uuid1 = builder.as_uuid(); - /// let uuid2 = builder.as_uuid(); - /// - /// assert_eq!(uuid1, uuid2); - /// ``` - pub const fn as_uuid(&self) -> &Uuid { - &self.0 - } - - /// Convert the builder into a [`Uuid`]. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Builder; - /// let uuid = Builder::nil().into_uuid(); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "00000000-0000-0000-0000-000000000000" - /// ); - /// ``` - pub const fn into_uuid(self) -> Uuid { - self.0 - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/error.rs b/fixtures/nextest-tests/vendor/uuid/src/error.rs deleted file mode 100644 index 6c3a4f438d9..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/error.rs +++ /dev/null @@ -1,172 +0,0 @@ -use crate::std::fmt; - -/// A general error that can occur when working with UUIDs. -#[derive(Clone, Debug, Eq, Hash, PartialEq)] -pub struct Error(pub(crate) ErrorKind); - -#[derive(Clone, Debug, Eq, Hash, PartialEq)] -pub(crate) enum ErrorKind { - /// Invalid character in the [`Uuid`] string. - /// - /// [`Uuid`]: ../struct.Uuid.html - Char { character: char, index: usize }, - /// A simple [`Uuid`] didn't contain 32 characters. - /// - /// [`Uuid`]: ../struct.Uuid.html - SimpleLength { len: usize }, - /// A byte array didn't contain 16 bytes - ByteLength { len: usize }, - /// A hyphenated [`Uuid`] didn't contain 5 groups - /// - /// [`Uuid`]: ../struct.Uuid.html - GroupCount { count: usize }, - /// A hyphenated [`Uuid`] had a group that wasn't the right length - /// - /// [`Uuid`]: ../struct.Uuid.html - GroupLength { - group: usize, - len: usize, - index: usize, - }, - /// The input was not a valid UTF8 string - InvalidUTF8, - /// Some other error occurred. - Other, -} - -/// A string that is guaranteed to fail to parse to a [`Uuid`]. -/// -/// This type acts as a lightweight error indicator, suggesting -/// that the string cannot be parsed but offering no error -/// details. To get details, use `InvalidUuid::into_err`. -/// -/// [`Uuid`]: ../struct.Uuid.html -#[derive(Clone, Debug, Eq, Hash, PartialEq)] -pub struct InvalidUuid<'a>(pub(crate) &'a [u8]); - -impl<'a> InvalidUuid<'a> { - /// Converts the lightweight error type into detailed diagnostics. - pub fn into_err(self) -> Error { - // Check whether or not the input was ever actually a valid UTF8 string - let input_str = match std::str::from_utf8(self.0) { - Ok(s) => s, - Err(_) => return Error(ErrorKind::InvalidUTF8), - }; - - let (uuid_str, offset, simple) = match input_str.as_bytes() { - [b'{', s @ .., b'}'] => (s, 1, false), - [b'u', b'r', b'n', b':', b'u', b'u', b'i', b'd', b':', s @ ..] => { - (s, "urn:uuid:".len(), false) - } - s => (s, 0, true), - }; - - let mut hyphen_count = 0; - let mut group_bounds = [0; 4]; - - // SAFETY: the byte array came from a valid utf8 string, - // and is aligned along char boundaries. - let uuid_str = unsafe { std::str::from_utf8_unchecked(uuid_str) }; - - for (index, character) in uuid_str.char_indices() { - let byte = character as u8; - if character as u32 - byte as u32 > 0 { - // Multibyte char - return Error(ErrorKind::Char { - character, - index: index + offset + 1, - }); - } else if byte == b'-' { - // While we search, also count group breaks - if hyphen_count < 4 { - group_bounds[hyphen_count] = index; - } - hyphen_count += 1; - } else if !matches!(byte, b'0'..=b'9' | b'a'..=b'f' | b'A'..=b'F') { - // Non-hex char - return Error(ErrorKind::Char { - character: byte as char, - index: index + offset + 1, - }); - } - } - - if hyphen_count == 0 && simple { - // This means that we tried and failed to parse a simple uuid. - // Since we verified that all the characters are valid, this means - // that it MUST have an invalid length. - Error(ErrorKind::SimpleLength { - len: input_str.len(), - }) - } else if hyphen_count != 4 { - // We tried to parse a hyphenated variant, but there weren't - // 5 groups (4 hyphen splits). - Error(ErrorKind::GroupCount { - count: hyphen_count + 1, - }) - } else { - // There are 5 groups, one of them has an incorrect length - const BLOCK_STARTS: [usize; 5] = [0, 9, 14, 19, 24]; - for i in 0..4 { - if group_bounds[i] != BLOCK_STARTS[i + 1] - 1 { - return Error(ErrorKind::GroupLength { - group: i, - len: group_bounds[i] - BLOCK_STARTS[i], - index: offset + BLOCK_STARTS[i] + 1, - }); - } - } - - // The last group must be too long - Error(ErrorKind::GroupLength { - group: 4, - len: input_str.len() - BLOCK_STARTS[4], - index: offset + BLOCK_STARTS[4] + 1, - }) - } - } -} - -// NOTE: This impl is part of the public API. Breaking changes to it should be carefully considered -impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self.0 { - ErrorKind::Char { - character, index, .. - } => { - write!(f, "invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `{}` at {}", character, index) - } - ErrorKind::SimpleLength { len } => { - write!( - f, - "invalid length: expected length 32 for simple format, found {}", - len - ) - } - ErrorKind::ByteLength { len } => { - write!(f, "invalid length: expected 16 bytes, found {}", len) - } - ErrorKind::GroupCount { count } => { - write!(f, "invalid group count: expected 5, found {}", count) - } - ErrorKind::GroupLength { group, len, .. } => { - let expected = [8, 4, 4, 4, 12][group]; - write!( - f, - "invalid group length in group {}: expected {}, found {}", - group, expected, len - ) - } - ErrorKind::InvalidUTF8 => write!(f, "non-UTF8 input"), - ErrorKind::Other => write!(f, "failed to parse a UUID"), - } - } -} - -#[cfg(feature = "std")] -mod std_support { - use super::*; - use crate::std::error; - - impl error::Error for Error {} -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/external.rs b/fixtures/nextest-tests/vendor/uuid/src/external.rs deleted file mode 100644 index 219a9236e55..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/external.rs +++ /dev/null @@ -1,6 +0,0 @@ -#[cfg(feature = "arbitrary")] -pub(crate) mod arbitrary_support; -#[cfg(feature = "serde")] -pub(crate) mod serde_support; -#[cfg(feature = "slog")] -pub(crate) mod slog_support; diff --git a/fixtures/nextest-tests/vendor/uuid/src/external/arbitrary_support.rs b/fixtures/nextest-tests/vendor/uuid/src/external/arbitrary_support.rs deleted file mode 100644 index cdc177c8e24..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/external/arbitrary_support.rs +++ /dev/null @@ -1,41 +0,0 @@ -use crate::{std::convert::TryInto, Builder, Uuid}; - -use arbitrary::{Arbitrary, Unstructured}; - -impl Arbitrary<'_> for Uuid { - fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result { - let b = u - .bytes(16)? - .try_into() - .map_err(|_| arbitrary::Error::NotEnoughData)?; - - Ok(Builder::from_random_bytes(b).into_uuid()) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - use crate::{Variant, Version}; - - #[test] - fn test_arbitrary() { - let mut bytes = Unstructured::new(&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); - - let uuid = Uuid::arbitrary(&mut bytes).unwrap(); - - assert_eq!(Some(Version::Random), uuid.get_version()); - assert_eq!(Variant::RFC4122, uuid.get_variant()); - } - - #[test] - fn test_arbitrary_empty() { - let mut bytes = Unstructured::new(&[]); - - // Ensure we don't panic when building an arbitrary `Uuid` - let uuid = Uuid::arbitrary(&mut bytes); - - assert!(uuid.is_err()); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/external/serde_support.rs b/fixtures/nextest-tests/vendor/uuid/src/external/serde_support.rs deleted file mode 100644 index 9c1a7244b75..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/external/serde_support.rs +++ /dev/null @@ -1,313 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. -// Copyright 2018 The Uuid Project Developers. -// -// See the COPYRIGHT file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use crate::{ - error::*, - fmt::{Braced, Hyphenated, Simple, Urn}, - std::fmt, - Uuid, -}; -use serde::{ - de::{self, Error as _}, - Deserialize, Deserializer, Serialize, Serializer, -}; - -impl Serialize for Uuid { - fn serialize(&self, serializer: S) -> Result { - if serializer.is_human_readable() { - serializer.serialize_str(self.hyphenated().encode_lower(&mut Uuid::encode_buffer())) - } else { - serializer.serialize_bytes(self.as_bytes()) - } - } -} - -impl Serialize for Hyphenated { - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer())) - } -} - -impl Serialize for Simple { - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer())) - } -} - -impl Serialize for Urn { - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer())) - } -} - -impl Serialize for Braced { - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(self.encode_lower(&mut Uuid::encode_buffer())) - } -} - -impl<'de> Deserialize<'de> for Uuid { - fn deserialize>(deserializer: D) -> Result { - fn de_error(e: Error) -> E { - E::custom(format_args!("UUID parsing failed: {}", e)) - } - - if deserializer.is_human_readable() { - struct UuidVisitor; - - impl<'vi> de::Visitor<'vi> for UuidVisitor { - type Value = Uuid; - - fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(formatter, "a UUID string") - } - - fn visit_str(self, value: &str) -> Result { - value.parse::().map_err(de_error) - } - - fn visit_bytes(self, value: &[u8]) -> Result { - Uuid::from_slice(value).map_err(de_error) - } - - fn visit_seq(self, mut seq: A) -> Result - where - A: de::SeqAccess<'vi>, - { - #[rustfmt::skip] - let bytes = [ - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(16, &self)) }, - ]; - - Ok(Uuid::from_bytes(bytes)) - } - } - - deserializer.deserialize_str(UuidVisitor) - } else { - struct UuidBytesVisitor; - - impl<'vi> de::Visitor<'vi> for UuidBytesVisitor { - type Value = Uuid; - - fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(formatter, "bytes") - } - - fn visit_bytes(self, value: &[u8]) -> Result { - Uuid::from_slice(value).map_err(de_error) - } - } - - deserializer.deserialize_bytes(UuidBytesVisitor) - } - } -} - -pub mod compact { - //! Serialize a [`Uuid`] as a `[u8; 16]`. - //! - //! [`Uuid`]: ../../struct.Uuid.html - - /// Serialize from a [`Uuid`] as a `[u8; 16]` - /// - /// [`Uuid`]: ../../struct.Uuid.html - pub fn serialize(u: &crate::Uuid, serializer: S) -> Result - where - S: serde::Serializer, - { - serde::Serialize::serialize(u.as_bytes(), serializer) - } - - /// Deserialize a `[u8; 16]` as a [`Uuid`] - /// - /// [`Uuid`]: ../../struct.Uuid.html - pub fn deserialize<'de, D>(deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - let bytes: [u8; 16] = serde::Deserialize::deserialize(deserializer)?; - - Ok(crate::Uuid::from_bytes(bytes)) - } - - #[cfg(test)] - mod tests { - use serde_derive::*; - use serde_test::{self, Configure}; - - #[test] - fn test_serialize_compact() { - #[derive(Serialize, Debug, Deserialize, PartialEq)] - struct UuidContainer { - #[serde(with = "crate::serde::compact")] - u: crate::Uuid, - } - - let uuid_bytes = b"F9168C5E-CEB2-4F"; - let container = UuidContainer { - u: crate::Uuid::from_slice(uuid_bytes).unwrap(), - }; - - // more complex because of the struct wrapping the actual UUID - // serialization - serde_test::assert_tokens( - &container.compact(), - &[ - serde_test::Token::Struct { - name: "UuidContainer", - len: 1, - }, - serde_test::Token::Str("u"), - serde_test::Token::Tuple { len: 16 }, - serde_test::Token::U8(uuid_bytes[0]), - serde_test::Token::U8(uuid_bytes[1]), - serde_test::Token::U8(uuid_bytes[2]), - serde_test::Token::U8(uuid_bytes[3]), - serde_test::Token::U8(uuid_bytes[4]), - serde_test::Token::U8(uuid_bytes[5]), - serde_test::Token::U8(uuid_bytes[6]), - serde_test::Token::U8(uuid_bytes[7]), - serde_test::Token::U8(uuid_bytes[8]), - serde_test::Token::U8(uuid_bytes[9]), - serde_test::Token::U8(uuid_bytes[10]), - serde_test::Token::U8(uuid_bytes[11]), - serde_test::Token::U8(uuid_bytes[12]), - serde_test::Token::U8(uuid_bytes[13]), - serde_test::Token::U8(uuid_bytes[14]), - serde_test::Token::U8(uuid_bytes[15]), - serde_test::Token::TupleEnd, - serde_test::Token::StructEnd, - ], - ) - } - } -} - -#[cfg(test)] -mod serde_tests { - use super::*; - - use serde_test::{Compact, Configure, Readable, Token}; - - #[test] - fn test_serialize_readable_string() { - let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4"; - let u = Uuid::parse_str(uuid_str).unwrap(); - serde_test::assert_tokens(&u.readable(), &[Token::Str(uuid_str)]); - } - - #[test] - fn test_deserialize_readable_compact() { - let uuid_bytes = b"F9168C5E-CEB2-4F"; - let u = Uuid::from_slice(uuid_bytes).unwrap(); - - serde_test::assert_de_tokens( - &u.readable(), - &[ - serde_test::Token::Tuple { len: 16 }, - serde_test::Token::U8(uuid_bytes[0]), - serde_test::Token::U8(uuid_bytes[1]), - serde_test::Token::U8(uuid_bytes[2]), - serde_test::Token::U8(uuid_bytes[3]), - serde_test::Token::U8(uuid_bytes[4]), - serde_test::Token::U8(uuid_bytes[5]), - serde_test::Token::U8(uuid_bytes[6]), - serde_test::Token::U8(uuid_bytes[7]), - serde_test::Token::U8(uuid_bytes[8]), - serde_test::Token::U8(uuid_bytes[9]), - serde_test::Token::U8(uuid_bytes[10]), - serde_test::Token::U8(uuid_bytes[11]), - serde_test::Token::U8(uuid_bytes[12]), - serde_test::Token::U8(uuid_bytes[13]), - serde_test::Token::U8(uuid_bytes[14]), - serde_test::Token::U8(uuid_bytes[15]), - serde_test::Token::TupleEnd, - ], - ); - } - - #[test] - fn test_deserialize_readable_bytes() { - let uuid_bytes = b"F9168C5E-CEB2-4F"; - let u = Uuid::from_slice(uuid_bytes).unwrap(); - - serde_test::assert_de_tokens(&u.readable(), &[serde_test::Token::Bytes(uuid_bytes)]); - } - - #[test] - fn test_serialize_hyphenated() { - let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4"; - let u = Uuid::parse_str(uuid_str).unwrap(); - serde_test::assert_ser_tokens(&u.hyphenated(), &[Token::Str(uuid_str)]); - } - - #[test] - fn test_serialize_simple() { - let uuid_str = "f9168c5eceb24faab6bf329bf39fa1e4"; - let u = Uuid::parse_str(uuid_str).unwrap(); - serde_test::assert_ser_tokens(&u.simple(), &[Token::Str(uuid_str)]); - } - - #[test] - fn test_serialize_urn() { - let uuid_str = "urn:uuid:f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4"; - let u = Uuid::parse_str(uuid_str).unwrap(); - serde_test::assert_ser_tokens(&u.urn(), &[Token::Str(uuid_str)]); - } - - #[test] - fn test_serialize_braced() { - let uuid_str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}"; - let u = Uuid::parse_str(uuid_str).unwrap(); - serde_test::assert_ser_tokens(&u.braced(), &[Token::Str(uuid_str)]); - } - - #[test] - fn test_serialize_non_human_readable() { - let uuid_bytes = b"F9168C5E-CEB2-4F"; - let u = Uuid::from_slice(uuid_bytes).unwrap(); - serde_test::assert_tokens( - &u.compact(), - &[serde_test::Token::Bytes(&[ - 70, 57, 49, 54, 56, 67, 53, 69, 45, 67, 69, 66, 50, 45, 52, 70, - ])], - ); - } - - #[test] - fn test_de_failure() { - serde_test::assert_de_tokens_error::>( - &[Token::Str("hello_world")], - "UUID parsing failed: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `h` at 1", - ); - - serde_test::assert_de_tokens_error::>( - &[Token::Bytes(b"hello_world")], - "UUID parsing failed: invalid length: expected 16 bytes, found 11", - ); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/external/slog_support.rs b/fixtures/nextest-tests/vendor/uuid/src/external/slog_support.rs deleted file mode 100644 index 2d6e817ba22..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/external/slog_support.rs +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. -// Copyright 2018 The Uuid Project Developers. -// -// See the COPYRIGHT file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use crate::Uuid; - -impl slog::Value for Uuid { - fn serialize( - &self, - _: &slog::Record<'_>, - key: slog::Key, - serializer: &mut dyn slog::Serializer, - ) -> Result<(), slog::Error> { - serializer.emit_arguments(key, &format_args!("{}", self)) - } -} - -#[cfg(test)] -mod tests { - use crate::tests::new; - - use slog::{self, crit, Drain}; - - #[test] - fn test_slog_kv() { - let root = slog::Logger::root(slog::Discard.fuse(), slog::o!()); - let u1 = new(); - crit!(root, "test"; "u1" => u1); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/fmt.rs b/fixtures/nextest-tests/vendor/uuid/src/fmt.rs deleted file mode 100644 index cd7a112aede..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/fmt.rs +++ /dev/null @@ -1,1038 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. -// Copyright 2018 The Uuid Project Developers. -// -// See the COPYRIGHT file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Adapters for alternative string formats. - -use crate::{ - std::{borrow::Borrow, fmt, ptr, str}, - Uuid, Variant, -}; - -impl std::fmt::Debug for Uuid { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt::LowerHex::fmt(self, f) - } -} - -impl fmt::Display for Uuid { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt::LowerHex::fmt(self, f) - } -} - -impl fmt::Display for Variant { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match *self { - Variant::NCS => write!(f, "NCS"), - Variant::RFC4122 => write!(f, "RFC4122"), - Variant::Microsoft => write!(f, "Microsoft"), - Variant::Future => write!(f, "Future"), - } - } -} - -impl fmt::LowerHex for Uuid { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - if f.alternate() { - fmt::LowerHex::fmt(self.as_simple(), f) - } else { - fmt::LowerHex::fmt(self.as_hyphenated(), f) - } - } -} - -impl fmt::UpperHex for Uuid { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - if f.alternate() { - fmt::UpperHex::fmt(self.as_simple(), f) - } else { - fmt::UpperHex::fmt(self.as_hyphenated(), f) - } - } -} - -/// Format a [`Uuid`] as a hyphenated string, like -/// `67e55044-10b1-426f-9247-bb680e5fe0c8`. -#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] -#[repr(transparent)] -pub struct Hyphenated(Uuid); - -/// Format a [`Uuid`] as a simple string, like -/// `67e5504410b1426f9247bb680e5fe0c8`. -#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] -#[repr(transparent)] -pub struct Simple(Uuid); - -/// Format a [`Uuid`] as a URN string, like -/// `urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8`. -#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] -#[repr(transparent)] -pub struct Urn(Uuid); - -/// Format a [`Uuid`] as a braced hyphenated string, like -/// `{67e55044-10b1-426f-9247-bb680e5fe0c8}`. -#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] -#[repr(transparent)] -pub struct Braced(Uuid); - -impl Uuid { - /// Get a [`Hyphenated`] formatter. - #[inline] - pub const fn hyphenated(self) -> Hyphenated { - Hyphenated(self) - } - - /// Get a borrowed [`Hyphenated`] formatter. - #[inline] - pub fn as_hyphenated(&self) -> &Hyphenated { - // SAFETY: `Uuid` and `Hyphenated` have the same ABI - unsafe { &*(self as *const Uuid as *const Hyphenated) } - } - - /// Get a [`Simple`] formatter. - #[inline] - pub const fn simple(self) -> Simple { - Simple(self) - } - - /// Get a borrowed [`Simple`] formatter. - #[inline] - pub fn as_simple(&self) -> &Simple { - // SAFETY: `Uuid` and `Simple` have the same ABI - unsafe { &*(self as *const Uuid as *const Simple) } - } - - /// Get a [`Urn`] formatter. - #[inline] - pub const fn urn(self) -> Urn { - Urn(self) - } - - /// Get a borrowed [`Urn`] formatter. - #[inline] - pub fn as_urn(&self) -> &Urn { - // SAFETY: `Uuid` and `Urn` have the same ABI - unsafe { &*(self as *const Uuid as *const Urn) } - } - - /// Get a [`Braced`] formatter. - #[inline] - pub const fn braced(self) -> Braced { - Braced(self) - } - - /// Get a borrowed [`Braced`] formatter. - #[inline] - pub fn as_braced(&self) -> &Braced { - // SAFETY: `Uuid` and `Braced` have the same ABI - unsafe { &*(self as *const Uuid as *const Braced) } - } -} - -const UPPER: [u8; 16] = [ - b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'A', b'B', b'C', b'D', b'E', b'F', -]; -const LOWER: [u8; 16] = [ - b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'a', b'b', b'c', b'd', b'e', b'f', -]; - -#[inline] -const fn format_simple(src: &[u8; 16], upper: bool) -> [u8; 32] { - let lut = if upper { &UPPER } else { &LOWER }; - let mut dst = [0; 32]; - let mut i = 0; - while i < 16 { - let x = src[i]; - dst[i * 2] = lut[(x >> 4) as usize]; - dst[i * 2 + 1] = lut[(x & 0x0f) as usize]; - i += 1; - } - dst -} - -#[inline] -const fn format_hyphenated(src: &[u8; 16], upper: bool) -> [u8; 36] { - let lut = if upper { &UPPER } else { &LOWER }; - let groups = [(0, 8), (9, 13), (14, 18), (19, 23), (24, 36)]; - let mut dst = [0; 36]; - - let mut group_idx = 0; - let mut i = 0; - while group_idx < 5 { - let (start, end) = groups[group_idx]; - let mut j = start; - while j < end { - let x = src[i]; - i += 1; - - dst[j] = lut[(x >> 4) as usize]; - dst[j + 1] = lut[(x & 0x0f) as usize]; - j += 2; - } - if group_idx < 4 { - dst[end] = b'-'; - } - group_idx += 1; - } - dst -} - -#[inline] -fn encode_simple<'b>(src: &[u8; 16], buffer: &'b mut [u8], upper: bool) -> &'b mut str { - let buf = &mut buffer[..Simple::LENGTH]; - let dst = buf.as_mut_ptr(); - - // SAFETY: `buf` is guaranteed to be at least `LEN` bytes - // SAFETY: The encoded buffer is ASCII encoded - unsafe { - ptr::write(dst.cast(), format_simple(src, upper)); - str::from_utf8_unchecked_mut(buf) - } -} - -#[inline] -fn encode_hyphenated<'b>(src: &[u8; 16], buffer: &'b mut [u8], upper: bool) -> &'b mut str { - let buf = &mut buffer[..Hyphenated::LENGTH]; - let dst = buf.as_mut_ptr(); - - // SAFETY: `buf` is guaranteed to be at least `LEN` bytes - // SAFETY: The encoded buffer is ASCII encoded - unsafe { - ptr::write(dst.cast(), format_hyphenated(src, upper)); - str::from_utf8_unchecked_mut(buf) - } -} - -#[inline] -fn encode_braced<'b>(src: &[u8; 16], buffer: &'b mut [u8], upper: bool) -> &'b mut str { - let buf = &mut buffer[..Braced::LENGTH]; - buf[0] = b'{'; - buf[Braced::LENGTH - 1] = b'}'; - - // SAFETY: `buf` is guaranteed to be at least `LEN` bytes - // SAFETY: The encoded buffer is ASCII encoded - unsafe { - let dst = buf.as_mut_ptr().add(1); - - ptr::write(dst.cast(), format_hyphenated(src, upper)); - str::from_utf8_unchecked_mut(buf) - } -} - -#[inline] -fn encode_urn<'b>(src: &[u8; 16], buffer: &'b mut [u8], upper: bool) -> &'b mut str { - let buf = &mut buffer[..Urn::LENGTH]; - buf[..9].copy_from_slice(b"urn:uuid:"); - - // SAFETY: `buf` is guaranteed to be at least `LEN` bytes - // SAFETY: The encoded buffer is ASCII encoded - unsafe { - let dst = buf.as_mut_ptr().add(9); - - ptr::write(dst.cast(), format_hyphenated(src, upper)); - str::from_utf8_unchecked_mut(buf) - } -} - -impl Hyphenated { - /// The length of a hyphenated [`Uuid`] string. - /// - /// [`Uuid`]: ../struct.Uuid.html - pub const LENGTH: usize = 36; - - /// Creates a [`Hyphenated`] from a [`Uuid`]. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// [`Hyphenated`]: struct.Hyphenated.html - pub const fn from_uuid(uuid: Uuid) -> Self { - Hyphenated(uuid) - } - - /// Writes the [`Uuid`] as a lower-case hyphenated string to - /// `buffer`, and returns the subslice of the buffer that contains the - /// encoded UUID. - /// - /// This is slightly more efficient than using the formatting - /// infrastructure as it avoids virtual calls, and may avoid - /// double buffering. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// - /// # Panics - /// - /// Panics if the buffer is not large enough: it must have length at least - /// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a - /// sufficiently-large temporary buffer. - /// - /// [`LENGTH`]: #associatedconstant.LENGTH - /// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8")?; - /// - /// // the encoded portion is returned - /// assert_eq!( - /// uuid.hyphenated() - /// .encode_lower(&mut Uuid::encode_buffer()), - /// "936da01f-9abd-4d9d-80c7-02af85c822a8" - /// ); - /// - /// // the buffer is mutated directly, and trailing contents remains - /// let mut buf = [b'!'; 40]; - /// uuid.hyphenated().encode_lower(&mut buf); - /// assert_eq!( - /// &buf as &[_], - /// b"936da01f-9abd-4d9d-80c7-02af85c822a8!!!!" as &[_] - /// ); - /// - /// Ok(()) - /// } - /// ``` - /// */ - #[inline] - pub fn encode_lower<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str { - encode_hyphenated(self.0.as_bytes(), buffer, false) - } - - /// Writes the [`Uuid`] as an upper-case hyphenated string to - /// `buffer`, and returns the subslice of the buffer that contains the - /// encoded UUID. - /// - /// This is slightly more efficient than using the formatting - /// infrastructure as it avoids virtual calls, and may avoid - /// double buffering. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// - /// # Panics - /// - /// Panics if the buffer is not large enough: it must have length at least - /// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a - /// sufficiently-large temporary buffer. - /// - /// [`LENGTH`]: #associatedconstant.LENGTH - /// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8")?; - /// - /// // the encoded portion is returned - /// assert_eq!( - /// uuid.hyphenated() - /// .encode_upper(&mut Uuid::encode_buffer()), - /// "936DA01F-9ABD-4D9D-80C7-02AF85C822A8" - /// ); - /// - /// // the buffer is mutated directly, and trailing contents remains - /// let mut buf = [b'!'; 40]; - /// uuid.hyphenated().encode_upper(&mut buf); - /// assert_eq!( - /// &buf as &[_], - /// b"936DA01F-9ABD-4D9D-80C7-02AF85C822A8!!!!" as &[_] - /// ); - /// - /// Ok(()) - /// } - /// ``` - /// */ - #[inline] - pub fn encode_upper<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str { - encode_hyphenated(self.0.as_bytes(), buffer, true) - } - - /// Get a reference to the underlying [`Uuid`]. - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// let hyphenated = Uuid::nil().hyphenated(); - /// assert_eq!(*hyphenated.as_uuid(), Uuid::nil()); - /// ``` - pub const fn as_uuid(&self) -> &Uuid { - &self.0 - } - - /// Consumes the [`Hyphenated`], returning the underlying [`Uuid`]. - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// let hyphenated = Uuid::nil().hyphenated(); - /// assert_eq!(hyphenated.into_uuid(), Uuid::nil()); - /// ``` - pub const fn into_uuid(self) -> Uuid { - self.0 - } -} - -impl Braced { - /// The length of a braced [`Uuid`] string. - /// - /// [`Uuid`]: ../struct.Uuid.html - pub const LENGTH: usize = 38; - - /// Creates a [`Braced`] from a [`Uuid`]. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// [`Braced`]: struct.Braced.html - pub const fn from_uuid(uuid: Uuid) -> Self { - Braced(uuid) - } - - /// Writes the [`Uuid`] as a lower-case hyphenated string surrounded by - /// braces to `buffer`, and returns the subslice of the buffer that contains - /// the encoded UUID. - /// - /// This is slightly more efficient than using the formatting - /// infrastructure as it avoids virtual calls, and may avoid - /// double buffering. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// - /// # Panics - /// - /// Panics if the buffer is not large enough: it must have length at least - /// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a - /// sufficiently-large temporary buffer. - /// - /// [`LENGTH`]: #associatedconstant.LENGTH - /// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8")?; - /// - /// // the encoded portion is returned - /// assert_eq!( - /// uuid.braced() - /// .encode_lower(&mut Uuid::encode_buffer()), - /// "{936da01f-9abd-4d9d-80c7-02af85c822a8}" - /// ); - /// - /// // the buffer is mutated directly, and trailing contents remains - /// let mut buf = [b'!'; 40]; - /// uuid.braced().encode_lower(&mut buf); - /// assert_eq!( - /// &buf as &[_], - /// b"{936da01f-9abd-4d9d-80c7-02af85c822a8}!!" as &[_] - /// ); - /// - /// Ok(()) - /// } - /// ``` - /// */ - #[inline] - pub fn encode_lower<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str { - encode_braced(self.0.as_bytes(), buffer, false) - } - - /// Writes the [`Uuid`] as an upper-case hyphenated string surrounded by - /// braces to `buffer`, and returns the subslice of the buffer that contains - /// the encoded UUID. - /// - /// This is slightly more efficient than using the formatting - /// infrastructure as it avoids virtual calls, and may avoid - /// double buffering. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// - /// # Panics - /// - /// Panics if the buffer is not large enough: it must have length at least - /// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a - /// sufficiently-large temporary buffer. - /// - /// [`LENGTH`]: #associatedconstant.LENGTH - /// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8")?; - /// - /// // the encoded portion is returned - /// assert_eq!( - /// uuid.braced() - /// .encode_upper(&mut Uuid::encode_buffer()), - /// "{936DA01F-9ABD-4D9D-80C7-02AF85C822A8}" - /// ); - /// - /// // the buffer is mutated directly, and trailing contents remains - /// let mut buf = [b'!'; 40]; - /// uuid.braced().encode_upper(&mut buf); - /// assert_eq!( - /// &buf as &[_], - /// b"{936DA01F-9ABD-4D9D-80C7-02AF85C822A8}!!" as &[_] - /// ); - /// - /// Ok(()) - /// } - /// ``` - /// */ - #[inline] - pub fn encode_upper<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str { - encode_braced(self.0.as_bytes(), buffer, true) - } - - /// Get a reference to the underlying [`Uuid`]. - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// let braced = Uuid::nil().braced(); - /// assert_eq!(*braced.as_uuid(), Uuid::nil()); - /// ``` - pub const fn as_uuid(&self) -> &Uuid { - &self.0 - } - - /// Consumes the [`Braced`], returning the underlying [`Uuid`]. - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// let braced = Uuid::nil().braced(); - /// assert_eq!(braced.into_uuid(), Uuid::nil()); - /// ``` - pub const fn into_uuid(self) -> Uuid { - self.0 - } -} - -impl Simple { - /// The length of a simple [`Uuid`] string. - /// - /// [`Uuid`]: ../struct.Uuid.html - pub const LENGTH: usize = 32; - - /// Creates a [`Simple`] from a [`Uuid`]. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// [`Simple`]: struct.Simple.html - pub const fn from_uuid(uuid: Uuid) -> Self { - Simple(uuid) - } - - /// Writes the [`Uuid`] as a lower-case simple string to `buffer`, - /// and returns the subslice of the buffer that contains the encoded UUID. - /// - /// This is slightly more efficient than using the formatting - /// infrastructure as it avoids virtual calls, and may avoid - /// double buffering. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// - /// # Panics - /// - /// Panics if the buffer is not large enough: it must have length at least - /// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a - /// sufficiently-large temporary buffer. - /// - /// [`LENGTH`]: #associatedconstant.LENGTH - /// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8")?; - /// - /// // the encoded portion is returned - /// assert_eq!( - /// uuid.simple().encode_lower(&mut Uuid::encode_buffer()), - /// "936da01f9abd4d9d80c702af85c822a8" - /// ); - /// - /// // the buffer is mutated directly, and trailing contents remains - /// let mut buf = [b'!'; 36]; - /// assert_eq!( - /// uuid.simple().encode_lower(&mut buf), - /// "936da01f9abd4d9d80c702af85c822a8" - /// ); - /// assert_eq!( - /// &buf as &[_], - /// b"936da01f9abd4d9d80c702af85c822a8!!!!" as &[_] - /// ); - /// - /// Ok(()) - /// } - /// ``` - /// */ - #[inline] - pub fn encode_lower<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str { - encode_simple(self.0.as_bytes(), buffer, false) - } - - /// Writes the [`Uuid`] as an upper-case simple string to `buffer`, - /// and returns the subslice of the buffer that contains the encoded UUID. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// - /// # Panics - /// - /// Panics if the buffer is not large enough: it must have length at least - /// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a - /// sufficiently-large temporary buffer. - /// - /// [`LENGTH`]: #associatedconstant.LENGTH - /// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8")?; - /// - /// // the encoded portion is returned - /// assert_eq!( - /// uuid.simple().encode_upper(&mut Uuid::encode_buffer()), - /// "936DA01F9ABD4D9D80C702AF85C822A8" - /// ); - /// - /// // the buffer is mutated directly, and trailing contents remains - /// let mut buf = [b'!'; 36]; - /// assert_eq!( - /// uuid.simple().encode_upper(&mut buf), - /// "936DA01F9ABD4D9D80C702AF85C822A8" - /// ); - /// assert_eq!( - /// &buf as &[_], - /// b"936DA01F9ABD4D9D80C702AF85C822A8!!!!" as &[_] - /// ); - /// - /// Ok(()) - /// } - /// ``` - /// */ - #[inline] - pub fn encode_upper<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str { - encode_simple(self.0.as_bytes(), buffer, true) - } - - /// Get a reference to the underlying [`Uuid`]. - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// let simple = Uuid::nil().simple(); - /// assert_eq!(*simple.as_uuid(), Uuid::nil()); - /// ``` - pub const fn as_uuid(&self) -> &Uuid { - &self.0 - } - - /// Consumes the [`Simple`], returning the underlying [`Uuid`]. - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// let simple = Uuid::nil().simple(); - /// assert_eq!(simple.into_uuid(), Uuid::nil()); - /// ``` - pub const fn into_uuid(self) -> Uuid { - self.0 - } -} - -impl Urn { - /// The length of a URN [`Uuid`] string. - /// - /// [`Uuid`]: ../struct.Uuid.html - pub const LENGTH: usize = 45; - - /// Creates a [`Urn`] from a [`Uuid`]. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// [`Urn`]: struct.Urn.html - pub const fn from_uuid(uuid: Uuid) -> Self { - Urn(uuid) - } - - /// Writes the [`Uuid`] as a lower-case URN string to - /// `buffer`, and returns the subslice of the buffer that contains the - /// encoded UUID. - /// - /// This is slightly more efficient than using the formatting - /// infrastructure as it avoids virtual calls, and may avoid - /// double buffering. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// - /// # Panics - /// - /// Panics if the buffer is not large enough: it must have length at least - /// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a - /// sufficiently-large temporary buffer. - /// - /// [`LENGTH`]: #associatedconstant.LENGTH - /// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8")?; - /// - /// // the encoded portion is returned - /// assert_eq!( - /// uuid.urn().encode_lower(&mut Uuid::encode_buffer()), - /// "urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8" - /// ); - /// - /// // the buffer is mutated directly, and trailing contents remains - /// let mut buf = [b'!'; 49]; - /// uuid.urn().encode_lower(&mut buf); - /// assert_eq!( - /// uuid.urn().encode_lower(&mut buf), - /// "urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8" - /// ); - /// assert_eq!( - /// &buf as &[_], - /// b"urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8!!!!" as &[_] - /// ); - /// - /// Ok(()) - /// } - /// ``` - /// */ - #[inline] - pub fn encode_lower<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str { - encode_urn(self.0.as_bytes(), buffer, false) - } - - /// Writes the [`Uuid`] as an upper-case URN string to - /// `buffer`, and returns the subslice of the buffer that contains the - /// encoded UUID. - /// - /// This is slightly more efficient than using the formatting - /// infrastructure as it avoids virtual calls, and may avoid - /// double buffering. - /// - /// [`Uuid`]: ../struct.Uuid.html - /// - /// # Panics - /// - /// Panics if the buffer is not large enough: it must have length at least - /// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a - /// sufficiently-large temporary buffer. - /// - /// [`LENGTH`]: #associatedconstant.LENGTH - /// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8")?; - /// - /// // the encoded portion is returned - /// assert_eq!( - /// uuid.urn().encode_upper(&mut Uuid::encode_buffer()), - /// "urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8" - /// ); - /// - /// // the buffer is mutated directly, and trailing contents remains - /// let mut buf = [b'!'; 49]; - /// assert_eq!( - /// uuid.urn().encode_upper(&mut buf), - /// "urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8" - /// ); - /// assert_eq!( - /// &buf as &[_], - /// b"urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8!!!!" as &[_] - /// ); - /// - /// Ok(()) - /// } - /// ``` - /// */ - #[inline] - pub fn encode_upper<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str { - encode_urn(self.0.as_bytes(), buffer, true) - } - - /// Get a reference to the underlying [`Uuid`]. - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// let urn = Uuid::nil().urn(); - /// assert_eq!(*urn.as_uuid(), Uuid::nil()); - /// ``` - pub const fn as_uuid(&self) -> &Uuid { - &self.0 - } - - /// Consumes the [`Urn`], returning the underlying [`Uuid`]. - /// - /// # Examples - /// - /// ```rust - /// use uuid::Uuid; - /// - /// let urn = Uuid::nil().urn(); - /// assert_eq!(urn.into_uuid(), Uuid::nil()); - /// ``` - pub const fn into_uuid(self) -> Uuid { - self.0 - } -} - -macro_rules! impl_fmt_traits { - ($($T:ident<$($a:lifetime),*>),+) => {$( - impl<$($a),*> fmt::Display for $T<$($a),*> { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt::LowerHex::fmt(self, f) - } - } - - impl<$($a),*> fmt::LowerHex for $T<$($a),*> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(self.encode_lower(&mut [0; Self::LENGTH])) - } - } - - impl<$($a),*> fmt::UpperHex for $T<$($a),*> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(self.encode_upper(&mut [0; Self::LENGTH])) - } - } - - impl_fmt_from!($T<$($a),*>); - )+} -} - -macro_rules! impl_fmt_from { - ($T:ident<>) => { - impl From for $T { - #[inline] - fn from(f: Uuid) -> Self { - $T(f) - } - } - - impl From<$T> for Uuid { - #[inline] - fn from(f: $T) -> Self { - f.into_uuid() - } - } - - impl AsRef for $T { - #[inline] - fn as_ref(&self) -> &Uuid { - &self.0 - } - } - - impl Borrow for $T { - #[inline] - fn borrow(&self) -> &Uuid { - &self.0 - } - } - }; - ($T:ident<$a:lifetime>) => { - impl<$a> From<&$a Uuid> for $T<$a> { - #[inline] - fn from(f: &$a Uuid) -> Self { - $T::from_uuid_ref(f) - } - } - - impl<$a> From<$T<$a>> for &$a Uuid { - #[inline] - fn from(f: $T<$a>) -> &$a Uuid { - f.0 - } - } - - impl<$a> AsRef for $T<$a> { - #[inline] - fn as_ref(&self) -> &Uuid { - self.0 - } - } - - impl<$a> Borrow for $T<$a> { - #[inline] - fn borrow(&self) -> &Uuid { - self.0 - } - } - }; -} - -impl_fmt_traits! { - Hyphenated<>, - Simple<>, - Urn<>, - Braced<> -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn hyphenated_trailing() { - let mut buf = [b'x'; 100]; - let len = Uuid::nil().hyphenated().encode_lower(&mut buf).len(); - assert_eq!(len, super::Hyphenated::LENGTH); - assert!(buf[len..].iter().all(|x| *x == b'x')); - } - - #[test] - fn hyphenated_ref_trailing() { - let mut buf = [b'x'; 100]; - let len = Uuid::nil().as_hyphenated().encode_lower(&mut buf).len(); - assert_eq!(len, super::Hyphenated::LENGTH); - assert!(buf[len..].iter().all(|x| *x == b'x')); - } - - #[test] - fn simple_trailing() { - let mut buf = [b'x'; 100]; - let len = Uuid::nil().simple().encode_lower(&mut buf).len(); - assert_eq!(len, super::Simple::LENGTH); - assert!(buf[len..].iter().all(|x| *x == b'x')); - } - - #[test] - fn simple_ref_trailing() { - let mut buf = [b'x'; 100]; - let len = Uuid::nil().as_simple().encode_lower(&mut buf).len(); - assert_eq!(len, super::Simple::LENGTH); - assert!(buf[len..].iter().all(|x| *x == b'x')); - } - - #[test] - fn urn_trailing() { - let mut buf = [b'x'; 100]; - let len = Uuid::nil().urn().encode_lower(&mut buf).len(); - assert_eq!(len, super::Urn::LENGTH); - assert!(buf[len..].iter().all(|x| *x == b'x')); - } - - #[test] - fn urn_ref_trailing() { - let mut buf = [b'x'; 100]; - let len = Uuid::nil().as_urn().encode_lower(&mut buf).len(); - assert_eq!(len, super::Urn::LENGTH); - assert!(buf[len..].iter().all(|x| *x == b'x')); - } - - #[test] - fn braced_trailing() { - let mut buf = [b'x'; 100]; - let len = Uuid::nil().braced().encode_lower(&mut buf).len(); - assert_eq!(len, super::Braced::LENGTH); - assert!(buf[len..].iter().all(|x| *x == b'x')); - } - - #[test] - fn braced_ref_trailing() { - let mut buf = [b'x'; 100]; - let len = Uuid::nil().as_braced().encode_lower(&mut buf).len(); - assert_eq!(len, super::Braced::LENGTH); - assert!(buf[len..].iter().all(|x| *x == b'x')); - } - - #[test] - #[should_panic] - fn hyphenated_too_small() { - Uuid::nil().hyphenated().encode_lower(&mut [0; 35]); - } - - #[test] - #[should_panic] - fn simple_too_small() { - Uuid::nil().simple().encode_lower(&mut [0; 31]); - } - - #[test] - #[should_panic] - fn urn_too_small() { - Uuid::nil().urn().encode_lower(&mut [0; 44]); - } - - #[test] - #[should_panic] - fn braced_too_small() { - Uuid::nil().braced().encode_lower(&mut [0; 37]); - } - - #[test] - fn hyphenated_to_inner() { - let hyphenated = Uuid::nil().hyphenated(); - assert_eq!(Uuid::from(hyphenated), Uuid::nil()); - } - - #[test] - fn simple_to_inner() { - let simple = Uuid::nil().simple(); - assert_eq!(Uuid::from(simple), Uuid::nil()); - } - - #[test] - fn urn_to_inner() { - let urn = Uuid::nil().urn(); - assert_eq!(Uuid::from(urn), Uuid::nil()); - } - - #[test] - fn braced_to_inner() { - let braced = Uuid::nil().braced(); - assert_eq!(Uuid::from(braced), Uuid::nil()); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/lib.rs b/fixtures/nextest-tests/vendor/uuid/src/lib.rs deleted file mode 100644 index 190827ca6a7..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/lib.rs +++ /dev/null @@ -1,1549 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. -// Copyright 2018 The Uuid Project Developers. -// -// See the COPYRIGHT file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Generate and parse universally unique identifiers (UUIDs). -//! -//! Here's an example of a UUID: -//! -//! ```text -//! 67e55044-10b1-426f-9247-bb680e5fe0c8 -//! ``` -//! -//! A UUID is a unique 128-bit value, stored as 16 octets, and regularly -//! formatted as a hex string in five groups. UUIDs are used to assign unique -//! identifiers to entities without requiring a central allocating authority. -//! -//! They are particularly useful in distributed systems, though can be used in -//! disparate areas, such as databases and network protocols. Typically a UUID -//! is displayed in a readable string form as a sequence of hexadecimal digits, -//! separated into groups by hyphens. -//! -//! The uniqueness property is not strictly guaranteed, however for all -//! practical purposes, it can be assumed that an unintentional collision would -//! be extremely unlikely. -//! -//! UUIDs have a number of standardized encodings that are specified in [RFC4122](http://tools.ietf.org/html/rfc4122), -//! with recent additions [in draft](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04). -//! -//! # Getting started -//! -//! Add the following to your `Cargo.toml`: -//! -//! ```toml -//! [dependencies.uuid] -//! version = "1.2.1" -//! features = [ -//! "v4", # Lets you generate random UUIDs -//! "fast-rng", # Use a faster (but still sufficiently random) RNG -//! "macro-diagnostics", # Enable better diagnostics for compile-time UUIDs -//! ] -//! ``` -//! -//! When you want a UUID, you can generate one: -//! -//! ``` -//! # fn main() { -//! # #[cfg(feature = "v4")] -//! # { -//! use uuid::Uuid; -//! -//! let id = Uuid::new_v4(); -//! # } -//! # } -//! ``` -//! -//! If you have a UUID value, you can use its string literal form inline: -//! -//! ``` -//! use uuid::{uuid, Uuid}; -//! -//! const ID: Uuid = uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"); -//! ``` -//! -//! # Working with different UUID versions -//! -//! This library supports all standardized methods for generating UUIDs through individual Cargo features. -//! -//! By default, this crate depends on nothing but the Rust standard library and can parse and format -//! UUIDs, but cannot generate them. Depending on the kind of UUID you'd like to work with, there -//! are Cargo features that enable generating them: -//! -//! * `v1` - Version 1 UUIDs using a timestamp and monotonic counter. -//! * `v3` - Version 3 UUIDs based on the MD5 hash of some data. -//! * `v4` - Version 4 UUIDs with random data. -//! * `v5` - Version 5 UUIDs based on the SHA1 hash of some data. -//! -//! Versions that are in draft are also supported. See the _unstable features_ section for details. -//! -//! This library also includes a [`Builder`] type that can be used to help construct UUIDs of any -//! version without any additional dependencies or features. It's a lower-level API than [`Uuid`] -//! that can be used when you need control over implicit requirements on things like a source -//! of randomness. -//! -//! ## Which UUID version should I use? -//! -//! If you just want to generate unique identifiers then consider version 4 (`v4`) UUIDs. If you want -//! to use UUIDs as database keys or need to sort them then consider version 7 (`v7`) UUIDs. -//! Other versions should generally be avoided unless there's an existing need for them. -//! -//! Some UUID versions supersede others. Prefer version 6 over version 1 and version 5 over version 3. -//! -//! # Other features -//! -//! Other crate features can also be useful beyond the version support: -//! -//! * `macro-diagnostics` - enhances the diagnostics of `uuid!` macro. -//! * `serde` - adds the ability to serialize and deserialize a UUID using -//! `serde`. -//! * `arbitrary` - adds an `Arbitrary` trait implementation to `Uuid` for -//! fuzzing. -//! * `fast-rng` - uses a faster algorithm for generating random UUIDs. -//! This feature requires more dependencies to compile, but is just as suitable for -//! UUIDs as the default algorithm. -//! -//! # Unstable features -//! -//! Some features are unstable. They may be incomplete or depend on other -//! unstable libraries. These include: -//! -//! * `v6` - Version 6 UUIDs using a timestamp and monotonic counter. -//! * `v7` - Version 7 UUIDs using a Unix timestamp. -//! * `v8` - Version 8 UUIDs using user-defined data. -//! * `zerocopy` - adds support for zero-copy deserialization using the -//! `zerocopy` library. -//! -//! Unstable features may break between minor releases. -//! -//! To allow unstable features, you'll need to enable the Cargo feature as -//! normal, but also pass an additional flag through your environment to opt-in -//! to unstable `uuid` features: -//! -//! ```text -//! RUSTFLAGS="--cfg uuid_unstable" -//! ``` -//! -//! # Building for other targets -//! -//! ## WebAssembly -//! -//! For WebAssembly, enable the `js` feature: -//! -//! ```toml -//! [dependencies.uuid] -//! version = "1.2.1" -//! features = [ -//! "v4", -//! "v7", -//! "js", -//! ] -//! ``` -//! -//! ## Embedded -//! -//! For embedded targets without the standard library, you'll need to -//! disable default features when building `uuid`: -//! -//! ```toml -//! [dependencies.uuid] -//! version = "1.2.1" -//! default-features = false -//! ``` -//! -//! Some additional features are supported in no-std environments: -//! -//! * `v1`, `v3`, `v5`, `v6`, and `v8`. -//! * `serde`. -//! -//! If you need to use `v4` or `v7` in a no-std environment, you'll need to -//! follow [`getrandom`'s docs] on configuring a source of randomness -//! on currently unsupported targets. Alternatively, you can produce -//! random bytes yourself and then pass them to [`Builder::from_random_bytes`] -//! without enabling the `v4` feature. -//! -//! # Examples -//! -//! Parse a UUID given in the simple format and print it as a URN: -//! -//! ``` -//! # use uuid::Uuid; -//! # fn main() -> Result<(), uuid::Error> { -//! let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?; -//! -//! println!("{}", my_uuid.urn()); -//! # Ok(()) -//! # } -//! ``` -//! -//! Generate a random UUID and print it out in hexadecimal form: -//! -//! ``` -//! // Note that this requires the `v4` feature to be enabled. -//! # use uuid::Uuid; -//! # fn main() { -//! # #[cfg(feature = "v4")] { -//! let my_uuid = Uuid::new_v4(); -//! -//! println!("{}", my_uuid); -//! # } -//! # } -//! ``` -//! -//! # References -//! -//! * [Wikipedia: Universally Unique Identifier](http://en.wikipedia.org/wiki/Universally_unique_identifier) -//! * [RFC4122: A Universally Unique Identifier (UUID) URN Namespace](http://tools.ietf.org/html/rfc4122) -//! * [Draft RFC: New UUID Formats, Version 4](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04) -//! -//! [`wasm-bindgen`]: https://crates.io/crates/wasm-bindgen -//! [`cargo-web`]: https://crates.io/crates/cargo-web -//! [`getrandom`'s docs]: https://docs.rs/getrandom - -#![no_std] -#![deny(missing_debug_implementations, missing_docs)] -#![doc( - html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", - html_favicon_url = "https://www.rust-lang.org/favicon.ico", - html_root_url = "https://docs.rs/uuid/1.2.1" -)] - -#[cfg(any(feature = "std", test))] -#[macro_use] -extern crate std; - -#[cfg(all(not(feature = "std"), not(test)))] -#[macro_use] -extern crate core as std; - -#[cfg(all(uuid_unstable, feature = "zerocopy"))] -use zerocopy::{AsBytes, FromBytes, Unaligned}; - -mod builder; -mod error; -mod parser; - -pub mod fmt; -pub mod timestamp; - -pub use timestamp::{context::NoContext, ClockSequence, Timestamp}; - -#[cfg(any(feature = "v1", feature = "v6"))] -pub use timestamp::context::Context; - -#[cfg(feature = "v1")] -#[doc(hidden)] -// Soft-deprecated (Rust doesn't support deprecating re-exports) -// Use `Context` from the crate root instead -pub mod v1; -#[cfg(feature = "v3")] -mod v3; -#[cfg(feature = "v4")] -mod v4; -#[cfg(feature = "v5")] -mod v5; -#[cfg(all(uuid_unstable, feature = "v6"))] -mod v6; -#[cfg(all(uuid_unstable, feature = "v7"))] -mod v7; -#[cfg(all(uuid_unstable, feature = "v8"))] -mod v8; - -#[cfg(feature = "md5")] -mod md5; -#[cfg(feature = "rng")] -mod rng; -#[cfg(feature = "sha1")] -mod sha1; - -mod external; - -#[macro_use] -mod macros; - -extern crate alloc; -#[doc(hidden)] -#[cfg(feature = "macro-diagnostics")] -pub extern crate uuid_macro_internal; - -use crate::std::convert; - -pub use crate::{builder::Builder, error::Error}; - -/// A 128-bit (16 byte) buffer containing the UUID. -/// -/// # ABI -/// -/// The `Bytes` type is always guaranteed to be have the same ABI as [`Uuid`]. -pub type Bytes = [u8; 16]; - -/// The version of the UUID, denoting the generating algorithm. -/// -/// # References -/// -/// * [Version in RFC4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3) -#[derive(Clone, Copy, Debug, PartialEq)] -#[non_exhaustive] -#[repr(u8)] -pub enum Version { - /// The "nil" (all zeros) UUID. - Nil = 0u8, - /// Version 1: Timestamp and node ID. - Mac = 1, - /// Version 2: DCE Security. - Dce = 2, - /// Version 3: MD5 hash. - Md5 = 3, - /// Version 4: Random. - Random = 4, - /// Version 5: SHA-1 hash. - Sha1 = 5, - /// Version 6: Sortable Timestamp and node ID. - #[cfg(uuid_unstable)] - SortMac = 6, - /// Version 7: Timestamp and random. - #[cfg(uuid_unstable)] - SortRand = 7, - /// Version 8: Custom. - #[cfg(uuid_unstable)] - Custom = 8, - /// The "max" (all ones) UUID. - #[cfg(uuid_unstable)] - Max = 0xff, -} - -/// The reserved variants of UUIDs. -/// -/// # References -/// -/// * [Variant in RFC4122](http://tools.ietf.org/html/rfc4122#section-4.1.1) -#[derive(Clone, Copy, Debug, PartialEq)] -#[non_exhaustive] -#[repr(u8)] -pub enum Variant { - /// Reserved by the NCS for backward compatibility. - NCS = 0u8, - /// As described in the RFC4122 Specification (default). - RFC4122, - /// Reserved by Microsoft for backward compatibility. - Microsoft, - /// Reserved for future expansion. - Future, -} - -/// A Universally Unique Identifier (UUID). -/// -/// # Examples -/// -/// Parse a UUID given in the simple format and print it as a urn: -/// -/// ``` -/// # use uuid::Uuid; -/// # fn main() -> Result<(), uuid::Error> { -/// let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?; -/// -/// println!("{}", my_uuid.urn()); -/// # Ok(()) -/// # } -/// ``` -/// -/// Create a new random (V4) UUID and print it out in hexadecimal form: -/// -/// ``` -/// // Note that this requires the `v4` feature enabled in the uuid crate. -/// # use uuid::Uuid; -/// # fn main() { -/// # #[cfg(feature = "v4")] { -/// let my_uuid = Uuid::new_v4(); -/// -/// println!("{}", my_uuid); -/// # } -/// # } -/// ``` -/// -/// # Formatting -/// -/// A UUID can be formatted in one of a few ways: -/// -/// * [`simple`](#method.simple): `a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8`. -/// * [`hyphenated`](#method.hyphenated): -/// `a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8`. -/// * [`urn`](#method.urn): `urn:uuid:A1A2A3A4-B1B2-C1C2-D1D2-D3D4D5D6D7D8`. -/// * [`braced`](#method.braced): `{a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8}`. -/// -/// The default representation when formatting a UUID with `Display` is -/// hyphenated: -/// -/// ``` -/// # use uuid::Uuid; -/// # fn main() -> Result<(), uuid::Error> { -/// let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?; -/// -/// assert_eq!( -/// "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", -/// my_uuid.to_string(), -/// ); -/// # Ok(()) -/// # } -/// ``` -/// -/// Other formats can be specified using adapter methods on the UUID: -/// -/// ``` -/// # use uuid::Uuid; -/// # fn main() -> Result<(), uuid::Error> { -/// let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?; -/// -/// assert_eq!( -/// "urn:uuid:a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", -/// my_uuid.urn().to_string(), -/// ); -/// # Ok(()) -/// # } -/// ``` -/// -/// # Endianness -/// -/// The specification for UUIDs encodes the integer fields that make up the -/// value in big-endian order. This crate assumes integer inputs are already in -/// the correct order by default, regardless of the endianness of the -/// environment. Most methods that accept integers have a `_le` variant (such as -/// `from_fields_le`) that assumes any integer values will need to have their -/// bytes flipped, regardless of the endianness of the environment. -/// -/// Most users won't need to worry about endianness unless they need to operate -/// on individual fields (such as when converting between Microsoft GUIDs). The -/// important things to remember are: -/// -/// - The endianness is in terms of the fields of the UUID, not the environment. -/// - The endianness is assumed to be big-endian when there's no `_le` suffix -/// somewhere. -/// - Byte-flipping in `_le` methods applies to each integer. -/// - Endianness roundtrips, so if you create a UUID with `from_fields_le` -/// you'll get the same values back out with `to_fields_le`. -/// -/// # ABI -/// -/// The `Uuid` type is always guaranteed to be have the same ABI as [`Bytes`]. -#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)] -#[cfg_attr(all(uuid_unstable, feature = "zerocopy"), derive(AsBytes, FromBytes, Unaligned))] -#[repr(transparent)] -pub struct Uuid(Bytes); - -impl Uuid { - /// UUID namespace for Domain Name System (DNS). - pub const NAMESPACE_DNS: Self = Uuid([ - 0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, - 0xc8, - ]); - - /// UUID namespace for ISO Object Identifiers (OIDs). - pub const NAMESPACE_OID: Self = Uuid([ - 0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, - 0xc8, - ]); - - /// UUID namespace for Uniform Resource Locators (URLs). - pub const NAMESPACE_URL: Self = Uuid([ - 0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, - 0xc8, - ]); - - /// UUID namespace for X.500 Distinguished Names (DNs). - pub const NAMESPACE_X500: Self = Uuid([ - 0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, - 0xc8, - ]); - - /// Returns the variant of the UUID structure. - /// - /// This determines the interpretation of the structure of the UUID. - /// This method simply reads the value of the variant byte. It doesn't - /// validate the rest of the UUID as conforming to that variant. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::{Uuid, Variant}; - /// # fn main() -> Result<(), uuid::Error> { - /// let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?; - /// - /// assert_eq!(Variant::RFC4122, my_uuid.get_variant()); - /// # Ok(()) - /// # } - /// ``` - /// - /// # References - /// - /// * [Variant in RFC4122](http://tools.ietf.org/html/rfc4122#section-4.1.1) - pub const fn get_variant(&self) -> Variant { - match self.as_bytes()[8] { - x if x & 0x80 == 0x00 => Variant::NCS, - x if x & 0xc0 == 0x80 => Variant::RFC4122, - x if x & 0xe0 == 0xc0 => Variant::Microsoft, - x if x & 0xe0 == 0xe0 => Variant::Future, - // The above match arms are actually exhaustive - // We just return `Future` here because we can't - // use `unreachable!()` in a `const fn` - _ => Variant::Future, - } - } - - /// Returns the version number of the UUID. - /// - /// This represents the algorithm used to generate the value. - /// This method is the future-proof alternative to [`Uuid::get_version`]. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::Uuid; - /// # fn main() -> Result<(), uuid::Error> { - /// let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?; - /// - /// assert_eq!(3, my_uuid.get_version_num()); - /// # Ok(()) - /// # } - /// ``` - /// - /// # References - /// - /// * [Version in RFC4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3) - pub const fn get_version_num(&self) -> usize { - (self.as_bytes()[6] >> 4) as usize - } - - /// Returns the version of the UUID. - /// - /// This represents the algorithm used to generate the value. - /// If the version field doesn't contain a recognized version then `None` - /// is returned. If you're trying to read the version for a future extension - /// you can also use [`Uuid::get_version_num`] to unconditionally return a - /// number. Future extensions may start to return `Some` once they're - /// standardized and supported. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::{Uuid, Version}; - /// # fn main() -> Result<(), uuid::Error> { - /// let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?; - /// - /// assert_eq!(Some(Version::Md5), my_uuid.get_version()); - /// # Ok(()) - /// # } - /// ``` - /// - /// # References - /// - /// * [Version in RFC4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3) - pub const fn get_version(&self) -> Option { - match self.get_version_num() { - 0 if self.is_nil() => Some(Version::Nil), - 1 => Some(Version::Mac), - 2 => Some(Version::Dce), - 3 => Some(Version::Md5), - 4 => Some(Version::Random), - 5 => Some(Version::Sha1), - #[cfg(uuid_unstable)] - 6 => Some(Version::SortMac), - #[cfg(uuid_unstable)] - 7 => Some(Version::SortRand), - #[cfg(uuid_unstable)] - 8 => Some(Version::Custom), - #[cfg(uuid_unstable)] - 0xf => Some(Version::Max), - _ => None, - } - } - - /// Returns the four field values of the UUID. - /// - /// These values can be passed to the [`Uuid::from_fields`] method to get - /// the original `Uuid` back. - /// - /// * The first field value represents the first group of (eight) hex - /// digits, taken as a big-endian `u32` value. For V1 UUIDs, this field - /// represents the low 32 bits of the timestamp. - /// * The second field value represents the second group of (four) hex - /// digits, taken as a big-endian `u16` value. For V1 UUIDs, this field - /// represents the middle 16 bits of the timestamp. - /// * The third field value represents the third group of (four) hex digits, - /// taken as a big-endian `u16` value. The 4 most significant bits give - /// the UUID version, and for V1 UUIDs, the last 12 bits represent the - /// high 12 bits of the timestamp. - /// * The last field value represents the last two groups of four and twelve - /// hex digits, taken in order. The first 1-3 bits of this indicate the - /// UUID variant, and for V1 UUIDs, the next 13-15 bits indicate the clock - /// sequence and the last 48 bits indicate the node ID. - /// - /// # Examples - /// - /// ``` - /// # use uuid::Uuid; - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::nil(); - /// - /// assert_eq!(uuid.as_fields(), (0, 0, 0, &[0u8; 8])); - /// - /// let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?; - /// - /// assert_eq!( - /// uuid.as_fields(), - /// ( - /// 0xa1a2a3a4, - /// 0xb1b2, - /// 0xc1c2, - /// &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8], - /// ) - /// ); - /// # Ok(()) - /// # } - /// ``` - pub fn as_fields(&self) -> (u32, u16, u16, &[u8; 8]) { - let bytes = self.as_bytes(); - - let d1 = (bytes[0] as u32) << 24 - | (bytes[1] as u32) << 16 - | (bytes[2] as u32) << 8 - | (bytes[3] as u32); - - let d2 = (bytes[4] as u16) << 8 | (bytes[5] as u16); - - let d3 = (bytes[6] as u16) << 8 | (bytes[7] as u16); - - let d4: &[u8; 8] = convert::TryInto::try_into(&bytes[8..16]).unwrap(); - (d1, d2, d3, d4) - } - - /// Returns the four field values of the UUID in little-endian order. - /// - /// The bytes in the returned integer fields will be converted from - /// big-endian order. This is based on the endianness of the UUID, - /// rather than the target environment so bytes will be flipped on both - /// big and little endian machines. - /// - /// # Examples - /// - /// ``` - /// use uuid::Uuid; - /// - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?; - /// - /// assert_eq!( - /// uuid.to_fields_le(), - /// ( - /// 0xa4a3a2a1, - /// 0xb2b1, - /// 0xc2c1, - /// &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8], - /// ) - /// ); - /// # Ok(()) - /// # } - /// ``` - pub fn to_fields_le(&self) -> (u32, u16, u16, &[u8; 8]) { - let d1 = (self.as_bytes()[0] as u32) - | (self.as_bytes()[1] as u32) << 8 - | (self.as_bytes()[2] as u32) << 16 - | (self.as_bytes()[3] as u32) << 24; - - let d2 = (self.as_bytes()[4] as u16) | (self.as_bytes()[5] as u16) << 8; - - let d3 = (self.as_bytes()[6] as u16) | (self.as_bytes()[7] as u16) << 8; - - let d4: &[u8; 8] = convert::TryInto::try_into(&self.as_bytes()[8..16]).unwrap(); - (d1, d2, d3, d4) - } - - /// Returns a 128bit value containing the value. - /// - /// The bytes in the UUID will be packed directly into a `u128`. - /// - /// # Examples - /// - /// ``` - /// # use uuid::Uuid; - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?; - /// - /// assert_eq!( - /// uuid.as_u128(), - /// 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8, - /// ); - /// # Ok(()) - /// # } - /// ``` - pub const fn as_u128(&self) -> u128 { - (self.as_bytes()[0] as u128) << 120 - | (self.as_bytes()[1] as u128) << 112 - | (self.as_bytes()[2] as u128) << 104 - | (self.as_bytes()[3] as u128) << 96 - | (self.as_bytes()[4] as u128) << 88 - | (self.as_bytes()[5] as u128) << 80 - | (self.as_bytes()[6] as u128) << 72 - | (self.as_bytes()[7] as u128) << 64 - | (self.as_bytes()[8] as u128) << 56 - | (self.as_bytes()[9] as u128) << 48 - | (self.as_bytes()[10] as u128) << 40 - | (self.as_bytes()[11] as u128) << 32 - | (self.as_bytes()[12] as u128) << 24 - | (self.as_bytes()[13] as u128) << 16 - | (self.as_bytes()[14] as u128) << 8 - | (self.as_bytes()[15] as u128) - } - - /// Returns a 128bit little-endian value containing the value. - /// - /// The bytes in the `u128` will be flipped to convert into big-endian - /// order. This is based on the endianness of the UUID, rather than the - /// target environment so bytes will be flipped on both big and little - /// endian machines. - /// - /// Note that this will produce a different result than - /// [`Uuid::to_fields_le`], because the entire UUID is reversed, rather - /// than reversing the individual fields in-place. - /// - /// # Examples - /// - /// ``` - /// # use uuid::Uuid; - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?; - /// - /// assert_eq!( - /// uuid.to_u128_le(), - /// 0xd8d7d6d5d4d3d2d1c2c1b2b1a4a3a2a1, - /// ); - /// # Ok(()) - /// # } - /// ``` - pub const fn to_u128_le(&self) -> u128 { - (self.as_bytes()[0] as u128) - | (self.as_bytes()[1] as u128) << 8 - | (self.as_bytes()[2] as u128) << 16 - | (self.as_bytes()[3] as u128) << 24 - | (self.as_bytes()[4] as u128) << 32 - | (self.as_bytes()[5] as u128) << 40 - | (self.as_bytes()[6] as u128) << 48 - | (self.as_bytes()[7] as u128) << 56 - | (self.as_bytes()[8] as u128) << 64 - | (self.as_bytes()[9] as u128) << 72 - | (self.as_bytes()[10] as u128) << 80 - | (self.as_bytes()[11] as u128) << 88 - | (self.as_bytes()[12] as u128) << 96 - | (self.as_bytes()[13] as u128) << 104 - | (self.as_bytes()[14] as u128) << 112 - | (self.as_bytes()[15] as u128) << 120 - } - - /// Returns two 64bit values containing the value. - /// - /// The bytes in the UUID will be split into two `u64`. - /// The first u64 represents the 64 most significant bits, - /// the second one represents the 64 least significant. - /// - /// # Examples - /// - /// ``` - /// # use uuid::Uuid; - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?; - /// assert_eq!( - /// uuid.as_u64_pair(), - /// (0xa1a2a3a4b1b2c1c2, 0xd1d2d3d4d5d6d7d8), - /// ); - /// # Ok(()) - /// # } - /// ``` - pub const fn as_u64_pair(&self) -> (u64, u64) { - let value = self.as_u128(); - ((value >> 64) as u64, value as u64) - } - - /// Returns a slice of 16 octets containing the value. - /// - /// This method borrows the underlying byte value of the UUID. - /// - /// # Examples - /// - /// ``` - /// # use uuid::Uuid; - /// let bytes1 = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// let uuid1 = Uuid::from_bytes_ref(&bytes1); - /// - /// let bytes2 = uuid1.as_bytes(); - /// let uuid2 = Uuid::from_bytes_ref(bytes2); - /// - /// assert_eq!(uuid1, uuid2); - /// - /// assert!(std::ptr::eq( - /// uuid2 as *const Uuid as *const u8, - /// &bytes1 as *const [u8; 16] as *const u8, - /// )); - /// ``` - pub const fn as_bytes(&self) -> &Bytes { - &self.0 - } - - /// Consumes self and returns the underlying byte value of the UUID. - /// - /// # Examples - /// - /// ``` - /// # use uuid::Uuid; - /// let bytes = [ - /// 0xa1, 0xa2, 0xa3, 0xa4, - /// 0xb1, 0xb2, - /// 0xc1, 0xc2, - /// 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, - /// ]; - /// let uuid = Uuid::from_bytes(bytes); - /// assert_eq!(bytes, uuid.into_bytes()); - /// ``` - pub const fn into_bytes(self) -> Bytes { - self.0 - } - - /// Returns the bytes of the UUID in little-endian order. - /// - /// The bytes will be flipped to convert into little-endian order. This is - /// based on the endianness of the UUID, rather than the target environment - /// so bytes will be flipped on both big and little endian machines. - /// - /// # Examples - /// - /// ``` - /// use uuid::Uuid; - /// - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?; - /// - /// assert_eq!( - /// uuid.to_bytes_le(), - /// ([ - /// 0xa4, 0xa3, 0xa2, 0xa1, 0xb2, 0xb1, 0xc2, 0xc1, 0xd1, 0xd2, - /// 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 - /// ]) - /// ); - /// # Ok(()) - /// # } - /// ``` - pub const fn to_bytes_le(&self) -> Bytes { - [ - self.0[3], self.0[2], self.0[1], self.0[0], self.0[5], self.0[4], self.0[7], self.0[6], - self.0[8], self.0[9], self.0[10], self.0[11], self.0[12], self.0[13], self.0[14], - self.0[15], - ] - } - - /// Tests if the UUID is nil (all zeros). - pub const fn is_nil(&self) -> bool { - self.as_u128() == u128::MIN - } - - /// Tests if the UUID is max (all ones). - #[cfg(uuid_unstable)] - pub const fn is_max(&self) -> bool { - self.as_u128() == u128::MAX - } - - /// A buffer that can be used for `encode_...` calls, that is - /// guaranteed to be long enough for any of the format adapters. - /// - /// # Examples - /// - /// ``` - /// # use uuid::Uuid; - /// let uuid = Uuid::nil(); - /// - /// assert_eq!( - /// uuid.simple().encode_lower(&mut Uuid::encode_buffer()), - /// "00000000000000000000000000000000" - /// ); - /// - /// assert_eq!( - /// uuid.hyphenated() - /// .encode_lower(&mut Uuid::encode_buffer()), - /// "00000000-0000-0000-0000-000000000000" - /// ); - /// - /// assert_eq!( - /// uuid.urn().encode_lower(&mut Uuid::encode_buffer()), - /// "urn:uuid:00000000-0000-0000-0000-000000000000" - /// ); - /// ``` - pub const fn encode_buffer() -> [u8; fmt::Urn::LENGTH] { - [0; fmt::Urn::LENGTH] - } - - /// If the UUID is the correct version (v1, v6, or v7) this will return - /// the timestamp and counter portion parsed from a V1 UUID. - /// - /// Returns `None` if the supplied UUID is not V1. - /// - /// The V1 timestamp format defined in RFC4122 specifies a 60-bit - /// integer representing the number of 100-nanosecond intervals - /// since 00:00:00.00, 15 Oct 1582. - /// - /// [`Timestamp`] offers several options for converting the raw RFC4122 - /// value into more commonly-used formats, such as a unix timestamp. - /// - /// # Roundtripping - /// - /// This method is unlikely to roundtrip a timestamp in a UUID due to the way - /// UUIDs encode timestamps. The timestamp returned from this method will be truncated to - /// 100ns precision for version 1 and 6 UUIDs, and to millisecond precision for version 7 UUIDs. - /// - /// [`Timestamp`]: v1/struct.Timestamp.html - pub const fn get_timestamp(&self) -> Option { - match self.get_version() { - Some(Version::Mac) => { - let (ticks, counter) = timestamp::decode_rfc4122_timestamp(self); - - Some(Timestamp::from_rfc4122(ticks, counter)) - } - #[cfg(uuid_unstable)] - Some(Version::SortMac) => { - let (ticks, counter) = timestamp::decode_sorted_rfc4122_timestamp(self); - - Some(Timestamp::from_rfc4122(ticks, counter)) - } - #[cfg(uuid_unstable)] - Some(Version::SortRand) => { - let millis = timestamp::decode_unix_timestamp_millis(self); - - let seconds = millis / 1000; - let nanos = ((millis % 1000) * 1_000_000) as u32; - - Some(Timestamp { - seconds, - nanos, - #[cfg(any(feature = "v1", feature = "v6"))] - counter: 0, - }) - } - _ => None, - } - } -} - -impl Default for Uuid { - #[inline] - fn default() -> Self { - Uuid::nil() - } -} - -impl AsRef<[u8]> for Uuid { - #[inline] - fn as_ref(&self) -> &[u8] { - &self.0 - } -} - -#[cfg(feature = "serde")] -pub mod serde { - //! Adapters for alternative `serde` formats. - //! - //! This module contains adapters you can use with [`#[serde(with)]`](https://serde.rs/field-attrs.html#with) - //! to change the way a [`Uuid`](../struct.Uuid.html) is serialized - //! and deserialized. - - pub use crate::external::serde_support::compact; -} - -#[cfg(test)] -mod tests { - use super::*; - - use crate::std::string::{String, ToString}; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - - macro_rules! check { - ($buf:ident, $format:expr, $target:expr, $len:expr, $cond:expr) => { - $buf.clear(); - write!($buf, $format, $target).unwrap(); - assert!($buf.len() == $len); - assert!($buf.chars().all($cond), "{}", $buf); - }; - } - - pub const fn new() -> Uuid { - Uuid::from_bytes([ - 0xF9, 0x16, 0x8C, 0x5E, 0xCE, 0xB2, 0x4F, 0xAA, 0xB6, 0xBF, 0x32, 0x9B, 0xF3, 0x9F, - 0xA1, 0xE4, - ]) - } - - pub const fn new2() -> Uuid { - Uuid::from_bytes([ - 0xF9, 0x16, 0x8C, 0x5E, 0xCE, 0xB2, 0x4F, 0xAB, 0xB6, 0xBF, 0x32, 0x9B, 0xF3, 0x9F, - 0xA1, 0xE4, - ]) - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_uuid_compare() { - let uuid1 = new(); - let uuid2 = new2(); - - assert_eq!(uuid1, uuid1); - assert_eq!(uuid2, uuid2); - - assert_ne!(uuid1, uuid2); - assert_ne!(uuid2, uuid1); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_uuid_default() { - let default_uuid = Uuid::default(); - let nil_uuid = Uuid::nil(); - - assert_eq!(default_uuid, nil_uuid); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_uuid_display() { - use crate::std::fmt::Write; - - let uuid = new(); - let s = uuid.to_string(); - let mut buffer = String::new(); - - assert_eq!(s, uuid.hyphenated().to_string()); - - check!(buffer, "{}", uuid, 36, |c| c.is_lowercase() - || c.is_digit(10) - || c == '-'); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_uuid_lowerhex() { - use crate::std::fmt::Write; - - let mut buffer = String::new(); - let uuid = new(); - - check!(buffer, "{:x}", uuid, 36, |c| c.is_lowercase() - || c.is_digit(10) - || c == '-'); - } - - // noinspection RsAssertEqual - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_uuid_operator_eq() { - let uuid1 = new(); - let uuid1_dup = uuid1.clone(); - let uuid2 = new2(); - - assert!(uuid1 == uuid1); - assert!(uuid1 == uuid1_dup); - assert!(uuid1_dup == uuid1); - - assert!(uuid1 != uuid2); - assert!(uuid2 != uuid1); - assert!(uuid1_dup != uuid2); - assert!(uuid2 != uuid1_dup); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_uuid_to_string() { - use crate::std::fmt::Write; - - let uuid = new(); - let s = uuid.to_string(); - let mut buffer = String::new(); - - assert_eq!(s.len(), 36); - - check!(buffer, "{}", s, 36, |c| c.is_lowercase() - || c.is_digit(10) - || c == '-'); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_non_conforming() { - let from_bytes = - Uuid::from_bytes([4, 54, 67, 12, 43, 2, 2, 76, 32, 50, 87, 5, 1, 33, 43, 87]); - - assert_eq!(from_bytes.get_version(), None); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_nil() { - let nil = Uuid::nil(); - let not_nil = new(); - - assert!(nil.is_nil()); - assert!(!not_nil.is_nil()); - - assert_eq!(nil.get_version(), Some(Version::Nil)); - assert_eq!(not_nil.get_version(), Some(Version::Random)); - - assert_eq!(nil, Builder::from_bytes([0; 16]).with_version(Version::Nil).into_uuid()); - } - - #[test] - #[cfg(uuid_unstable)] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_max() { - let max = Uuid::max(); - let not_max = new(); - - assert!(max.is_max()); - assert!(!not_max.is_max()); - - assert_eq!(max.get_version(), Some(Version::Max)); - assert_eq!(not_max.get_version(), Some(Version::Random)); - - assert_eq!(max, Builder::from_bytes([0xff; 16]).with_version(Version::Max).into_uuid()); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_predefined_namespaces() { - assert_eq!( - Uuid::NAMESPACE_DNS.hyphenated().to_string(), - "6ba7b810-9dad-11d1-80b4-00c04fd430c8" - ); - assert_eq!( - Uuid::NAMESPACE_URL.hyphenated().to_string(), - "6ba7b811-9dad-11d1-80b4-00c04fd430c8" - ); - assert_eq!( - Uuid::NAMESPACE_OID.hyphenated().to_string(), - "6ba7b812-9dad-11d1-80b4-00c04fd430c8" - ); - assert_eq!( - Uuid::NAMESPACE_X500.hyphenated().to_string(), - "6ba7b814-9dad-11d1-80b4-00c04fd430c8" - ); - } - - #[cfg(feature = "v3")] - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_get_version_v3() { - let uuid = Uuid::new_v3(&Uuid::NAMESPACE_DNS, "rust-lang.org".as_bytes()); - - assert_eq!(uuid.get_version().unwrap(), Version::Md5); - assert_eq!(uuid.get_version_num(), 3); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_get_variant() { - let uuid1 = new(); - let uuid2 = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap(); - let uuid3 = Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8").unwrap(); - let uuid4 = Uuid::parse_str("936DA01F9ABD4d9dC0C702AF85C822A8").unwrap(); - let uuid5 = Uuid::parse_str("F9168C5E-CEB2-4faa-D6BF-329BF39FA1E4").unwrap(); - let uuid6 = Uuid::parse_str("f81d4fae-7dec-11d0-7765-00a0c91e6bf6").unwrap(); - - assert_eq!(uuid1.get_variant(), Variant::RFC4122); - assert_eq!(uuid2.get_variant(), Variant::RFC4122); - assert_eq!(uuid3.get_variant(), Variant::RFC4122); - assert_eq!(uuid4.get_variant(), Variant::Microsoft); - assert_eq!(uuid5.get_variant(), Variant::Microsoft); - assert_eq!(uuid6.get_variant(), Variant::NCS); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_to_simple_string() { - let uuid1 = new(); - let s = uuid1.simple().to_string(); - - assert_eq!(s.len(), 32); - assert!(s.chars().all(|c| c.is_digit(16))); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_hyphenated_string() { - let uuid1 = new(); - let s = uuid1.hyphenated().to_string(); - - assert_eq!(36, s.len()); - assert!(s.chars().all(|c| c.is_digit(16) || c == '-')); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_upper_lower_hex() { - use std::fmt::Write; - - let mut buf = String::new(); - let u = new(); - - macro_rules! check { - ($buf:ident, $format:expr, $target:expr, $len:expr, $cond:expr) => { - $buf.clear(); - write!($buf, $format, $target).unwrap(); - assert_eq!($len, buf.len()); - assert!($buf.chars().all($cond), "{}", $buf); - }; - } - - check!(buf, "{:x}", u, 36, |c| c.is_lowercase() - || c.is_digit(10) - || c == '-'); - check!(buf, "{:X}", u, 36, |c| c.is_uppercase() - || c.is_digit(10) - || c == '-'); - check!(buf, "{:#x}", u, 32, |c| c.is_lowercase() || c.is_digit(10)); - check!(buf, "{:#X}", u, 32, |c| c.is_uppercase() || c.is_digit(10)); - - check!(buf, "{:X}", u.hyphenated(), 36, |c| c.is_uppercase() - || c.is_digit(10) - || c == '-'); - check!(buf, "{:X}", u.simple(), 32, |c| c.is_uppercase() - || c.is_digit(10)); - check!(buf, "{:#X}", u.hyphenated(), 36, |c| c.is_uppercase() - || c.is_digit(10) - || c == '-'); - check!(buf, "{:#X}", u.simple(), 32, |c| c.is_uppercase() - || c.is_digit(10)); - - check!(buf, "{:x}", u.hyphenated(), 36, |c| c.is_lowercase() - || c.is_digit(10) - || c == '-'); - check!(buf, "{:x}", u.simple(), 32, |c| c.is_lowercase() - || c.is_digit(10)); - check!(buf, "{:#x}", u.hyphenated(), 36, |c| c.is_lowercase() - || c.is_digit(10) - || c == '-'); - check!(buf, "{:#x}", u.simple(), 32, |c| c.is_lowercase() - || c.is_digit(10)); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_to_urn_string() { - let uuid1 = new(); - let ss = uuid1.urn().to_string(); - let s = &ss[9..]; - - assert!(ss.starts_with("urn:uuid:")); - assert_eq!(s.len(), 36); - assert!(s.chars().all(|c| c.is_digit(16) || c == '-')); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_to_simple_string_matching() { - let uuid1 = new(); - - let hs = uuid1.hyphenated().to_string(); - let ss = uuid1.simple().to_string(); - - let hsn = hs.chars().filter(|&c| c != '-').collect::(); - - assert_eq!(hsn, ss); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_string_roundtrip() { - let uuid = new(); - - let hs = uuid.hyphenated().to_string(); - let uuid_hs = Uuid::parse_str(&hs).unwrap(); - assert_eq!(uuid_hs, uuid); - - let ss = uuid.to_string(); - let uuid_ss = Uuid::parse_str(&ss).unwrap(); - assert_eq!(uuid_ss, uuid); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_from_fields() { - let d1: u32 = 0xa1a2a3a4; - let d2: u16 = 0xb1b2; - let d3: u16 = 0xc1c2; - let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - - let u = Uuid::from_fields(d1, d2, d3, &d4); - - let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"; - let result = u.simple().to_string(); - assert_eq!(result, expected); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_from_fields_le() { - let d1: u32 = 0xa4a3a2a1; - let d2: u16 = 0xb2b1; - let d3: u16 = 0xc2c1; - let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - - let u = Uuid::from_fields_le(d1, d2, d3, &d4); - - let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"; - let result = u.simple().to_string(); - assert_eq!(result, expected); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_as_fields() { - let u = new(); - let (d1, d2, d3, d4) = u.as_fields(); - - assert_ne!(d1, 0); - assert_ne!(d2, 0); - assert_ne!(d3, 0); - assert_eq!(d4.len(), 8); - assert!(!d4.iter().all(|&b| b == 0)); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_fields_roundtrip() { - let d1_in: u32 = 0xa1a2a3a4; - let d2_in: u16 = 0xb1b2; - let d3_in: u16 = 0xc1c2; - let d4_in = &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - - let u = Uuid::from_fields(d1_in, d2_in, d3_in, d4_in); - let (d1_out, d2_out, d3_out, d4_out) = u.as_fields(); - - assert_eq!(d1_in, d1_out); - assert_eq!(d2_in, d2_out); - assert_eq!(d3_in, d3_out); - assert_eq!(d4_in, d4_out); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_fields_le_roundtrip() { - let d1_in: u32 = 0xa4a3a2a1; - let d2_in: u16 = 0xb2b1; - let d3_in: u16 = 0xc2c1; - let d4_in = &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - - let u = Uuid::from_fields_le(d1_in, d2_in, d3_in, d4_in); - let (d1_out, d2_out, d3_out, d4_out) = u.to_fields_le(); - - assert_eq!(d1_in, d1_out); - assert_eq!(d2_in, d2_out); - assert_eq!(d3_in, d3_out); - assert_eq!(d4_in, d4_out); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_fields_le_are_actually_le() { - let d1_in: u32 = 0xa1a2a3a4; - let d2_in: u16 = 0xb1b2; - let d3_in: u16 = 0xc1c2; - let d4_in = &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8]; - - let u = Uuid::from_fields(d1_in, d2_in, d3_in, d4_in); - let (d1_out, d2_out, d3_out, d4_out) = u.to_fields_le(); - - assert_eq!(d1_in, d1_out.swap_bytes()); - assert_eq!(d2_in, d2_out.swap_bytes()); - assert_eq!(d3_in, d3_out.swap_bytes()); - assert_eq!(d4_in, d4_out); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_from_u128() { - let v_in: u128 = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8; - - let u = Uuid::from_u128(v_in); - - let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"; - let result = u.simple().to_string(); - assert_eq!(result, expected); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_from_u128_le() { - let v_in: u128 = 0xd8d7d6d5d4d3d2d1c2c1b2b1a4a3a2a1; - - let u = Uuid::from_u128_le(v_in); - - let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"; - let result = u.simple().to_string(); - assert_eq!(result, expected); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_from_u64_pair() { - let high_in: u64 = 0xa1a2a3a4b1b2c1c2; - let low_in: u64 = 0xd1d2d3d4d5d6d7d8; - - let u = Uuid::from_u64_pair(high_in, low_in); - - let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"; - let result = u.simple().to_string(); - assert_eq!(result, expected); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_u128_roundtrip() { - let v_in: u128 = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8; - - let u = Uuid::from_u128(v_in); - let v_out = u.as_u128(); - - assert_eq!(v_in, v_out); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_u128_le_roundtrip() { - let v_in: u128 = 0xd8d7d6d5d4d3d2d1c2c1b2b1a4a3a2a1; - - let u = Uuid::from_u128_le(v_in); - let v_out = u.to_u128_le(); - - assert_eq!(v_in, v_out); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_u64_pair_roundtrip() { - let high_in: u64 = 0xa1a2a3a4b1b2c1c2; - let low_in: u64 = 0xd1d2d3d4d5d6d7d8; - - let u = Uuid::from_u64_pair(high_in, low_in); - let (high_out, low_out) = u.as_u64_pair(); - - assert_eq!(high_in, high_out); - assert_eq!(low_in, low_out); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_u128_le_is_actually_le() { - let v_in: u128 = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8; - - let u = Uuid::from_u128(v_in); - let v_out = u.to_u128_le(); - - assert_eq!(v_in, v_out.swap_bytes()); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_from_slice() { - let b = [ - 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, - 0xd7, 0xd8, - ]; - - let u = Uuid::from_slice(&b).unwrap(); - let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"; - - assert_eq!(u.simple().to_string(), expected); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_from_bytes() { - let b = [ - 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, - 0xd7, 0xd8, - ]; - - let u = Uuid::from_bytes(b); - let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8"; - - assert_eq!(u.simple().to_string(), expected); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_as_bytes() { - let u = new(); - let ub = u.as_bytes(); - let ur = u.as_ref(); - - assert_eq!(ub.len(), 16); - assert_eq!(ur.len(), 16); - assert!(!ub.iter().all(|&b| b == 0)); - assert!(!ur.iter().all(|&b| b == 0)); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_bytes_roundtrip() { - let b_in: crate::Bytes = [ - 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, - 0xd7, 0xd8, - ]; - - let u = Uuid::from_slice(&b_in).unwrap(); - - let b_out = u.as_bytes(); - - assert_eq!(&b_in, b_out); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_bytes_le_roundtrip() { - let b = [ - 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, - 0xd7, 0xd8, - ]; - - let u1 = Uuid::from_bytes(b); - - let b_le = u1.to_bytes_le(); - - let u2 = Uuid::from_bytes_le(b_le); - - assert_eq!(u1, u2); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_iterbytes_impl_for_uuid() { - let mut set = std::collections::HashSet::new(); - let id1 = new(); - let id2 = new2(); - set.insert(id1.clone()); - - assert!(set.contains(&id1)); - assert!(!set.contains(&id2)); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/macros.rs b/fixtures/nextest-tests/vendor/uuid/src/macros.rs deleted file mode 100644 index de2004863ac..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/macros.rs +++ /dev/null @@ -1,99 +0,0 @@ -macro_rules! define_uuid_macro { - {$(#[$doc:meta])*} => { - $(#[$doc])* - #[cfg(feature = "macro-diagnostics")] - #[macro_export] - macro_rules! uuid { - ($uuid:literal) => {{ - $crate::Uuid::from_bytes($crate::uuid_macro_internal::parse_lit!($uuid)) - }}; - } - - $(#[$doc])* - #[cfg(not(feature = "macro-diagnostics"))] - #[macro_export] - macro_rules! uuid { - ($uuid:literal) => {{ - const OUTPUT: $crate::Uuid = match $crate::Uuid::try_parse($uuid) { - Ok(u) => u, - Err(_) => { - // here triggers const_err - // const_panic requires 1.57 - #[allow(unconditional_panic)] - let _ = ["invalid uuid representation"][1]; - - loop {} // -> never type - } - }; - OUTPUT - }}; - } - } -} - -define_uuid_macro! { -/// Parse [`Uuid`][uuid::Uuid]s from string literals at compile time. -/// -/// ## Usage -/// -/// This macro transforms the string literal representation of a -/// [`Uuid`][uuid::Uuid] into the bytes representation, raising a compilation -/// error if it cannot properly be parsed. -/// -/// ## Examples -/// -/// Setting a global constant: -/// -/// ``` -/// # use uuid::{uuid, Uuid}; -/// pub const SCHEMA_ATTR_CLASS: Uuid = uuid!("00000000-0000-0000-0000-ffff00000000"); -/// pub const SCHEMA_ATTR_UUID: Uuid = uuid!("00000000-0000-0000-0000-ffff00000001"); -/// pub const SCHEMA_ATTR_NAME: Uuid = uuid!("00000000-0000-0000-0000-ffff00000002"); -/// ``` -/// -/// Defining a local variable: -/// -/// ``` -/// # use uuid::uuid; -/// let uuid = uuid!("urn:uuid:F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4"); -/// ``` -/// -/// ## Compilation Failures -/// -/// Invalid UUIDs are rejected: -/// -/// ```compile_fail -/// # use uuid::uuid; -/// let uuid = uuid!("F9168C5E-ZEB2-4FAA-B6BF-329BF39FA1E4"); -/// ``` -/// -/// Enable the feature `macro-diagnostics` to see the error messages below. -/// -/// Provides the following compilation error: -/// -/// ```txt -/// error: invalid character: expected an optional prefix of `urn:uuid:` followed by 0123456789abcdefABCDEF-, found Z at 9 -/// | -/// | let id = uuid!("F9168C5E-ZEB2-4FAA-B6BF-329BF39FA1E4"); -/// | ^ -/// ``` -/// -/// Tokens that aren't string literals are also rejected: -/// -/// ```compile_fail -/// # use uuid::uuid; -/// let uuid_str: &str = "550e8400e29b41d4a716446655440000"; -/// let uuid = uuid!(uuid_str); -/// ``` -/// -/// Provides the following compilation error: -/// -/// ```txt -/// error: expected string literal -/// | -/// | let uuid = uuid!(uuid_str); -/// | ^^^^^^^^ -/// ``` -/// -/// [uuid::Uuid]: https://docs.rs/uuid/*/uuid/struct.Uuid.html -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/md5.rs b/fixtures/nextest-tests/vendor/uuid/src/md5.rs deleted file mode 100644 index fce5d9b8726..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/md5.rs +++ /dev/null @@ -1,14 +0,0 @@ -#[cfg(feature = "v3")] -pub(crate) fn hash(ns: &[u8], src: &[u8]) -> [u8; 16] { - use md_5::{Digest, Md5}; - - let mut hasher = Md5::new(); - - hasher.update(ns); - hasher.update(src); - - let mut bytes = [0; 16]; - bytes.copy_from_slice(&hasher.finalize()[..16]); - - bytes -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/parser.rs b/fixtures/nextest-tests/vendor/uuid/src/parser.rs deleted file mode 100644 index bc5f82638d8..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/parser.rs +++ /dev/null @@ -1,521 +0,0 @@ -// Copyright 2013-2014 The Rust Project Developers. -// Copyright 2018 The Uuid Project Developers. -// -// See the COPYRIGHT file at the top-level directory of this distribution. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! [`Uuid`] parsing constructs and utilities. -//! -//! [`Uuid`]: ../struct.Uuid.html - -use crate::{ - error::*, - std::{convert::TryFrom, str}, - Uuid, -}; - -impl str::FromStr for Uuid { - type Err = Error; - - fn from_str(uuid_str: &str) -> Result { - Uuid::parse_str(uuid_str) - } -} - -impl TryFrom<&'_ str> for Uuid { - type Error = Error; - - fn try_from(uuid_str: &'_ str) -> Result { - Uuid::parse_str(uuid_str) - } -} - -impl Uuid { - /// Parses a `Uuid` from a string of hexadecimal digits with optional - /// hyphens. - /// - /// Any of the formats generated by this module (simple, hyphenated, urn, - /// Microsoft GUID) are supported by this parsing function. - /// - /// Prefer [`try_parse`] unless you need detailed user-facing diagnostics. - /// This method will be eventually deprecated in favor of `try_parse`. - /// - /// # Examples - /// - /// Parse a hyphenated UUID: - /// - /// ``` - /// # use uuid::{Uuid, Version, Variant}; - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")?; - /// - /// assert_eq!(Some(Version::Random), uuid.get_version()); - /// assert_eq!(Variant::RFC4122, uuid.get_variant()); - /// # Ok(()) - /// # } - /// ``` - /// - /// [`try_parse`]: #method.try_parse - pub fn parse_str(input: &str) -> Result { - try_parse(input.as_bytes()) - .map(Uuid::from_bytes) - .map_err(InvalidUuid::into_err) - } - - /// Parses a `Uuid` from a string of hexadecimal digits with optional - /// hyphens. - /// - /// This function is similar to [`parse_str`], in fact `parse_str` shares - /// the same underlying parser. The difference is that if `try_parse` - /// fails, it won't generate very useful error messages. The `parse_str` - /// function will eventually be deprecated in favor or `try_parse`. - /// - /// To parse a UUID from a byte stream instead of a UTF8 string, see - /// [`try_parse_ascii`]. - /// - /// # Examples - /// - /// Parse a hyphenated UUID: - /// - /// ``` - /// # use uuid::{Uuid, Version, Variant}; - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000")?; - /// - /// assert_eq!(Some(Version::Random), uuid.get_version()); - /// assert_eq!(Variant::RFC4122, uuid.get_variant()); - /// # Ok(()) - /// # } - /// ``` - /// - /// [`parse_str`]: #method.parse_str - /// [`try_parse_ascii`]: #method.try_parse_ascii - pub const fn try_parse(input: &str) -> Result { - Self::try_parse_ascii(input.as_bytes()) - } - - /// Parses a `Uuid` from a string of hexadecimal digits with optional - /// hyphens. - /// - /// The input is expected to be a string of ASCII characters. This method - /// can be more convenient than [`try_parse`] if the UUID is being - /// parsed from a byte stream instead of from a UTF8 string. - /// - /// # Examples - /// - /// Parse a hyphenated UUID: - /// - /// ``` - /// # use uuid::{Uuid, Version, Variant}; - /// # fn main() -> Result<(), uuid::Error> { - /// let uuid = Uuid::try_parse_ascii(b"550e8400-e29b-41d4-a716-446655440000")?; - /// - /// assert_eq!(Some(Version::Random), uuid.get_version()); - /// assert_eq!(Variant::RFC4122, uuid.get_variant()); - /// # Ok(()) - /// # } - /// ``` - /// - /// [`try_parse`]: #method.try_parse - pub const fn try_parse_ascii(input: &[u8]) -> Result { - match try_parse(input) { - Ok(bytes) => Ok(Uuid::from_bytes(bytes)), - // If parsing fails then we don't know exactly what went wrong - // In this case, we just return a generic error - Err(_) => Err(Error(ErrorKind::Other)), - } - } -} - -const fn try_parse(input: &[u8]) -> Result<[u8; 16], InvalidUuid> { - let result = match (input.len(), input) { - // Inputs of 32 bytes must be a non-hyphenated UUID - (32, s) => parse_simple(s), - // Hyphenated UUIDs may be wrapped in various ways: - // - `{UUID}` for braced UUIDs - // - `urn:uuid:UUID` for URNs - // - `UUID` for a regular hyphenated UUID - (36, s) - | (38, [b'{', s @ .., b'}']) - | (45, [b'u', b'r', b'n', b':', b'u', b'u', b'i', b'd', b':', s @ ..]) => { - parse_hyphenated(s) - } - // Any other shaped input is immediately invalid - _ => Err(()), - }; - - match result { - Ok(b) => Ok(b), - Err(()) => Err(InvalidUuid(input)), - } -} - -#[inline] -const fn parse_simple(s: &[u8]) -> Result<[u8; 16], ()> { - // This length check here removes all other bounds - // checks in this function - if s.len() != 32 { - return Err(()); - } - - let mut buf: [u8; 16] = [0; 16]; - let mut i = 0; - - while i < 16 { - // Convert a two-char hex value (like `A8`) - // into a byte (like `10101000`) - let h1 = HEX_TABLE[s[i * 2] as usize]; - let h2 = HEX_TABLE[s[i * 2 + 1] as usize]; - - // We use `0xff` as a sentinel value to indicate - // an invalid hex character sequence (like the letter `G`) - if h1 | h2 == 0xff { - return Err(()); - } - - // The upper nibble needs to be shifted into position - // to produce the final byte value - buf[i] = SHL4_TABLE[h1 as usize] | h2; - i += 1; - } - - Ok(buf) -} - -#[inline] -const fn parse_hyphenated(s: &[u8]) -> Result<[u8; 16], ()> { - // This length check here removes all other bounds - // checks in this function - if s.len() != 36 { - return Err(()); - } - - // We look at two hex-encoded values (4 chars) at a time because - // that's the size of the smallest group in a hyphenated UUID. - // The indexes we're interested in are: - // - // uuid : 936da01f-9abd-4d9d-80c7-02af85c822a8 - // | | || || || || | | - // hyphens : | | 8| 13| 18| 23| | | - // positions: 0 4 9 14 19 24 28 32 - - // First, ensure the hyphens appear in the right places - match [s[8], s[13], s[18], s[23]] { - [b'-', b'-', b'-', b'-'] => {} - _ => return Err(()), - } - - let positions: [u8; 8] = [0, 4, 9, 14, 19, 24, 28, 32]; - let mut buf: [u8; 16] = [0; 16]; - let mut j = 0; - - while j < 8 { - let i = positions[j]; - - // The decoding here is the same as the simple case - // We're just dealing with two values instead of one - let h1 = HEX_TABLE[s[i as usize] as usize]; - let h2 = HEX_TABLE[s[(i + 1) as usize] as usize]; - let h3 = HEX_TABLE[s[(i + 2) as usize] as usize]; - let h4 = HEX_TABLE[s[(i + 3) as usize] as usize]; - - if h1 | h2 | h3 | h4 == 0xff { - return Err(()); - } - - buf[j * 2] = SHL4_TABLE[h1 as usize] | h2; - buf[j * 2 + 1] = SHL4_TABLE[h3 as usize] | h4; - j += 1; - } - - Ok(buf) -} - -const HEX_TABLE: &[u8; 256] = &{ - let mut buf = [0; 256]; - let mut i: u8 = 0; - - loop { - buf[i as usize] = match i { - b'0'..=b'9' => i - b'0', - b'a'..=b'f' => i - b'a' + 10, - b'A'..=b'F' => i - b'A' + 10, - _ => 0xff, - }; - - if i == 255 { - break buf; - } - - i += 1 - } -}; - -const SHL4_TABLE: &[u8; 256] = &{ - let mut buf = [0; 256]; - let mut i: u8 = 0; - - loop { - buf[i as usize] = i.wrapping_shl(4); - - if i == 255 { - break buf; - } - - i += 1; - } -}; - -#[cfg(test)] -mod tests { - use super::*; - use crate::{std::string::ToString, tests::new}; - - #[test] - fn test_parse_uuid_v4_valid() { - let from_hyphenated = Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8").unwrap(); - let from_simple = Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c8").unwrap(); - let from_urn = Uuid::parse_str("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8").unwrap(); - let from_guid = Uuid::parse_str("{67e55044-10b1-426f-9247-bb680e5fe0c8}").unwrap(); - - assert_eq!(from_hyphenated, from_simple); - assert_eq!(from_hyphenated, from_urn); - assert_eq!(from_hyphenated, from_guid); - - assert!(Uuid::parse_str("00000000000000000000000000000000").is_ok()); - assert!(Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok()); - assert!(Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").is_ok()); - assert!(Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c8").is_ok()); - assert!(Uuid::parse_str("01020304-1112-2122-3132-414243444546").is_ok()); - assert!(Uuid::parse_str("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok()); - assert!(Uuid::parse_str("{6d93bade-bd9f-4e13-8914-9474e1e3567b}").is_ok()); - - // Nil - let nil = Uuid::nil(); - assert_eq!( - Uuid::parse_str("00000000000000000000000000000000").unwrap(), - nil - ); - assert_eq!( - Uuid::parse_str("00000000-0000-0000-0000-000000000000").unwrap(), - nil - ); - } - - #[test] - fn test_parse_uuid_v4_invalid() { - // Invalid - assert_eq!( - Uuid::parse_str(""), - Err(Error(ErrorKind::SimpleLength { len: 0 })) - ); - - assert_eq!( - Uuid::parse_str("!"), - Err(Error(ErrorKind::Char { - character: '!', - index: 1, - })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E45"), - Err(Error(ErrorKind::GroupLength { - group: 4, - len: 13, - index: 25, - })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4"), - Err(Error(ErrorKind::GroupLength { - group: 3, - len: 3, - index: 20, - })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"), - Err(Error(ErrorKind::Char { - character: 'G', - index: 21, - })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2F4faaFB6BFF329BF39FA1E4"), - Err(Error(ErrorKind::GroupCount { count: 2 })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2-4faaFB6BFF329BF39FA1E4"), - Err(Error(ErrorKind::GroupCount { count: 3 })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4"), - Err(Error(ErrorKind::GroupCount { count: 4 })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2-4faa"), - Err(Error(ErrorKind::GroupCount { count: 3 })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2-4faaXB6BFF329BF39FA1E4"), - Err(Error(ErrorKind::Char { - character: 'X', - index: 19, - })) - ); - - assert_eq!( - Uuid::parse_str("{F9168C5E-CEB2-4faa9B6BFF329BF39FA1E41"), - Err(Error(ErrorKind::Char { - character: '{', - index: 1, - })) - ); - - assert_eq!( - Uuid::parse_str("{F9168C5E-CEB2-4faa9B6BFF329BF39FA1E41}"), - Err(Error(ErrorKind::GroupCount { count: 3 })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB-24fa-eB6BFF32-BF39FA1E4"), - Err(Error(ErrorKind::GroupLength { - group: 1, - len: 3, - index: 10, - })) - ); - - // // (group, found, expecting) - // // - assert_eq!( - Uuid::parse_str("01020304-1112-2122-3132-41424344"), - Err(Error(ErrorKind::GroupLength { - group: 4, - len: 8, - index: 25, - })) - ); - - assert_eq!( - Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c"), - Err(Error(ErrorKind::SimpleLength { len: 31 })) - ); - - assert_eq!( - Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c88"), - Err(Error(ErrorKind::SimpleLength { len: 33 })) - ); - - assert_eq!( - Uuid::parse_str("67e5504410b1426f9247bb680e5fe0cg8"), - Err(Error(ErrorKind::Char { - character: 'g', - index: 32, - })) - ); - - assert_eq!( - Uuid::parse_str("67e5504410b1426%9247bb680e5fe0c8"), - Err(Error(ErrorKind::Char { - character: '%', - index: 16, - })) - ); - - assert_eq!( - Uuid::parse_str("231231212212423424324323477343246663"), - Err(Error(ErrorKind::SimpleLength { len: 36 })) - ); - - assert_eq!( - Uuid::parse_str("{00000000000000000000000000000000}"), - Err(Error(ErrorKind::GroupCount { count: 1 })) - ); - - assert_eq!( - Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c"), - Err(Error(ErrorKind::SimpleLength { len: 31 })) - ); - - assert_eq!( - Uuid::parse_str("67e550X410b1426f9247bb680e5fe0cd"), - Err(Error(ErrorKind::Char { - character: 'X', - index: 7, - })) - ); - - assert_eq!( - Uuid::parse_str("67e550-4105b1426f9247bb680e5fe0c"), - Err(Error(ErrorKind::GroupCount { count: 2 })) - ); - - assert_eq!( - Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4"), - Err(Error(ErrorKind::GroupLength { - group: 3, - len: 5, - index: 20, - })) - ); - } - - #[test] - fn test_roundtrip_default() { - let uuid_orig = new(); - let orig_str = uuid_orig.to_string(); - let uuid_out = Uuid::parse_str(&orig_str).unwrap(); - assert_eq!(uuid_orig, uuid_out); - } - - #[test] - fn test_roundtrip_hyphenated() { - let uuid_orig = new(); - let orig_str = uuid_orig.hyphenated().to_string(); - let uuid_out = Uuid::parse_str(&orig_str).unwrap(); - assert_eq!(uuid_orig, uuid_out); - } - - #[test] - fn test_roundtrip_simple() { - let uuid_orig = new(); - let orig_str = uuid_orig.simple().to_string(); - let uuid_out = Uuid::parse_str(&orig_str).unwrap(); - assert_eq!(uuid_orig, uuid_out); - } - - #[test] - fn test_roundtrip_urn() { - let uuid_orig = new(); - let orig_str = uuid_orig.urn().to_string(); - let uuid_out = Uuid::parse_str(&orig_str).unwrap(); - assert_eq!(uuid_orig, uuid_out); - } - - #[test] - fn test_roundtrip_braced() { - let uuid_orig = new(); - let orig_str = uuid_orig.braced().to_string(); - let uuid_out = Uuid::parse_str(&orig_str).unwrap(); - assert_eq!(uuid_orig, uuid_out); - } - - #[test] - fn test_try_parse_ascii_non_utf8() { - assert!(Uuid::try_parse_ascii(b"67e55044-10b1-426f-9247-bb680e5\0e0c8").is_err()); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/rng.rs b/fixtures/nextest-tests/vendor/uuid/src/rng.rs deleted file mode 100644 index dcfbb8d665c..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/rng.rs +++ /dev/null @@ -1,39 +0,0 @@ -#[cfg(any(feature = "v4", feature = "v7"))] -pub(crate) fn bytes() -> [u8; 16] { - #[cfg(not(feature = "fast-rng"))] - { - let mut bytes = [0u8; 16]; - - getrandom::getrandom(&mut bytes).unwrap_or_else(|err| { - // NB: getrandom::Error has no source; this is adequate display - panic!("could not retrieve random bytes for uuid: {}", err) - }); - - bytes - } - - #[cfg(feature = "fast-rng")] - { - rand::random() - } -} - -#[cfg(any(feature = "v1", feature = "v6"))] -pub(crate) fn u16() -> u16 { - #[cfg(not(feature = "fast-rng"))] - { - let mut bytes = [0u8; 2]; - - getrandom::getrandom(&mut bytes).unwrap_or_else(|err| { - // NB: getrandom::Error has no source; this is adequate display - panic!("could not retrieve random bytes for uuid: {}", err) - }); - - ((bytes[0] as u16) << 8) | (bytes[1] as u16) - } - - #[cfg(feature = "fast-rng")] - { - rand::random() - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/sha1.rs b/fixtures/nextest-tests/vendor/uuid/src/sha1.rs deleted file mode 100644 index 14ca302f280..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/sha1.rs +++ /dev/null @@ -1,14 +0,0 @@ -#[cfg(feature = "v5")] -pub(crate) fn hash(ns: &[u8], src: &[u8]) -> [u8; 16] { - use sha1_smol::Sha1; - - let mut hasher = Sha1::new(); - - hasher.update(ns); - hasher.update(src); - - let mut bytes = [0; 16]; - bytes.copy_from_slice(&hasher.digest().bytes()[..16]); - - bytes -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/timestamp.rs b/fixtures/nextest-tests/vendor/uuid/src/timestamp.rs deleted file mode 100644 index 2f95ac4e930..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/timestamp.rs +++ /dev/null @@ -1,409 +0,0 @@ -//! Generating UUIDs from timestamps. -//! -//! Timestamps are used in a few UUID versions as a source of decentralized -//! uniqueness (as in versions 1 and 6), and as a way to enable sorting (as -//! in versions 6 and 7). Timestamps aren't encoded the same way by all UUID -//! versions so this module provides a single [`Timestamp`] type that can -//! convert between them. -//! -//! # Timestamp representations in UUIDs -//! -//! Versions 1 and 6 UUIDs use a bespoke timestamp that consists of the -//! number of 100ns ticks since `1582-10-15 00:00:00`, along with -//! a counter value to avoid duplicates. -//! -//! Version 7 UUIDs use a more standard timestamp that consists of the -//! number of millisecond ticks since the Unix epoch (`1970-01-01 00:00:00`). -//! -//! # References -//! -//! * [Timestamp in RFC4122](https://www.rfc-editor.org/rfc/rfc4122#section-4.1.4) -//! * [Timestamp in Draft RFC: New UUID Formats, Version 4](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-6.1) - -use crate::Uuid; - -/// The number of 100 nanosecond ticks between the RFC4122 epoch -/// (`1582-10-15 00:00:00`) and the Unix epoch (`1970-01-01 00:00:00`). -pub const UUID_TICKS_BETWEEN_EPOCHS: u64 = 0x01B2_1DD2_1381_4000; - -/// A timestamp that can be encoded into a UUID. -/// -/// This type abstracts the specific encoding, so versions 1, 6, and 7 -/// UUIDs can both be supported through the same type, even -/// though they have a different representation of a timestamp. -/// -/// # References -/// -/// * [Timestamp in RFC4122](https://www.rfc-editor.org/rfc/rfc4122#section-4.1.4) -/// * [Timestamp in Draft RFC: New UUID Formats, Version 4](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-6.1) -/// * [Clock Sequence in RFC4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.5) -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct Timestamp { - pub(crate) seconds: u64, - pub(crate) nanos: u32, - #[cfg(any(feature = "v1", feature = "v6"))] - pub(crate) counter: u16, -} - -impl Timestamp { - /// Get a timestamp representing the current system time. - /// - /// This method defers to the standard library's `SystemTime` type. - /// - /// # Panics - /// - /// This method will panic if calculating the elapsed time since the Unix epoch fails. - #[cfg(feature = "std")] - pub fn now(context: impl ClockSequence) -> Self { - #[cfg(not(any(feature = "v1", feature = "v6")))] - { - let _ = context; - } - - let (seconds, nanos) = now(); - - Timestamp { - seconds, - nanos, - #[cfg(any(feature = "v1", feature = "v6"))] - counter: context.generate_sequence(seconds, nanos), - } - } - - /// Construct a `Timestamp` from an RFC4122 timestamp and counter, as used - /// in versions 1 and 6 UUIDs. - pub const fn from_rfc4122(ticks: u64, counter: u16) -> Self { - #[cfg(not(any(feature = "v1", feature = "v6")))] - { - let _ = counter; - } - - let (seconds, nanos) = Self::rfc4122_to_unix(ticks); - - Timestamp { - seconds, - nanos, - #[cfg(any(feature = "v1", feature = "v6"))] - counter, - } - } - - /// Construct a `Timestamp` from a Unix timestamp, as used in version 7 UUIDs. - pub fn from_unix(context: impl ClockSequence, seconds: u64, nanos: u32) -> Self { - #[cfg(not(any(feature = "v1", feature = "v6")))] - { - let _ = context; - - Timestamp { seconds, nanos } - } - #[cfg(any(feature = "v1", feature = "v6"))] - { - let counter = context.generate_sequence(seconds, nanos); - - Timestamp { - seconds, - nanos, - counter, - } - } - } - - /// Get the value of the timestamp as an RFC4122 timestamp and counter, - /// as used in versions 1 and 6 UUIDs. - #[cfg(any(feature = "v1", feature = "v6"))] - pub const fn to_rfc4122(&self) -> (u64, u16) { - ( - Self::unix_to_rfc4122_ticks(self.seconds, self.nanos), - self.counter, - ) - } - - /// Get the value of the timestamp as a Unix timestamp, as used in version 7 UUIDs. - pub const fn to_unix(&self) -> (u64, u32) { - (self.seconds, self.nanos) - } - - #[cfg(any(feature = "v1", feature = "v6"))] - const fn unix_to_rfc4122_ticks(seconds: u64, nanos: u32) -> u64 { - let ticks = UUID_TICKS_BETWEEN_EPOCHS + seconds * 10_000_000 + nanos as u64 / 100; - - ticks - } - - const fn rfc4122_to_unix(ticks: u64) -> (u64, u32) { - ( - (ticks - UUID_TICKS_BETWEEN_EPOCHS) / 10_000_000, - ((ticks - UUID_TICKS_BETWEEN_EPOCHS) % 10_000_000) as u32 * 100, - ) - } - - #[deprecated(note = "use `to_unix` instead")] - /// Get the number of fractional nanoseconds in the Unix timestamp. - /// - /// This method is deprecated and probably doesn't do what you're expecting it to. - /// It doesn't return the timestamp as nanoseconds since the Unix epoch, it returns - /// the fractional seconds of the timestamp. - pub const fn to_unix_nanos(&self) -> u32 { - // NOTE: This method never did what it said on the tin: instead of - // converting the timestamp into nanos it simply returned the nanoseconds - // part of the timestamp. - // - // We can't fix the behavior because the return type is too small to fit - // a useful value for nanoseconds since the epoch. - self.nanos - } -} - -pub(crate) const fn encode_rfc4122_timestamp(ticks: u64, counter: u16, node_id: &[u8; 6]) -> Uuid { - let time_low = (ticks & 0xFFFF_FFFF) as u32; - let time_mid = ((ticks >> 32) & 0xFFFF) as u16; - let time_high_and_version = (((ticks >> 48) & 0x0FFF) as u16) | (1 << 12); - - let mut d4 = [0; 8]; - - d4[0] = (((counter & 0x3F00) >> 8) as u8) | 0x80; - d4[1] = (counter & 0xFF) as u8; - d4[2] = node_id[0]; - d4[3] = node_id[1]; - d4[4] = node_id[2]; - d4[5] = node_id[3]; - d4[6] = node_id[4]; - d4[7] = node_id[5]; - - Uuid::from_fields(time_low, time_mid, time_high_and_version, &d4) -} - -pub(crate) const fn decode_rfc4122_timestamp(uuid: &Uuid) -> (u64, u16) { - let bytes = uuid.as_bytes(); - - let ticks: u64 = ((bytes[6] & 0x0F) as u64) << 56 - | (bytes[7] as u64) << 48 - | (bytes[4] as u64) << 40 - | (bytes[5] as u64) << 32 - | (bytes[0] as u64) << 24 - | (bytes[1] as u64) << 16 - | (bytes[2] as u64) << 8 - | (bytes[3] as u64); - - let counter: u16 = ((bytes[8] & 0x3F) as u16) << 8 | (bytes[9] as u16); - - (ticks, counter) -} - -#[cfg(uuid_unstable)] -pub(crate) const fn encode_sorted_rfc4122_timestamp( - ticks: u64, - counter: u16, - node_id: &[u8; 6], -) -> Uuid { - let time_high = ((ticks >> 28) & 0xFFFF_FFFF) as u32; - let time_mid = ((ticks >> 12) & 0xFFFF) as u16; - let time_low_and_version = ((ticks & 0x0FFF) as u16) | (0x6 << 12); - - let mut d4 = [0; 8]; - - d4[0] = (((counter & 0x3F00) >> 8) as u8) | 0x80; - d4[1] = (counter & 0xFF) as u8; - d4[2] = node_id[0]; - d4[3] = node_id[1]; - d4[4] = node_id[2]; - d4[5] = node_id[3]; - d4[6] = node_id[4]; - d4[7] = node_id[5]; - - Uuid::from_fields(time_high, time_mid, time_low_and_version, &d4) -} - -#[cfg(uuid_unstable)] -pub(crate) const fn decode_sorted_rfc4122_timestamp(uuid: &Uuid) -> (u64, u16) { - let bytes = uuid.as_bytes(); - - let ticks: u64 = ((bytes[0]) as u64) << 52 - | (bytes[1] as u64) << 44 - | (bytes[2] as u64) << 36 - | (bytes[3] as u64) << 28 - | (bytes[4] as u64) << 20 - | (bytes[5] as u64) << 12 - | ((bytes[6] & 0xF) as u64) << 8 - | (bytes[7] as u64); - - let counter: u16 = ((bytes[8] & 0x3F) as u16) << 8 | (bytes[9] as u16); - - (ticks, counter) -} - -#[cfg(uuid_unstable)] -pub(crate) const fn encode_unix_timestamp_millis(millis: u64, random_bytes: &[u8; 10]) -> Uuid { - let millis_high = ((millis >> 16) & 0xFFFF_FFFF) as u32; - let millis_low = (millis & 0xFFFF) as u16; - - let random_and_version = - (random_bytes[0] as u16 | ((random_bytes[1] as u16) << 8) & 0x0FFF) | (0x7 << 12); - - let mut d4 = [0; 8]; - - d4[0] = (random_bytes[2] & 0x3F) | 0x80; - d4[1] = random_bytes[3]; - d4[2] = random_bytes[4]; - d4[3] = random_bytes[5]; - d4[4] = random_bytes[6]; - d4[5] = random_bytes[7]; - d4[6] = random_bytes[8]; - d4[7] = random_bytes[9]; - - Uuid::from_fields(millis_high, millis_low, random_and_version, &d4) -} - -#[cfg(uuid_unstable)] -pub(crate) const fn decode_unix_timestamp_millis(uuid: &Uuid) -> u64 { - let bytes = uuid.as_bytes(); - - let millis: u64 = (bytes[0] as u64) << 40 - | (bytes[1] as u64) << 32 - | (bytes[2] as u64) << 24 - | (bytes[3] as u64) << 16 - | (bytes[4] as u64) << 8 - | (bytes[5] as u64); - - millis -} - -#[cfg(all(feature = "std", feature = "js", target_arch = "wasm32"))] -fn now() -> (u64, u32) { - use wasm_bindgen::prelude::*; - - #[wasm_bindgen] - extern "C" { - #[wasm_bindgen(js_namespace = Date)] - fn now() -> f64; - } - - let now = now(); - - let secs = (now / 1_000.0) as u64; - let nanos = ((now % 1_000.0) * 1_000_000.0) as u32; - - dbg!((secs, nanos)) -} - -#[cfg(all(feature = "std", any(not(feature = "js"), not(target_arch = "wasm32"))))] -fn now() -> (u64, u32) { - let dur = std::time::SystemTime::UNIX_EPOCH - .elapsed() - .expect("Getting elapsed time since UNIX_EPOCH. If this fails, we've somehow violated causality"); - - (dur.as_secs(), dur.subsec_nanos()) -} - -/// A counter that can be used by version 1 and version 6 UUIDs to support -/// the uniqueness of timestamps. -/// -/// # References -/// -/// * [Clock Sequence in RFC4122](https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.5) -pub trait ClockSequence { - /// The type of sequence returned by this counter. - type Output; - - /// Get the next value in the sequence to feed into a timestamp. - /// - /// This method will be called each time a [`Timestamp`] is constructed. - fn generate_sequence(&self, seconds: u64, subsec_nanos: u32) -> Self::Output; -} - -impl<'a, T: ClockSequence + ?Sized> ClockSequence for &'a T { - type Output = T::Output; - fn generate_sequence(&self, seconds: u64, subsec_nanos: u32) -> Self::Output { - (**self).generate_sequence(seconds, subsec_nanos) - } -} - -/// Default implementations for the [`ClockSequence`] trait. -pub mod context { - use super::ClockSequence; - - #[cfg(any(feature = "v1", feature = "v6"))] - use atomic::{Atomic, Ordering}; - - /// An empty counter that will always return the value `0`. - /// - /// This type should be used when constructing timestamps for version 7 UUIDs, - /// since they don't need a counter for uniqueness. - #[derive(Debug, Clone, Copy, Default)] - pub struct NoContext; - - impl ClockSequence for NoContext { - type Output = u16; - - fn generate_sequence(&self, _seconds: u64, _nanos: u32) -> Self::Output { - 0 - } - } - - #[cfg(all(any(feature = "v1", feature = "v6"), feature = "std", feature = "rng"))] - static CONTEXT: Context = Context { - count: Atomic::new(0), - }; - - #[cfg(all(any(feature = "v1", feature = "v6"), feature = "std", feature = "rng"))] - static CONTEXT_INITIALIZED: Atomic = Atomic::new(false); - - #[cfg(all(any(feature = "v1", feature = "v6"), feature = "std", feature = "rng"))] - pub(crate) fn shared_context() -> &'static Context { - // If the context is in its initial state then assign it to a random value - // It doesn't matter if multiple threads observe `false` here and initialize the context - if CONTEXT_INITIALIZED - .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) - .is_ok() - { - CONTEXT.count.store(crate::rng::u16(), Ordering::Release); - } - - &CONTEXT - } - - /// A thread-safe, wrapping counter that produces 14-bit numbers. - /// - /// This type should be used when constructing version 1 and version 6 UUIDs. - #[derive(Debug)] - #[cfg(any(feature = "v1", feature = "v6"))] - pub struct Context { - count: Atomic, - } - - #[cfg(any(feature = "v1", feature = "v6"))] - impl Context { - /// Construct a new context that's initialized with the given value. - /// - /// The starting value should be a random number, so that UUIDs from - /// different systems with the same timestamps are less likely to collide. - /// When the `rng` feature is enabled, prefer the [`Context::new_random`] method. - pub const fn new(count: u16) -> Self { - Self { - count: Atomic::::new(count), - } - } - - /// Construct a new context that's initialized with a random value. - #[cfg(feature = "rng")] - pub fn new_random() -> Self { - Self { - count: Atomic::::new(crate::rng::u16()), - } - } - } - - #[cfg(any(feature = "v1", feature = "v6"))] - impl ClockSequence for Context { - type Output = u16; - - fn generate_sequence(&self, _seconds: u64, _nanos: u32) -> Self::Output { - // RFC4122 reserves 2 bits of the clock sequence so the actual - // maximum value is smaller than `u16::MAX`. Since we unconditionally - // increment the clock sequence we want to wrap once it becomes larger - // than what we can represent in a "u14". Otherwise there'd be patches - // where the clock sequence doesn't change regardless of the timestamp - self.count.fetch_add(1, Ordering::AcqRel) % (u16::MAX >> 2) - } - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/v1.rs b/fixtures/nextest-tests/vendor/uuid/src/v1.rs deleted file mode 100644 index e19c8a3fba6..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/v1.rs +++ /dev/null @@ -1,175 +0,0 @@ -//! The implementation for Version 1 UUIDs. -//! -//! This module is soft-deprecated. Instead of using the `Context` type re-exported here, -//! use the one from the crate root. - -use crate::{Builder, Uuid}; - -#[deprecated(note = "use types from the crate root instead")] -pub use crate::{timestamp::context::Context, Timestamp}; - -impl Uuid { - /// Create a new version 1 UUID using the current system time and node ID. - /// - /// This method is only available if both the `std` and `rng` features are enabled. - /// - /// This method is a convenient alternative to [`Uuid::new_v1`] that uses the current system time - /// as the source timestamp. - /// - /// Note that usage of this method requires the `v1`, `std`, and `rng` features of this crate - /// to be enabled. - #[cfg(all(feature = "std", feature = "rng"))] - pub fn now_v1(node_id: &[u8; 6]) -> Self { - let ts = Timestamp::now(crate::timestamp::context::shared_context()); - - Self::new_v1(ts, node_id) - } - - /// Create a new version 1 UUID using the given timestamp and node ID. - /// - /// Also see [`Uuid::now_v1`] for a convenient way to generate version 1 - /// UUIDs using the current system time. - /// - /// When generating [`Timestamp`]s using a [`ClockSequence`], this function - /// is only guaranteed to produce unique values if the following conditions - /// hold: - /// - /// 1. The *node ID* is unique for this process, - /// 2. The *context* is shared across all threads which are generating version 1 - /// UUIDs, - /// 3. The [`ClockSequence`] implementation reliably returns unique - /// clock sequences (this crate provides [`Context`] for this - /// purpose. However you can create your own [`ClockSequence`] - /// implementation, if [`Context`] does not meet your needs). - /// - /// Note that usage of this method requires the `v1` feature of this crate - /// to be enabled. - /// - /// # Examples - /// - /// A UUID can be created from a unix [`Timestamp`] with a - /// [`ClockSequence`]. RFC4122 requires the clock sequence - /// is seeded with a random value: - /// - /// ``` - /// # use uuid::{Timestamp, Context}; - /// # use uuid::Uuid; - /// # fn random_seed() -> u16 { 42 } - /// let context = Context::new(random_seed()); - /// let ts = Timestamp::from_unix(&context, 1497624119, 1234); - /// - /// let uuid = Uuid::new_v1(ts, &[1, 2, 3, 4, 5, 6]); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "f3b4958c-52a1-11e7-802a-010203040506" - /// ); - /// ``` - /// - /// The timestamp can also be created manually as per RFC4122: - /// - /// ``` - /// # use uuid::{Uuid, Timestamp, Context, ClockSequence}; - /// let context = Context::new(42); - /// let ts = Timestamp::from_rfc4122(14976234442241191232, context.generate_sequence(0, 0)); - /// - /// let uuid = Uuid::new_v1(ts, &[1, 2, 3, 4, 5, 6]); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "b2c1ad40-45e0-1fd6-802a-010203040506" - /// ); - /// ``` - /// - /// # References - /// - /// * [Version 1 UUIDs in RFC4122](https://www.rfc-editor.org/rfc/rfc4122#section-4.2) - /// - /// [`Timestamp`]: v1/struct.Timestamp.html - /// [`ClockSequence`]: v1/trait.ClockSequence.html - /// [`Context`]: v1/struct.Context.html - pub fn new_v1(ts: Timestamp, node_id: &[u8; 6]) -> Self { - let (ticks, counter) = ts.to_rfc4122(); - - Builder::from_rfc4122_timestamp(ticks, counter, node_id).into_uuid() - } -} - -#[cfg(test)] -mod tests { - use super::*; - - use crate::{std::string::ToString, Variant, Version}; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new() { - let time: u64 = 1_496_854_535; - let time_fraction: u32 = 812_946_000; - let node = [1, 2, 3, 4, 5, 6]; - let context = Context::new(0); - - let uuid = Uuid::new_v1(Timestamp::from_unix(&context, time, time_fraction), &node); - - assert_eq!(uuid.get_version(), Some(Version::Mac)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - assert_eq!( - uuid.hyphenated().to_string(), - "20616934-4ba2-11e7-8000-010203040506" - ); - - let ts = uuid.get_timestamp().unwrap().to_rfc4122(); - - assert_eq!(ts.0 - 0x01B2_1DD2_1381_4000, 14_968_545_358_129_460); - - // Ensure parsing the same UUID produces the same timestamp - let parsed = Uuid::parse_str("20616934-4ba2-11e7-8000-010203040506").unwrap(); - - assert_eq!( - uuid.get_timestamp().unwrap(), - parsed.get_timestamp().unwrap() - ); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - #[cfg(all(feature = "std", feature = "rng"))] - fn test_now() { - let node = [1, 2, 3, 4, 5, 6]; - - let uuid = Uuid::now_v1(&node); - - assert_eq!(uuid.get_version(), Some(Version::Mac)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new_context() { - let time: u64 = 1_496_854_535; - let time_fraction: u32 = 812_946_000; - let node = [1, 2, 3, 4, 5, 6]; - - // This context will wrap - let context = Context::new((u16::MAX >> 2) - 1); - - let uuid1 = Uuid::new_v1(Timestamp::from_unix(&context, time, time_fraction), &node); - - let time: u64 = 1_496_854_536; - - let uuid2 = Uuid::new_v1(Timestamp::from_unix(&context, time, time_fraction), &node); - - assert_eq!(uuid1.get_timestamp().unwrap().to_rfc4122().1, 16382); - assert_eq!(uuid2.get_timestamp().unwrap().to_rfc4122().1, 0); - - let time = 1_496_854_535; - - let uuid3 = Uuid::new_v1(Timestamp::from_unix(&context, time, time_fraction), &node); - let uuid4 = Uuid::new_v1(Timestamp::from_unix(&context, time, time_fraction), &node); - - assert_eq!(uuid3.get_timestamp().unwrap().to_rfc4122().1, 1); - assert_eq!(uuid4.get_timestamp().unwrap().to_rfc4122().1, 2); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/v3.rs b/fixtures/nextest-tests/vendor/uuid/src/v3.rs deleted file mode 100644 index cc7cb9ac392..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/v3.rs +++ /dev/null @@ -1,151 +0,0 @@ -use crate::Uuid; - -impl Uuid { - /// Creates a UUID using a name from a namespace, based on the MD5 - /// hash. - /// - /// A number of namespaces are available as constants in this crate: - /// - /// * [`NAMESPACE_DNS`] - /// * [`NAMESPACE_OID`] - /// * [`NAMESPACE_URL`] - /// * [`NAMESPACE_X500`] - /// - /// Note that usage of this method requires the `v3` feature of this crate - /// to be enabled. - /// - /// # Examples - /// - /// Generating a MD5 DNS UUID for `rust-lang.org`: - /// - /// ``` - /// # use uuid::{Uuid, Version}; - /// let uuid = Uuid::new_v3(&Uuid::NAMESPACE_DNS, b"rust-lang.org"); - /// - /// assert_eq!(Some(Version::Md5), uuid.get_version()); - /// ``` - /// - /// # References - /// - /// * [Version 3 and 5 UUIDs in RFC4122](https://www.rfc-editor.org/rfc/rfc4122#section-4.3) - /// - /// [`NAMESPACE_DNS`]: #associatedconstant.NAMESPACE_DNS - /// [`NAMESPACE_OID`]: #associatedconstant.NAMESPACE_OID - /// [`NAMESPACE_URL`]: #associatedconstant.NAMESPACE_URL - /// [`NAMESPACE_X500`]: #associatedconstant.NAMESPACE_X500 - pub fn new_v3(namespace: &Uuid, name: &[u8]) -> Uuid { - crate::Builder::from_md5_bytes(crate::md5::hash(namespace.as_bytes(), name)).into_uuid() - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - - use crate::{std::string::ToString, Variant, Version}; - - static FIXTURE: &'static [(&'static Uuid, &'static str, &'static str)] = &[ - ( - &Uuid::NAMESPACE_DNS, - "example.org", - "04738bdf-b25a-3829-a801-b21a1d25095b", - ), - ( - &Uuid::NAMESPACE_DNS, - "rust-lang.org", - "c6db027c-615c-3b4d-959e-1a917747ca5a", - ), - ( - &Uuid::NAMESPACE_DNS, - "42", - "5aab6e0c-b7d3-379c-92e3-2bfbb5572511", - ), - ( - &Uuid::NAMESPACE_DNS, - "lorem ipsum", - "4f8772e9-b59c-3cc9-91a9-5c823df27281", - ), - ( - &Uuid::NAMESPACE_URL, - "example.org", - "39682ca1-9168-3da2-a1bb-f4dbcde99bf9", - ), - ( - &Uuid::NAMESPACE_URL, - "rust-lang.org", - "7ed45aaf-e75b-3130-8e33-ee4d9253b19f", - ), - ( - &Uuid::NAMESPACE_URL, - "42", - "08998a0c-fcf4-34a9-b444-f2bfc15731dc", - ), - ( - &Uuid::NAMESPACE_URL, - "lorem ipsum", - "e55ad2e6-fb89-34e8-b012-c5dde3cd67f0", - ), - ( - &Uuid::NAMESPACE_OID, - "example.org", - "f14eec63-2812-3110-ad06-1625e5a4a5b2", - ), - ( - &Uuid::NAMESPACE_OID, - "rust-lang.org", - "6506a0ec-4d79-3e18-8c2b-f2b6b34f2b6d", - ), - ( - &Uuid::NAMESPACE_OID, - "42", - "ce6925a5-2cd7-327b-ab1c-4b375ac044e4", - ), - ( - &Uuid::NAMESPACE_OID, - "lorem ipsum", - "5dd8654f-76ba-3d47-bc2e-4d6d3a78cb09", - ), - ( - &Uuid::NAMESPACE_X500, - "example.org", - "64606f3f-bd63-363e-b946-fca13611b6f7", - ), - ( - &Uuid::NAMESPACE_X500, - "rust-lang.org", - "bcee7a9c-52f1-30c6-a3cc-8c72ba634990", - ), - ( - &Uuid::NAMESPACE_X500, - "42", - "c1073fa2-d4a6-3104-b21d-7a6bdcf39a23", - ), - ( - &Uuid::NAMESPACE_X500, - "lorem ipsum", - "02f09a3f-1624-3b1d-8409-44eff7708208", - ), - ]; - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new() { - for &(ref ns, ref name, _) in FIXTURE { - let uuid = Uuid::new_v3(*ns, name.as_bytes()); - assert_eq!(uuid.get_version(), Some(Version::Md5)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - } - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_hyphenated_string() { - for &(ref ns, ref name, ref expected) in FIXTURE { - let uuid = Uuid::new_v3(*ns, name.as_bytes()); - assert_eq!(uuid.hyphenated().to_string(), *expected); - } - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/v4.rs b/fixtures/nextest-tests/vendor/uuid/src/v4.rs deleted file mode 100644 index e78fb1e69a6..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/v4.rs +++ /dev/null @@ -1,63 +0,0 @@ -use crate::Uuid; - -impl Uuid { - /// Creates a random UUID. - /// - /// This uses the [`getrandom`] crate to utilise the operating system's RNG - /// as the source of random numbers. If you'd like to use a custom - /// generator, don't use this method: generate random bytes using your - /// custom generator and pass them to the - /// [`uuid::Builder::from_random_bytes`][from_random_bytes] function - /// instead. - /// - /// Note that usage of this method requires the `v4` feature of this crate - /// to be enabled. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::{Uuid, Version}; - /// let uuid = Uuid::new_v4(); - /// - /// assert_eq!(Some(Version::Random), uuid.get_version()); - /// ``` - /// - /// # References - /// - /// * [Version 4 UUIDs in RFC4122](https://www.rfc-editor.org/rfc/rfc4122#section-4.4) - /// - /// [`getrandom`]: https://crates.io/crates/getrandom - /// [from_random_bytes]: struct.Builder.html#method.from_random_bytes - pub fn new_v4() -> Uuid { - crate::Builder::from_random_bytes(crate::rng::bytes()).into_uuid() - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{Variant, Version}; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new() { - let uuid = Uuid::new_v4(); - - assert_eq!(uuid.get_version(), Some(Version::Random)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_get_version() { - let uuid = Uuid::new_v4(); - - assert_eq!(uuid.get_version(), Some(Version::Random)); - assert_eq!(uuid.get_version_num(), 4) - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/v5.rs b/fixtures/nextest-tests/vendor/uuid/src/v5.rs deleted file mode 100644 index c3dd44795d1..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/v5.rs +++ /dev/null @@ -1,162 +0,0 @@ -use crate::Uuid; - -impl Uuid { - /// Creates a UUID using a name from a namespace, based on the SHA-1 hash. - /// - /// A number of namespaces are available as constants in this crate: - /// - /// * [`NAMESPACE_DNS`] - /// * [`NAMESPACE_OID`] - /// * [`NAMESPACE_URL`] - /// * [`NAMESPACE_X500`] - /// - /// Note that usage of this method requires the `v5` feature of this crate - /// to be enabled. - /// - /// # Examples - /// - /// Generating a SHA1 DNS UUID for `rust-lang.org`: - /// - /// ``` - /// # use uuid::{Uuid, Version}; - /// let uuid = Uuid::new_v5(&Uuid::NAMESPACE_DNS, b"rust-lang.org"); - /// - /// assert_eq!(Some(Version::Sha1), uuid.get_version()); - /// ``` - /// - /// # References - /// - /// * [Version 3 and 5 UUIDs in RFC4122](https://www.rfc-editor.org/rfc/rfc4122#section-4.3) - /// - /// [`NAMESPACE_DNS`]: struct.Uuid.html#associatedconst.NAMESPACE_DNS - /// [`NAMESPACE_OID`]: struct.Uuid.html#associatedconst.NAMESPACE_OID - /// [`NAMESPACE_URL`]: struct.Uuid.html#associatedconst.NAMESPACE_URL - /// [`NAMESPACE_X500`]: struct.Uuid.html#associatedconst.NAMESPACE_X500 - pub fn new_v5(namespace: &Uuid, name: &[u8]) -> Uuid { - crate::Builder::from_sha1_bytes(crate::sha1::hash(namespace.as_bytes(), name)).into_uuid() - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - - use crate::{std::string::ToString, Variant, Version}; - - static FIXTURE: &'static [(&'static Uuid, &'static str, &'static str)] = &[ - ( - &Uuid::NAMESPACE_DNS, - "example.org", - "aad03681-8b63-5304-89e0-8ca8f49461b5", - ), - ( - &Uuid::NAMESPACE_DNS, - "rust-lang.org", - "c66bbb60-d62e-5f17-a399-3a0bd237c503", - ), - ( - &Uuid::NAMESPACE_DNS, - "42", - "7c411b5e-9d3f-50b5-9c28-62096e41c4ed", - ), - ( - &Uuid::NAMESPACE_DNS, - "lorem ipsum", - "97886a05-8a68-5743-ad55-56ab2d61cf7b", - ), - ( - &Uuid::NAMESPACE_URL, - "example.org", - "54a35416-963c-5dd6-a1e2-5ab7bb5bafc7", - ), - ( - &Uuid::NAMESPACE_URL, - "rust-lang.org", - "c48d927f-4122-5413-968c-598b1780e749", - ), - ( - &Uuid::NAMESPACE_URL, - "42", - "5c2b23de-4bad-58ee-a4b3-f22f3b9cfd7d", - ), - ( - &Uuid::NAMESPACE_URL, - "lorem ipsum", - "15c67689-4b85-5253-86b4-49fbb138569f", - ), - ( - &Uuid::NAMESPACE_OID, - "example.org", - "34784df9-b065-5094-92c7-00bb3da97a30", - ), - ( - &Uuid::NAMESPACE_OID, - "rust-lang.org", - "8ef61ecb-977a-5844-ab0f-c25ef9b8d5d6", - ), - ( - &Uuid::NAMESPACE_OID, - "42", - "ba293c61-ad33-57b9-9671-f3319f57d789", - ), - ( - &Uuid::NAMESPACE_OID, - "lorem ipsum", - "6485290d-f79e-5380-9e64-cb4312c7b4a6", - ), - ( - &Uuid::NAMESPACE_X500, - "example.org", - "e3635e86-f82b-5bbc-a54a-da97923e5c76", - ), - ( - &Uuid::NAMESPACE_X500, - "rust-lang.org", - "26c9c3e9-49b7-56da-8b9f-a0fb916a71a3", - ), - ( - &Uuid::NAMESPACE_X500, - "42", - "e4b88014-47c6-5fe0-a195-13710e5f6e27", - ), - ( - &Uuid::NAMESPACE_X500, - "lorem ipsum", - "b11f79a5-1e6d-57ce-a4b5-ba8531ea03d0", - ), - ]; - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_get_version() { - let uuid = Uuid::new_v5(&Uuid::NAMESPACE_DNS, "rust-lang.org".as_bytes()); - - assert_eq!(uuid.get_version(), Some(Version::Sha1)); - assert_eq!(uuid.get_version_num(), 5); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_hyphenated() { - for &(ref ns, ref name, ref expected) in FIXTURE { - let uuid = Uuid::new_v5(*ns, name.as_bytes()); - - assert_eq!(uuid.hyphenated().to_string(), *expected) - } - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new() { - for &(ref ns, ref name, ref u) in FIXTURE { - let uuid = Uuid::new_v5(*ns, name.as_bytes()); - - assert_eq!(uuid.get_version(), Some(Version::Sha1)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - assert_eq!(Ok(uuid), u.parse()); - } - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/v6.rs b/fixtures/nextest-tests/vendor/uuid/src/v6.rs deleted file mode 100644 index 07644fd4fac..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/v6.rs +++ /dev/null @@ -1,177 +0,0 @@ -//! The implementation for Version 6 UUIDs. -//! -//! Note that you need to enable the `v6` Cargo feature -//! in order to use this module. - -use crate::{Builder, Timestamp, Uuid}; - -impl Uuid { - /// Create a new version 6 UUID using the current system time and node ID. - /// - /// This method is only available if the `std` feature is enabled. - /// - /// This method is a convenient alternative to [`Uuid::new_v6`] that uses the current system time - /// as the source timestamp. - /// - /// Note that usage of this method requires the `v6`, `std`, and `rng` features of this crate - /// to be enabled. - #[cfg(all(feature = "std", feature = "rng"))] - pub fn now_v6(node_id: &[u8; 6]) -> Self { - let ts = Timestamp::now(crate::timestamp::context::shared_context()); - - Self::new_v6(ts, node_id) - } - - /// Create a new version 6 UUID using the given timestamp and a node ID. - /// - /// This is similar to version 1 UUIDs, except that it is lexicographically sortable by timestamp. - /// - /// Also see [`Uuid::now_v6`] for a convenient way to generate version 6 - /// UUIDs using the current system time. - /// - /// When generating [`Timestamp`]s using a [`ClockSequence`], this function - /// is only guaranteed to produce unique values if the following conditions - /// hold: - /// - /// 1. The *node ID* is unique for this process, - /// 2. The *context* is shared across all threads which are generating version 6 - /// UUIDs, - /// 3. The [`ClockSequence`] implementation reliably returns unique - /// clock sequences (this crate provides [`Context`] for this - /// purpose. However you can create your own [`ClockSequence`] - /// implementation, if [`Context`] does not meet your needs). - /// - /// The NodeID must be exactly 6 bytes long. - /// - /// Note that usage of this method requires the `v6` feature of this crate - /// to be enabled. - /// - /// # Examples - /// - /// A UUID can be created from a unix [`Timestamp`] with a - /// [`ClockSequence`]. RFC4122 requires the clock sequence - /// is seeded with a random value: - /// - /// ```rust - /// # use uuid::{Uuid, Timestamp, Context}; - /// # fn random_seed() -> u16 { 42 } - /// let context = Context::new(random_seed()); - /// let ts = Timestamp::from_unix(context, 1497624119, 1234); - /// - /// let uuid = Uuid::new_v6(ts, &[1, 2, 3, 4, 5, 6]); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "1e752a1f-3b49-658c-802a-010203040506" - /// ); - /// ``` - /// - /// The timestamp can also be created manually as per RFC4122: - /// - /// ``` - /// # use uuid::{Uuid, Timestamp, Context, ClockSequence}; - /// # fn random_seed() -> u16 { 42 } - /// let context = Context::new(random_seed()); - /// let ts = Timestamp::from_rfc4122(14976241191231231313, context.generate_sequence(0, 0) ); - /// - /// let uuid = Uuid::new_v6(ts, &[1, 2, 3, 4, 5, 6]); - /// - /// assert_eq!( - /// uuid.hyphenated().to_string(), - /// "fd64c041-1e91-6551-802a-010203040506" - /// ); - /// ``` - /// - /// # References - /// - /// * [Version 6 UUIDs in Draft RFC: New UUID Formats, Version 4](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-5.1) - /// - /// [`Timestamp`]: v1/struct.Timestamp.html - /// [`ClockSequence`]: v1/trait.ClockSequence.html - /// [`Context`]: v1/struct.Context.html - pub fn new_v6(ts: Timestamp, node_id: &[u8; 6]) -> Self { - let (ticks, counter) = ts.to_rfc4122(); - - Builder::from_sorted_rfc4122_timestamp(ticks, counter, node_id).into_uuid() - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{Context, Variant, Version}; - use std::string::ToString; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new() { - let time: u64 = 1_496_854_535; - let time_fraction: u32 = 812_946_000; - let node = [1, 2, 3, 4, 5, 6]; - let context = Context::new(0); - - let uuid = Uuid::new_v6(Timestamp::from_unix(context, time, time_fraction), &node); - - assert_eq!(uuid.get_version(), Some(Version::SortMac)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - assert_eq!( - uuid.hyphenated().to_string(), - "1e74ba22-0616-6934-8000-010203040506" - ); - - let ts = uuid.get_timestamp().unwrap().to_rfc4122(); - - assert_eq!(ts.0 - 0x01B2_1DD2_1381_4000, 14_968_545_358_129_460); - - // Ensure parsing the same UUID produces the same timestamp - let parsed = Uuid::parse_str("1e74ba22-0616-6934-8000-010203040506").unwrap(); - - assert_eq!( - uuid.get_timestamp().unwrap(), - parsed.get_timestamp().unwrap() - ); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - #[cfg(all(feature = "std", feature = "rng"))] - fn test_now() { - let node = [1, 2, 3, 4, 5, 6]; - - let uuid = Uuid::now_v6(&node); - - assert_eq!(uuid.get_version(), Some(Version::SortMac)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new_context() { - let time: u64 = 1_496_854_535; - let time_fraction: u32 = 812_946_000; - let node = [1, 2, 3, 4, 5, 6]; - - // This context will wrap - let context = Context::new((u16::MAX >> 2) - 1); - - let uuid1 = Uuid::new_v6(Timestamp::from_unix(&context, time, time_fraction), &node); - - let time: u64 = 1_496_854_536; - - let uuid2 = Uuid::new_v6(Timestamp::from_unix(&context, time, time_fraction), &node); - - assert_eq!(uuid1.get_timestamp().unwrap().to_rfc4122().1, 16382); - assert_eq!(uuid2.get_timestamp().unwrap().to_rfc4122().1, 0); - - let time = 1_496_854_535; - - let uuid3 = Uuid::new_v6(Timestamp::from_unix(&context, time, time_fraction), &node); - let uuid4 = Uuid::new_v6(Timestamp::from_unix(&context, time, time_fraction), &node); - - assert_eq!(uuid3.get_timestamp().unwrap().counter, 1); - assert_eq!(uuid4.get_timestamp().unwrap().counter, 2); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/v7.rs b/fixtures/nextest-tests/vendor/uuid/src/v7.rs deleted file mode 100644 index 4497ea3f51c..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/v7.rs +++ /dev/null @@ -1,124 +0,0 @@ -//! The implementation for Version 7 UUIDs. -//! -//! Note that you need to enable the `v7` Cargo feature -//! in order to use this module. - -use crate::{std::convert::TryInto, rng, timestamp::Timestamp, Builder, Uuid}; - -impl Uuid { - /// Create a new version 7 UUID using the current time value and random bytes. - /// - /// This method is a convenient alternative to [`Uuid::new_v7`] that uses the current system time - /// as the source timestamp. - #[cfg(feature = "std")] - pub fn now_v7() -> Self { - Self::new_v7(Timestamp::now(crate::NoContext)) - } - - /// Create a new version 7 UUID using a time value and random bytes. - /// - /// When the `std` feature is enabled, you can also use [`Uuid::now_v7`]. - /// - /// Note that usage of this method requires the `v7` feature of this crate - /// to be enabled. - /// - /// Also see [`Uuid::now_v7`] for a convenient way to generate version 7 - /// UUIDs using the current system time. - /// - /// # Examples - /// - /// A v7 UUID can be created from a unix [`Timestamp`] plus a 128 bit - /// random number. When supplied as such, the data will be - /// - /// ```rust - /// # use uuid::{Uuid, Timestamp, NoContext}; - /// let ts = Timestamp::from_unix(NoContext, 1497624119, 1234); - /// - /// let uuid = Uuid::new_v7(ts); - /// - /// assert!( - /// uuid.hyphenated().to_string().starts_with("015cb15a-86d8-7") - /// ); - /// ``` - /// - /// # References - /// - /// * [Version 7 UUIDs in Draft RFC: New UUID Formats, Version 4](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-5.2) - pub fn new_v7(ts: Timestamp) -> Self { - let (secs, nanos) = ts.to_unix(); - let millis = (secs * 1000).saturating_add(nanos as u64 / 1_000_000); - - Builder::from_unix_timestamp_millis(millis, &rng::bytes()[..10].try_into().unwrap()) - .into_uuid() - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{std::string::ToString, NoContext, Variant, Version}; - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new() { - let ts: u64 = 1645557742000; - - let seconds = ts / 1000; - let nanos = ((ts % 1000) * 1_000_000) as u32; - - let uuid = Uuid::new_v7(Timestamp::from_unix(NoContext, seconds, nanos)); - let uustr = uuid.hyphenated().to_string(); - - assert_eq!(uuid.get_version(), Some(Version::SortRand)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - assert!(uuid.hyphenated().to_string().starts_with("017f22e2-79b0-7")); - - // Ensure parsing the same UUID produces the same timestamp - let parsed = Uuid::parse_str(uustr.as_str()).unwrap(); - - assert_eq!(uuid, parsed); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - #[cfg(feature = "std")] - fn test_now() { - let uuid = Uuid::now_v7(); - - assert_eq!(uuid.get_version(), Some(Version::SortRand)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_sorting() { - let time1: u64 = 1_496_854_535; - let time_fraction1: u32 = 812_000_000; - - let time2 = time1 + 4000; - let time_fraction2 = time_fraction1; - - let uuid1 = Uuid::new_v7(Timestamp::from_unix(NoContext, time1, time_fraction1)); - let uuid2 = Uuid::new_v7(Timestamp::from_unix(NoContext, time2, time_fraction2)); - - assert!(uuid1.as_bytes() < uuid2.as_bytes()); - assert!(uuid1.to_string() < uuid2.to_string()); - } - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new_timestamp_roundtrip() { - let time: u64 = 1_496_854_535; - let time_fraction: u32 = 812_000_000; - - let ts = Timestamp::from_unix(NoContext, time, time_fraction); - - let uuid = Uuid::new_v7(ts); - - let decoded_ts = uuid.get_timestamp().unwrap(); - - assert_eq!(ts.to_unix(), decoded_ts.to_unix()); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/src/v8.rs b/fixtures/nextest-tests/vendor/uuid/src/v8.rs deleted file mode 100644 index a54a9798052..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/src/v8.rs +++ /dev/null @@ -1,57 +0,0 @@ -use crate::{Builder, Uuid}; - -impl Uuid { - /// Creates a custom UUID comprised almost entirely of user-supplied bytes. - /// - /// This will inject the UUID Version at 4 bits starting at the 48th bit - /// and the Variant into 2 bits 64th bit. Any existing bits in the user-supplied bytes - /// at those locations will be overridden. - /// - /// Note that usage of this method requires the `v8` feature of this crate - /// to be enabled. - /// - /// # Examples - /// - /// Basic usage: - /// - /// ``` - /// # use uuid::{Uuid, Version}; - /// let buf: [u8; 16] = *b"abcdefghijklmnop"; - /// let uuid = Uuid::new_v8(buf); - /// - /// assert_eq!(Some(Version::Custom), uuid.get_version()); - /// ``` - /// - /// # References - /// - /// * [Version 8 UUIDs in Draft RFC: New UUID Formats, Version 4](https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-5.3) - pub fn new_v8(buf: [u8; 16]) -> Uuid { - Builder::from_custom_bytes(buf).into_uuid() - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{Variant, Version}; - use std::string::ToString; - - #[cfg(target_arch = "wasm32")] - use wasm_bindgen_test::*; - - #[test] - #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] - fn test_new() { - let buf: [u8; 16] = [ - 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, - ]; - let uuid = Uuid::new_v8(buf); - assert_eq!(uuid.get_version(), Some(Version::Custom)); - assert_eq!(uuid.get_variant(), Variant::RFC4122); - assert_eq!(uuid.get_version_num(), 8); - assert_eq!( - uuid.hyphenated().to_string(), - "0f0e0d0c-0b0a-8908-8706-050403020100" - ); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/tests/macros.rs b/fixtures/nextest-tests/vendor/uuid/tests/macros.rs deleted file mode 100644 index c7cf2a42985..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/tests/macros.rs +++ /dev/null @@ -1,11 +0,0 @@ -#[cfg(feature = "macro-diagnostics")] -#[test] -fn ui() { - let t = trybuild::TestCases::new(); - - t.pass("tests/ui/compile_pass/*.rs"); - - if rustversion::cfg!(nightly) { - t.compile_fail("tests/ui/compile_fail/*.rs"); - } -} diff --git a/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_fail/invalid_parse.rs b/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_fail/invalid_parse.rs deleted file mode 100644 index f67456b935e..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_fail/invalid_parse.rs +++ /dev/null @@ -1,45 +0,0 @@ -use uuid::{uuid, Uuid}; - -const _: Uuid = uuid!(""); -const _: Uuid = uuid!("!"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E45"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faaXB6BFF329BF39FA1E4"); -const _: Uuid = uuid!("F9168C5E-CEB-24fa-eB6BFF32-BF39FA1E4"); -const _: Uuid = uuid!("01020304-1112-2122-3132-41424344"); -const _: Uuid = uuid!("67e5504410b1426f9247bb680e5fe0c88"); -const _: Uuid = uuid!("67e5504410b1426f9247bb680e5fe0cg8"); -const _: Uuid = uuid!("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8"); - -// Test error reporting -const _: Uuid = uuid!("67e5504410b1426f9247bb680e5fe0c"); -const _: Uuid = uuid!("67e550X410b1426f9247bb680e5fe0cd"); -const _: Uuid = uuid!("67e550-4105b1426f9247bb680e5fe0c"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4"); - - -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"); -const _: Uuid = uuid!("01020304-1112-2122-3132-41424344"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4"); -const _: Uuid = uuid!("urn:uuid:F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"); -const _: Uuid = uuid!("urn:uuid:F9168C5E-CEB2-4faa-B2cBF-32BF39FA1E4"); -const _: Uuid = uuid!("{F9168C5E-CEB2-4faa-B0a75-32BF39FA1E4}"); - -const _: Uuid = uuid!("{F9168C5E-CEB2-4faa-B6BF-329Bz39FA1E4}"); - -// group 0 has invalid length -const _: Uuid = uuid!("67e550-4105b1426f9247bb680e5fe0c"); - -const _: Uuid = uuid!("504410岡林aab1426f9247bb680e5fe0c8"); -const _: Uuid = uuid!("504410😎👍aab1426f9247bb680e5fe0c8"); - -const _: Uuid = uuid!("{F9168C5E-CEB2-4faa-👍5-32BF39FA1E4}"); - -const _: Uuid = uuid!("F916"); -const _: Uuid = uuid!("F916x"); - -fn main() {} diff --git a/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_fail/invalid_parse.stderr b/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_fail/invalid_parse.stderr deleted file mode 100644 index b630494975f..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_fail/invalid_parse.stderr +++ /dev/null @@ -1,197 +0,0 @@ -error: invalid length: expected length 32 for simple format, found 0 - --> tests/ui/compile_fail/invalid_parse.rs:3:17 - | -3 | const _: Uuid = uuid!(""); - | ^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `!` at 1 - --> tests/ui/compile_fail/invalid_parse.rs:4:24 - | -4 | const _: Uuid = uuid!("!"); - | ^ - -error: invalid group length in group 4: expected 12, found 13 - --> tests/ui/compile_fail/invalid_parse.rs:5:48 - | -5 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E45"); - | ^^^^^^^^^^^^^ - -error: invalid group length in group 3: expected 4, found 3 - --> tests/ui/compile_fail/invalid_parse.rs:6:43 - | -6 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4"); - | ^^^ - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `G` at 21 - --> tests/ui/compile_fail/invalid_parse.rs:7:44 - | -7 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"); - | ^ - -error: invalid group count: expected 5, found 4 - --> tests/ui/compile_fail/invalid_parse.rs:8:17 - | -8 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4"); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid group count: expected 5, found 3 - --> tests/ui/compile_fail/invalid_parse.rs:9:17 - | -9 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa"); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `X` at 19 - --> tests/ui/compile_fail/invalid_parse.rs:10:42 - | -10 | const _: Uuid = uuid!("F9168C5E-CEB2-4faaXB6BFF329BF39FA1E4"); - | ^ - -error: invalid group length in group 1: expected 4, found 3 - --> tests/ui/compile_fail/invalid_parse.rs:11:33 - | -11 | const _: Uuid = uuid!("F9168C5E-CEB-24fa-eB6BFF32-BF39FA1E4"); - | ^^^ - -error: invalid group length in group 4: expected 12, found 8 - --> tests/ui/compile_fail/invalid_parse.rs:12:48 - | -12 | const _: Uuid = uuid!("01020304-1112-2122-3132-41424344"); - | ^^^^^^^^ - -error: invalid length: expected length 32 for simple format, found 33 - --> tests/ui/compile_fail/invalid_parse.rs:13:17 - | -13 | const _: Uuid = uuid!("67e5504410b1426f9247bb680e5fe0c88"); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `g` at 32 - --> tests/ui/compile_fail/invalid_parse.rs:14:55 - | -14 | const _: Uuid = uuid!("67e5504410b1426f9247bb680e5fe0cg8"); - | ^ - -error: invalid length: expected length 32 for simple format, found 31 - --> tests/ui/compile_fail/invalid_parse.rs:18:17 - | -18 | const _: Uuid = uuid!("67e5504410b1426f9247bb680e5fe0c"); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `X` at 7 - --> tests/ui/compile_fail/invalid_parse.rs:19:30 - | -19 | const _: Uuid = uuid!("67e550X410b1426f9247bb680e5fe0cd"); - | ^ - -error: invalid group count: expected 5, found 2 - --> tests/ui/compile_fail/invalid_parse.rs:20:17 - | -20 | const _: Uuid = uuid!("67e550-4105b1426f9247bb680e5fe0c"); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid group length in group 3: expected 4, found 5 - --> tests/ui/compile_fail/invalid_parse.rs:21:43 - | -21 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4"); - | ^^^^^ - -error: invalid group length in group 3: expected 4, found 3 - --> tests/ui/compile_fail/invalid_parse.rs:24:43 - | -24 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4"); - | ^^^ - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `G` at 21 - --> tests/ui/compile_fail/invalid_parse.rs:25:44 - | -25 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"); - | ^ - -error: invalid group length in group 4: expected 12, found 8 - --> tests/ui/compile_fail/invalid_parse.rs:26:48 - | -26 | const _: Uuid = uuid!("01020304-1112-2122-3132-41424344"); - | ^^^^^^^^ - -error: invalid group count: expected 5, found 4 - --> tests/ui/compile_fail/invalid_parse.rs:27:17 - | -27 | const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4"); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `G` at 30 - --> tests/ui/compile_fail/invalid_parse.rs:28:53 - | -28 | const _: Uuid = uuid!("urn:uuid:F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"); - | ^ - -error: invalid group length in group 3: expected 4, found 5 - --> tests/ui/compile_fail/invalid_parse.rs:29:52 - | -29 | const _: Uuid = uuid!("urn:uuid:F9168C5E-CEB2-4faa-B2cBF-32BF39FA1E4"); - | ^^^^^ - -error: invalid group length in group 3: expected 4, found 5 - --> tests/ui/compile_fail/invalid_parse.rs:30:44 - | -30 | const _: Uuid = uuid!("{F9168C5E-CEB2-4faa-B0a75-32BF39FA1E4}"); - | ^^^^^ - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `z` at 30 - --> tests/ui/compile_fail/invalid_parse.rs:32:53 - | -32 | const _: Uuid = uuid!("{F9168C5E-CEB2-4faa-B6BF-329Bz39FA1E4}"); - | ^ - -error: invalid group count: expected 5, found 2 - --> tests/ui/compile_fail/invalid_parse.rs:35:17 - | -35 | const _: Uuid = uuid!("67e550-4105b1426f9247bb680e5fe0c"); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `岡` at 7 - --> tests/ui/compile_fail/invalid_parse.rs:37:30 - | -37 | const _: Uuid = uuid!("504410岡林aab1426f9247bb680e5fe0c8"); - | ^^ - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `😎` at 7 - --> tests/ui/compile_fail/invalid_parse.rs:38:30 - | -38 | const _: Uuid = uuid!("504410😎👍aab1426f9247bb680e5fe0c8"); - | ^^ - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `👍` at 21 - --> tests/ui/compile_fail/invalid_parse.rs:40:44 - | -40 | const _: Uuid = uuid!("{F9168C5E-CEB2-4faa-👍5-32BF39FA1E4}"); - | ^^ - -error: invalid length: expected length 32 for simple format, found 4 - --> tests/ui/compile_fail/invalid_parse.rs:42:17 - | -42 | const _: Uuid = uuid!("F916"); - | ^^^^^^^^^^^^^ - | - = note: this error originates in the macro `uuid` (in Nightly builds, run with -Z macro-backtrace for more info) - -error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-zA-Z], found `x` at 5 - --> tests/ui/compile_fail/invalid_parse.rs:43:28 - | -43 | const _: Uuid = uuid!("F916x"); - | ^ diff --git a/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_pass/renamed.rs b/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_pass/renamed.rs deleted file mode 100644 index 321172efeff..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_pass/renamed.rs +++ /dev/null @@ -1,11 +0,0 @@ -use ::uuid::{uuid as id, Uuid as Id}; - -mod uuid { - struct MyType; -} - -struct Uuid; - -const _: Id = id!("67e55044-10b1-426f-9247-bb680e5fe0c8"); - -fn main() {} diff --git a/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_pass/valid.rs b/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_pass/valid.rs deleted file mode 100644 index 1f536dc0430..00000000000 --- a/fixtures/nextest-tests/vendor/uuid/tests/ui/compile_pass/valid.rs +++ /dev/null @@ -1,20 +0,0 @@ -use uuid::{uuid, Uuid}; - -const _: Uuid = uuid!("00000000000000000000000000000000"); -const _: Uuid = uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"); -const _: Uuid = uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"); -const _: Uuid = uuid!("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4"); -const _: Uuid = uuid!("67e5504410b1426f9247bb680e5fe0c8"); -const _: Uuid = uuid!("01020304-1112-2122-3132-414243444546"); -const _: Uuid = uuid!("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8"); - -// Nil -const _: Uuid = uuid!("00000000000000000000000000000000"); -const _: Uuid = uuid!("00000000-0000-0000-0000-000000000000"); - -// valid hyphenated -const _: Uuid = uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"); -// valid short -const _: Uuid = uuid!("67e5504410b1426f9247bb680e5fe0c8"); - -fn main() {}