From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/maplit/.cargo-checksum.json | 1 + vendor/maplit/Cargo.toml | 24 +++ vendor/maplit/LICENSE-APACHE | 201 +++++++++++++++++++++++ vendor/maplit/LICENSE-MIT | 25 +++ vendor/maplit/README.rst | 80 +++++++++ vendor/maplit/src/lib.rs | 324 +++++++++++++++++++++++++++++++++++++ vendor/maplit/tests/tests.rs | 65 ++++++++ 7 files changed, 720 insertions(+) create mode 100644 vendor/maplit/.cargo-checksum.json create mode 100644 vendor/maplit/Cargo.toml create mode 100644 vendor/maplit/LICENSE-APACHE create mode 100644 vendor/maplit/LICENSE-MIT create mode 100644 vendor/maplit/README.rst create mode 100644 vendor/maplit/src/lib.rs create mode 100644 vendor/maplit/tests/tests.rs (limited to 'vendor/maplit') diff --git a/vendor/maplit/.cargo-checksum.json b/vendor/maplit/.cargo-checksum.json new file mode 100644 index 000000000..bf057d194 --- /dev/null +++ b/vendor/maplit/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.toml":"4281e55a6ade6ea883936f2325599d7050c823118a641bb549cf0d47bf4d861e","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"7576269ea71f767b99297934c0b2367532690f8c4badc695edf8e04ab6a1e545","README.rst":"a3896d941360244037c0e1bf82e6f8def2ddaea13381e7165b26cbf9502a311c","src/lib.rs":"20592121c8ee5365ba967e1c09c46d7f09c247b0a7f7d7ad7066e262b70f1af2","tests/tests.rs":"f7fc8b9ed33f3b14eee34cacbb99d1f435666b52445eb7b41e5bde8dffae759d"},"package":"3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"} \ No newline at end of file diff --git a/vendor/maplit/Cargo.toml b/vendor/maplit/Cargo.toml new file mode 100644 index 000000000..30bf9066c --- /dev/null +++ b/vendor/maplit/Cargo.toml @@ -0,0 +1,24 @@ +# 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 believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "maplit" +version = "1.0.2" +authors = ["bluss"] +description = "Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet." +documentation = "https://docs.rs/maplit/" +keywords = ["literal", "data-structure", "hashmap", "macro"] +categories = ["rust-patterns"] +license = "MIT/Apache-2.0" +repository = "https://github.com/bluss/maplit" +[package.metadata.release] +no-dev-version = true diff --git a/vendor/maplit/LICENSE-APACHE b/vendor/maplit/LICENSE-APACHE new file mode 100644 index 000000000..16fe87b06 --- /dev/null +++ b/vendor/maplit/LICENSE-APACHE @@ -0,0 +1,201 @@ + 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/vendor/maplit/LICENSE-MIT b/vendor/maplit/LICENSE-MIT new file mode 100644 index 000000000..9203baa05 --- /dev/null +++ b/vendor/maplit/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright (c) 2015 + +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/vendor/maplit/README.rst b/vendor/maplit/README.rst new file mode 100644 index 000000000..1be1840e6 --- /dev/null +++ b/vendor/maplit/README.rst @@ -0,0 +1,80 @@ +maplit +====== + +Container / collection literal macros for `HashMap `_, `HashSet `_, `BTreeMap `_, `BTreeSet `_. + +You can use these for convenience. Using them has no other implications. + +Please read the `API documentation here`__ + +__ https://docs.rs/maplit/ + +|build_status|_ |crates|_ + +.. |build_status| image:: https://travis-ci.org/bluss/maplit.svg?branch=master +.. _build_status: https://travis-ci.org/bluss/maplit + +.. |crates| image:: http://meritbadge.herokuapp.com/maplit +.. _crates: https://crates.io/crates/maplit + + +Recent Changes +-------------- + +- 1.0.2 + + - Fix usage of the macros through full paths, like `maplit::hashmap!(..)` (#27) + +- 1.0.1 + + - Fix ``unused_results`` lint in the macros by @povilasb + +- 1.0.0 + + - maplit 1.0! + - Only documentation changes since the last version + +- 0.1.6 + + - Add macro ``convert_args!`` for composable opt-in conversion of the + expressions being used for the maplit macros. + +- 0.1.5 + + - Add license files correctly + - Add crates.io category + - Small doc improvements by @seeekr and @sanmai-NL + +- 0.1.4 + + - Update docs to point to docs.rs + +- 0.1.2 + + - Now supports more arguments in hashset!{} and hashmap!{} + +- 0.1.0 + + - Initial release + +FAQ +--- + +**Question:** Very large maps take a long time to compile? + +**Answer:** Rustc is very slow to compile big expressions with many literals +(including integers and float literals). Work around this by either +using explicitly typed literals, or explicitly typed conversions. +See https://github.com/bluss/maplit/issues/14 for more information. + + +License +------- + +Dual-licensed to be compatible with the Rust project. + +Licensed under the Apache License, Version 2.0 +http://www.apache.org/licenses/LICENSE-2.0 or the MIT license +http://opensource.org/licenses/MIT, at your +option. This file may not be copied, modified, or distributed +except according to those terms. diff --git a/vendor/maplit/src/lib.rs b/vendor/maplit/src/lib.rs new file mode 100644 index 000000000..4993f1bd3 --- /dev/null +++ b/vendor/maplit/src/lib.rs @@ -0,0 +1,324 @@ +#![warn(missing_docs)] +#![warn(unused_results)] +#![doc(html_root_url="https://docs.rs/maplit/1/")] + +//! Macros for container literals with specific type. +//! +//! ``` +//! #[macro_use] extern crate maplit; +//! +//! # fn main() { +//! let map = hashmap!{ +//! "a" => 1, +//! "b" => 2, +//! }; +//! # } +//! ``` +//! +//! The **maplit** crate uses `=>` syntax to separate the key and value for the +//! mapping macros. (It was not possible to use `:` as separator due to syntactic +//! restrictions in regular `macro_rules!` macros.) +//! +//! Note that rust macros are flexible in which brackets you use for the invocation. +//! You can use them as `hashmap!{}` or `hashmap![]` or `hashmap!()`. +//! +//! Generic container macros already exist elsewhere, so those are not provided +//! here at the moment. + +#[macro_export(local_inner_macros)] +/// Create a **HashMap** from a list of key-value pairs +/// +/// ## Example +/// +/// ``` +/// #[macro_use] extern crate maplit; +/// # fn main() { +/// +/// let map = hashmap!{ +/// "a" => 1, +/// "b" => 2, +/// }; +/// assert_eq!(map["a"], 1); +/// assert_eq!(map["b"], 2); +/// assert_eq!(map.get("c"), None); +/// # } +/// ``` +macro_rules! hashmap { + (@single $($x:tt)*) => (()); + (@count $($rest:expr),*) => (<[()]>::len(&[$(hashmap!(@single $rest)),*])); + + ($($key:expr => $value:expr,)+) => { hashmap!($($key => $value),+) }; + ($($key:expr => $value:expr),*) => { + { + let _cap = hashmap!(@count $($key),*); + let mut _map = ::std::collections::HashMap::with_capacity(_cap); + $( + let _ = _map.insert($key, $value); + )* + _map + } + }; +} + +/// Create a **HashSet** from a list of elements. +/// +/// ## Example +/// +/// ``` +/// #[macro_use] extern crate maplit; +/// # fn main() { +/// +/// let set = hashset!{"a", "b"}; +/// assert!(set.contains("a")); +/// assert!(set.contains("b")); +/// assert!(!set.contains("c")); +/// # } +/// ``` +#[macro_export(local_inner_macros)] +macro_rules! hashset { + (@single $($x:tt)*) => (()); + (@count $($rest:expr),*) => (<[()]>::len(&[$(hashset!(@single $rest)),*])); + + ($($key:expr,)+) => { hashset!($($key),+) }; + ($($key:expr),*) => { + { + let _cap = hashset!(@count $($key),*); + let mut _set = ::std::collections::HashSet::with_capacity(_cap); + $( + let _ = _set.insert($key); + )* + _set + } + }; +} + +#[macro_export(local_inner_macros)] +/// Create a **BTreeMap** from a list of key-value pairs +/// +/// ## Example +/// +/// ``` +/// #[macro_use] extern crate maplit; +/// # fn main() { +/// +/// let map = btreemap!{ +/// "a" => 1, +/// "b" => 2, +/// }; +/// assert_eq!(map["a"], 1); +/// assert_eq!(map["b"], 2); +/// assert_eq!(map.get("c"), None); +/// # } +/// ``` +macro_rules! btreemap { + // trailing comma case + ($($key:expr => $value:expr,)+) => (btreemap!($($key => $value),+)); + + ( $($key:expr => $value:expr),* ) => { + { + let mut _map = ::std::collections::BTreeMap::new(); + $( + let _ = _map.insert($key, $value); + )* + _map + } + }; +} + +#[macro_export(local_inner_macros)] +/// Create a **BTreeSet** from a list of elements. +/// +/// ## Example +/// +/// ``` +/// #[macro_use] extern crate maplit; +/// # fn main() { +/// +/// let set = btreeset!{"a", "b"}; +/// assert!(set.contains("a")); +/// assert!(set.contains("b")); +/// assert!(!set.contains("c")); +/// # } +/// ``` +macro_rules! btreeset { + ($($key:expr,)+) => (btreeset!($($key),+)); + + ( $($key:expr),* ) => { + { + let mut _set = ::std::collections::BTreeSet::new(); + $( + _set.insert($key); + )* + _set + } + }; +} + +/// Identity function. Used as the fallback for conversion. +#[doc(hidden)] +pub fn __id(t: T) -> T { t } + +/// Macro that converts the keys or key-value pairs passed to another maplit +/// macro. The default conversion is to use the [`Into`] trait, if no +/// custom conversion is passed. +/// +/// The syntax is: +/// +/// `convert_args!(` `keys=` *function* `,` `values=` *function* `,` +/// *macro_name* `!(` [ *key* => *value* [, *key* => *value* ... ] ] `))` +/// +/// Here *macro_name* is any other maplit macro and either or both of the +/// explicit `keys=` and `values=` parameters can be omitted. +/// +/// [`Into`]: https://doc.rust-lang.org/std/convert/trait.Into.html +/// +/// **Note** To use `convert_args`, the macro that is being wrapped +/// must itself be brought into the current scope with `#[macro_use]` or `use`. +/// +/// # Examples +/// +/// ``` +/// #[macro_use] extern crate maplit; +/// # fn main() { +/// +/// use std::collections::HashMap; +/// use std::collections::BTreeSet; +/// +/// // a. Use the default conversion with the Into trait. +/// // Here this converts both the key and value string literals to `String`, +/// // but we need to specify the map type exactly! +/// +/// let map1: HashMap = convert_args!(hashmap!( +/// "a" => "b", +/// "c" => "d", +/// )); +/// +/// // b. Specify an explicit custom conversion for the keys. If we don't specify +/// // a conversion for the values, they are not converted at all. +/// +/// let map2 = convert_args!(keys=String::from, hashmap!( +/// "a" => 1, +/// "c" => 2, +/// )); +/// +/// // Note: map2 is a HashMap, but we didn't need to specify the type +/// let _: HashMap = map2; +/// +/// // c. convert_args! works with all the maplit macros -- and macros from other +/// // crates that have the same "signature". +/// // For example, btreeset and conversion from &str to Vec. +/// +/// let set: BTreeSet> = convert_args!(btreeset!( +/// "a", "b", "c", "d", "a", "e", "f", +/// )); +/// assert_eq!(set.len(), 6); +/// +/// +/// # } +/// ``` +#[macro_export(local_inner_macros)] +macro_rules! convert_args { + (keys=$kf:expr, $macro_name:ident !($($k:expr),* $(,)*)) => { + $macro_name! { $(($kf)($k)),* } + }; + (keys=$kf:expr, values=$vf:expr, $macro_name:ident !($($k:expr),* $(,)*)) => { + $macro_name! { $(($kf)($k)),* } + }; + (keys=$kf:expr, values=$vf:expr, $macro_name:ident !( $($k:expr => $v:expr),* $(,)*)) => { + $macro_name! { $(($kf)($k) => ($vf)($v)),* } + }; + (keys=$kf:expr, $macro_name:ident !($($rest:tt)*)) => { + convert_args! { + keys=$kf, values=$crate::__id, + $macro_name !( + $($rest)* + ) + } + }; + (values=$vf:expr, $macro_name:ident !($($rest:tt)*)) => { + convert_args! { + keys=$crate::__id, values=$vf, + $macro_name !( + $($rest)* + ) + } + }; + ($macro_name:ident ! $($rest:tt)*) => { + convert_args! { + keys=::std::convert::Into::into, values=::std::convert::Into::into, + $macro_name ! + $($rest)* + } + }; +} + +#[test] +fn test_hashmap() { + use std::collections::HashMap; + use std::collections::HashSet; + let names = hashmap!{ + 1 => "one", + 2 => "two", + }; + assert_eq!(names.len(), 2); + assert_eq!(names[&1], "one"); + assert_eq!(names[&2], "two"); + assert_eq!(names.get(&3), None); + + let empty: HashMap = hashmap!{}; + assert_eq!(empty.len(), 0); + + let _nested_compiles = hashmap!{ + 1 => hashmap!{0 => 1 + 2,}, + 2 => hashmap!{1 => 1,}, + }; + + let _: HashMap = convert_args!(keys=String::from, hashmap!( + "one" => 1, + "two" => 2, + )); + + let _: HashMap = convert_args!(keys=String::from, values=__id, hashmap!( + "one" => 1, + "two" => 2, + )); + + let names: HashSet = convert_args!(hashset!( + "one", + "two", + )); + assert!(names.contains("one")); + assert!(names.contains("two")); + + let lengths: HashSet = convert_args!(keys=str::len, hashset!( + "one", + "two", + )); + assert_eq!(lengths.len(), 1); + + let _no_trailing: HashSet = convert_args!(keys=str::len, hashset!( + "one", + "two" + )); +} + +#[test] +fn test_btreemap() { + use std::collections::BTreeMap; + let names = btreemap!{ + 1 => "one", + 2 => "two", + }; + assert_eq!(names.len(), 2); + assert_eq!(names[&1], "one"); + assert_eq!(names[&2], "two"); + assert_eq!(names.get(&3), None); + + let empty: BTreeMap = btreemap!{}; + assert_eq!(empty.len(), 0); + + let _nested_compiles = btreemap!{ + 1 => btreemap!{0 => 1 + 2,}, + 2 => btreemap!{1 => 1,}, + }; +} diff --git a/vendor/maplit/tests/tests.rs b/vendor/maplit/tests/tests.rs new file mode 100644 index 000000000..b7b8968fc --- /dev/null +++ b/vendor/maplit/tests/tests.rs @@ -0,0 +1,65 @@ + +#[macro_use] extern crate maplit; + +#[test] +#[allow(unused_parens)] +fn test_parse() { + let mut m = hashmap!{}; + m.insert(1, 1); + hashmap!{1 => 1}; + hashmap!{1 => 1,}; + hashmap!{1 + 1 => 1, 2 + 1 => 2}; + hashmap!{1 + 1 => 1, 2 + 1 => 2,}; + hashmap!{{1 + 2} => 1, (1 + 3) => {0 + 2}}; + let m = hashmap!{"a".to_string() => 1 + 2, "b".to_string() => 1 + 3}; + assert_eq!(m["a"], 3); + assert_eq!(m["b"], 4); + let m = hashmap!{"a".to_string() => 1 + 2, "b".to_string() => 1 + 3, }; + assert_eq!(m["a"], 3); + assert_eq!(m["b"], 4); + + let mut s = hashset!{}; + s.insert(1); + hashset!{1}; + hashset!{1,}; + hashset!{1, 2}; + hashset!{1, 2,}; + hashset!{1 + 1, 2 + 1}; + hashset!{1 + 1, 2 + 1,}; + hashset!{{1 + 1}, (2 + 1)}; +} + +#[test] +fn hashset() { + let mut set = hashset!{}; + assert!(set.is_empty()); + set.insert(2); + let set = hashset!{1}; + assert_eq!(set.len(), 1); + let set = hashset!{2, 3}; + assert_eq!(set.len(), 2); + // Test that we can use many elements without hitting the macro recursion limit + let set = hashset!{1, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + 2,3,4,5,6,7,8,9,0,1,2,3,4,5,6, + }; + assert_eq!(set.len(), 10); +} -- cgit v1.2.3