Lines Matching defs:test
2 use test::Bencher;
78 use test::{black_box, Bencher};
292 use test::Bencher;
293 use test::black_box;
378 use test::{black_box, Bencher};
543 use test::{black_box, Bencher};
1283 #![feature(test)]
1285 extern crate test;
1301 use test::{black_box, Bencher};
1808 use test::Bencher;
2036 use test::{black_box, Bencher};
2414 use test::{black_box, Bencher};
2470 use test::{black_box, Bencher};
2595 #[test]
2643 #[test]
2699 #[test]
2715 #[test]
2729 #[test]
2747 #[test]
2763 #[test]
2784 #[test]
2802 #[test]
2816 #[test]
2831 #[test]
2851 #[test]
2861 #[test]
2893 #[test]
2898 let list: LinkedList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
2899 assert_eq!(format!("{:?}", list), "[\"just\", \"one\", \"test\", \"more\"]");
2902 #[test]
2921 #[test]
2937 #[test]
2950 #[test]
2967 #[test]
2990 #[test]
3013 #[test]
3037 #[test]
3125 #[test]
3159 #[test]
3193 #[test]
3215 #[test]
3241 #[test]
3265 #[test]
3304 #[test]
3316 #[test]
3329 #[test]
3347 #[test]
3354 #[test]
3370 #[test]
3387 // The test code below is identical to that in `rc.rs`.
3395 #[test]
3417 #[test]
3454 #[test]
3469 #[test]
3498 #[test]
3506 #[test]
3516 #[test]
3526 #[test]
3536 #[test]
3543 #[test]
3602 #[test]
3608 #[test]
3624 #[test]
3634 #[test]
3645 #[test]
3656 #[test]
3686 #[test]
3714 #[test]
3725 #[test]
3736 #[test]
3742 #[test]
3748 let test = "test";
3749 assert_eq!(" test test ".replacen(test, "toast", 3), " toast toast ");
3750 assert_eq!(" test test ".replacen(test, "toast", 0), " test test ");
3751 assert_eq!(" test test ".replacen(test, "", 5), " ");
3756 #[test]
3762 let test = "test";
3763 assert_eq!(" test test ".replace(test, "toast"), " toast toast ");
3764 assert_eq!(" test test ".replace(test, ""), " ");
3767 #[test]
3777 #[test]
3787 #[test]
3797 #[test]
3806 #[test]
3868 #[test]
3877 #[test]
3883 // Generates test cases for bad index operations.
3885 // This generates `should_panic` test cases for Index/IndexMut
3886 // and `None` test cases for get/get_mut.
3907 #[test]
3924 #[test]
3932 #[test]
3943 #[test]
3958 #[test]
4001 #[test]
4027 #[test]
4143 // it is especially important to test all of the different range types here
4207 #[test]
4213 #[test]
4220 #[test]
4227 #[test]
4234 #[test]
4242 #[test]
4250 #[test]
4270 #[test]
4285 #[test]
4300 #[test]
4315 #[test]
4325 #[test]
4335 #[test]
4345 #[test]
4354 #[test]
4379 #[test]
4391 #[test]
4393 macro_rules! test {
4400 test!(b"A\xC3\xA9 \xFF ", 4, Some(1));
4401 test!(b"A\xC3\xA9 \x80 ", 4, Some(1));
4402 test!(b"A\xC3\xA9 \xC1 ", 4, Some(1));
4403 test!(b"A\xC3\xA9 \xC1", 4, Some(1));
4404 test!(b"A\xC3\xA9 \xC2", 4, None);
4405 test!(b"A\xC3\xA9 \xC2 ", 4, Some(1));
4406 test!(b"A\xC3\xA9 \xC2\xC0", 4, Some(1));
4407 test!(b"A\xC3\xA9 \xE0", 4, None);
4408 test!(b"A\xC3\xA9 \xE0\x9F", 4, Some(1));
4409 test!(b"A\xC3\xA9 \xE0\xA0", 4, None);
4410 test!(b"A\xC3\xA9 \xE0\xA0\xC0", 4, Some(2));
4411 test!(b"A\xC3\xA9 \xE0\xA0 ", 4, Some(2));
4412 test!(b"A\xC3\xA9 \xED\xA0\x80 ", 4, Some(1));
4413 test!(b"A\xC3\xA9 \xF1", 4, None);
4414 test!(b"A\xC3\xA9 \xF1\x80", 4, None);
4415 test!(b"A\xC3\xA9 \xF1\x80\x80", 4, None);
4416 test!(b"A\xC3\xA9 \xF1 ", 4, Some(1));
4417 test!(b"A\xC3\xA9 \xF1\x80 ", 4, Some(2));
4418 test!(b"A\xC3\xA9 \xF1\x80\x80 ", 4, Some(3));
4421 #[test]
4434 #[test]
4444 #[test]
4456 #[test]
4474 #[test]
4491 #[test]
4499 #[test]
4512 #[test]
4523 #[test]
4530 #[test]
4543 #[test]
4567 #[test]
4581 #[test]
4590 #[test]
4606 #[test]
4621 #[test]
4633 #[test]
4645 #[test]
4653 #[test]
4661 #[test]
4671 #[test]
4686 #[test]
4701 #[test]
4715 #[test]
4723 #[test]
4731 #[test]
4748 #[test]
4765 #[test]
4773 #[test]
4791 #[test]
4802 #[test]
4821 #[test]
4845 #[test]
4859 #[test]
4873 #[test]
4885 #[test]
4897 #[test]
4904 #[test]
4915 #[test]
4937 #[test]
4951 #[test]
4963 #[test]
4975 #[test]
4983 #[test]
4990 #[test]
5006 #[test]
5012 // test all substrings for good measure
5016 #[test]
5022 #[test]
5029 #[test]
5051 #[test]
5085 #[test]
5098 #[test]
5103 #[test]
5108 #[test]
5127 #[test]
5134 #[test]
5148 #[test]
5181 #[test]
5187 #[test]
5190 // test that we can round-trip between Box<str> and String.
5195 #[test]
5203 #[test]
5213 #[test]
5230 #[test]
5234 #[test]
5380 #[test]
5404 #[test]
5461 #[test]
5477 #[test]
5480 is a test"
5485 test"
5487 assert_eq!(a, "this is a test".to_string());
5488 assert_eq!(b, "this is another test".to_string());
5491 #[test]
5498 #[test]
5518 #[test]
5568 #[test]
5598 #[test]
5643 #[test]
5649 #[test]
5655 #[test]
5661 #[test]
5678 #[test]
5732 #[test]
5787 #[test]
5802 #[test]
5820 #[test]
5830 #[test]
5841 #[test]
5852 #[test]
5863 #[test]
5874 #[test]
5882 #[test]
5890 #[test]
5897 #[test]
5907 #[test]
5917 #[test]
5935 #[test]
5942 #[test]
5949 #[test]
5957 #[test]
5966 #[test]
5976 #[test]
5982 #[test]
6009 #[test]
6043 #[test]
6052 #[test]
6057 #[test]
6063 #[test]
6072 #[test]
6083 #[test]
6092 #[test]
6113 #[test]
6130 #[test]
6137 #[test]
6144 #[test]
6151 #[test]
6158 #[test]
6167 #[test]
6174 #[test]
6181 #[test]
6188 #[test]
6195 #[test]
6202 #[test]
6209 #[test]
6232 #[test]
6255 #[test]
6263 #[test]
6270 #[test]
6294 #[test]
6384 #[test]
6389 // See that test for comments.
6456 #[test]
6463 #[test]
6488 #[test]
6494 #[test]
6500 #[test]
6506 #[test]
6512 #[test]
6518 #[test]
6520 // test that the methods of `Cow` are usable in a const context
6552 #[test]
6557 #[test]
6582 #[test]
6604 #[test]
6609 #[test]
6622 #[test]
6634 #[test]
6645 #[test]
6690 #[test]
6702 #[test]
6717 #[test]
6725 #[test]
6739 #[test]
6753 #[test]
6778 #[test]
6791 #[test]
6813 #[test]
6820 #[test]
6837 #[test]
6852 #[test]
6881 #[test]
6898 #[test]
6915 #[test]
6933 #[test]
6945 #[test]
6978 #[test]
6986 #[test]
6997 #[test]
7020 #[test]
7040 #[test]
7057 #[test]
7063 #[test]
7070 #[test]
7077 #[test]
7084 #[test]
7091 #[test]
7098 #[test]
7105 #[test]
7112 #[test]
7122 #[test]
7132 #[test]
7142 #[test]
7153 #[test]
7164 #[test]
7175 #[test]
7186 #[test]
7193 #[test]
7212 #[test]
7235 #[test]
7252 #[test]
7262 #[test]
7269 #[test]
7276 #[test]
7283 #[test]
7321 #[test]
7331 #[test]
7343 #[test]
7351 #[test]
7359 #[test]
7368 #[test]
7376 #[test]
7384 #[test]
7391 #[test]
7400 #[test]
7410 #[test]
7422 #[test]
7434 #[test]
7445 #[test]
7453 #[test]
7458 #[test]
7476 #[test]
7501 #[test]
7510 #[test]
7522 #[test]
7543 #[test]
7558 #[test]
7582 #[test]
7627 #[test]
7637 #[test]
7655 #[test]
7671 #[test]
7686 #[test]
7702 #[test]
7724 #[test]
7746 #[test]
7769 #[test]
7839 #[test]
7891 #[test]
7941 #[test]
7949 #[test]
7973 #[test]
8091 #[test]
8096 // See that test for comments.
8189 #[test]
8199 // invalidate references into the vector (such as `v0`). This test also
8201 // Note that this test does *not* constitute a stable guarantee that all these functions do not
8273 // Smoke test that would fire even outside Miri if an actual relocation happened.
8291 #[test]
8319 // This test will likely fail if you change the capacities used in
8321 #[test]
8446 #[test]
8465 #[test]
8488 #[test]
8526 #[test]
8567 #[test]
8584 #[test]
8597 #[test]
8609 #[test]
8623 #[test]
8631 #[test]
8639 #[test]
8647 #[test]
8654 #[test]
8662 #[test]
8670 #[test]
8679 #[test]
8688 #[test]
8697 #[test]
8706 #[test]
8715 #[test]
8732 #[test]
8752 #[test]
8805 // Regression test for issue #82533
8806 #[test]
8898 #[test]
8913 #[test]
8943 #[test]
8966 #[test]
9008 #[test]
9042 #[test]
9061 #[test]
9073 #[test]
9086 #[test]
9104 #[test]
9111 #[test]
9127 #[test]
9148 #[test]
9170 #[test]
9207 #[test]
9222 #[test]
9267 #[test]
9292 #[test]
9316 #[test]
9323 #[test]
9335 #[test]
9345 #[test]
9355 #[test]
9365 #[test]
9376 #[test]
9387 #[test]
9398 #[test]
9410 #[test]
9420 #[test]
9430 #[test]
9461 #[test]
9471 #[test]
9481 #[test]
9493 #[test]
9504 #[test]
9512 #[test]
9527 #[test]
9542 #[test]
9552 #[test]
9560 #[test]
9567 #[test]
9612 #[test]
9636 #[test]
9711 #[test]
9753 #[test]
9788 #[test]
9823 #[test]
9837 #[test]
9850 #[test]
9859 #[test]
9878 #[test]
9885 #[test]
9902 #[test]
9910 #[test]
9917 #[test]
9941 #[test]
9955 #[test]
9969 #[test]
9987 #[test]
9994 #[test]
10003 #[test]
10012 #[test]
10023 #[test]
10033 #[test]
10042 #[test]
10054 #[test]
10063 #[test]
10069 #[test]
10075 #[test]
10095 #[test]
10115 #[test]
10135 #[test]
10155 #[test]
10175 #[test]
10191 #[test]
10207 #[test]
10225 #[test]
10242 #[test]
10257 #[test]
10264 #[test]
10281 #[test]
10288 #[test]
10305 #[test]
10312 #[test]
10329 #[test]
10336 #[test]
10353 #[test]
10360 #[test]
10367 #[test]
10392 #[test]
10405 #[test]
10414 #[test]
10422 #[test]
10450 #[test]
10489 #[test]
10501 #[test]
10515 #[test]
10529 #[test]
10545 #[test]
10554 #[test]
10564 #[test]
10577 #[test]
10589 #[test]
10596 #[test]
10609 #[test]
10621 #[test]
10628 #[test]
10641 #[test]
10653 #[test]
10660 #[test]
10673 #[test]
10685 #[test]
10692 #[test]
10702 #[test]
10709 #[test]
10718 #[test]
10726 #[test]
10772 #[test]
10780 #[test]
10788 #[test]
10919 macro_rules! test {
10968 #[test]
11011 test!(input, sort_by);
11012 test!(input, sort_unstable_by);
11021 #[test]
11029 #[test]
11032 // This test comprehensively checks the passing static and dynamic semantics
11148 #[test]
11177 #[test]
11217 #[test]
11282 #[test]
11304 #[test]
11313 #[test]
11323 #[test]
11330 #[test]
11358 #[test]
11363 #[test]
11368 #[test]
11378 #[test]
11387 #[test]
11397 #[test]
11438 #[test]
11446 #[test]
11454 #[test]
11462 #[test]
11497 #[test]
11517 #[test]
11531 #[test]
11554 #[test]
11577 #[test]
11635 #[test]
11701 #[test]
11716 #[test]
11733 #[test]
11754 #[test]
11773 #[test]
11791 #[test]
11793 // test that two deques hash equal even if elements are laid out differently
11810 #[test]
11812 // test that two deques are equal even if elements are laid out differently
11837 #[test]
11850 #[test]
11855 let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
11856 assert_eq!(format!("{:?}", ringbuf), "[\"just\", \"one\", \"test\", \"more\"]");
11859 #[test]
11881 #[test]
11907 #[test]
11931 #[test]
11964 #[test]
11966 // test growth path A
11977 // test growth path B
11992 // test growth path C
12008 #[test]
12040 #[test]
12063 #[test]
12075 #[test]
12103 #[test]
12131 #[test]
12152 #[test]
12238 #[test]
12253 #[test]
12262 #[test]
12288 #[test]
12308 #[test]
12329 #[test]
12352 #[test]
12467 #[test]
12472 // See that test for comments.
12564 #[test]
12622 #[test]
12641 #[test]
12660 #[test]
12678 #[test]
12696 #[test]
12701 #[test]
12707 #[test]
12713 #[test]
12719 #[test]
12727 #[test]
12740 #[test]
12748 #[test]
12761 #[test]
12774 #[test]
12787 #[test]
12795 #[test]
12828 #[test]
12867 #[test]
12890 #[test]
12898 #[test]
12906 #[test]
12924 #[test]
12954 #[test]
12965 #[test]
13005 #[test]
13188 // test that trailing commas are acceptable
13189 format!("{}", "test",);
13190 format!("{foo}", foo = "test",);
13193 // Basic test to make sure that we can invoke the `write!` macro with an
13195 #[test]
13213 // can do with them just yet (to test the output)
13214 #[test]
13219 println!("this is a {}", "test");
13224 // can do with them just yet (to test the output)
13225 #[test]
13231 let _ = write!(w, "{}", format_args!("test"));
13232 let _ = write!(w, "{}", format_args!("{test}", test = 3));
13243 #[test]
13260 #[test]
13274 #[test]
13289 #[test]
13301 #[test]
13311 #[test]
13321 #[test]
13338 #[test]
13348 #[test]
13356 #[test]
13378 #[test]
13400 #[test]
13407 #[test]
13419 #[test]
13431 #[test]
13444 #[test]
13466 #[test]
13498 #[test]
13515 #[test]
13527 #[test]
13533 #[test]
13539 #[test]
13545 #[test]
13556 #[test]
13565 #[test]
13574 #[test]
13605 #[test]
13630 #[test]
13641 #[test]
13652 #[test]
13669 #[test]
13690 // old binaryheap failed this test
13697 #[test]
13733 // since it's a fuzzy test, run several tries.
13776 #[test]
13797 #[test]
13809 /// This test might give a false positive in case the box realocates, but the alocator keeps the
13814 #[test]
13825 #[test]
13834 #[test]
13839 #[test]
13911 #[cfg(not(test))]
13929 // HACK(japaric): with cfg(test) the inherent `[T]::into_vec` method, which is
13931 // `slice::into_vec` function which is only available with cfg(test)
13933 #[cfg(test)]
13978 /// format!("test");
13984 #[cfg_attr(not(test), rustc_diagnostic_item = "format_macro")]
14005 #[cfg(not(test))]
14010 #[cfg(not(test))]
14017 #[cfg(test)]
14049 #[cfg(not(test))]
14052 #[cfg(test)]
14158 #[cfg(not(test))]
14222 #[cfg(not(test))]
14311 #[cfg(not(test))]
14322 #[cfg_attr(not(test), lang = "box_free")]
14361 #[cfg(not(test))]
14370 // For alloc test `std::alloc::handle_alloc_error` can be used directly.
14371 #[cfg(test)]
14374 #[cfg(not(any(target_os = "hermit", test)))]
14438 #[cfg(test)]
14995 // Many of the usings in this module are only used in the test configuration.
15194 #[cfg(not(test))]
15584 #[test]
15603 #[test]
15616 #[test]
15643 #[test]
15655 #[test]
15672 #[test]
15694 #[test]
15712 #[test]
15736 #[test]
15760 #[test]
15782 #[test]
15796 #[test]
15803 #[test]
15811 #[test]
15824 #[test]
15832 #[test]
15843 #[test]
15860 #[test]
15886 #[test]
15898 #[test]
15907 #[test]
15909 // If/when custom thin DSTs exist, this test should be updated to use one
15924 #[test]
15931 #[test]
15937 #[test]
15947 #[test]
15970 #[test]
15977 #[test]
15985 #[test]
15996 #[test]
16019 #[test]
16027 #[test]
16037 #[test]
16045 #[test]
16056 #[test]
16066 #[test]
16074 #[test]
16094 #[test]
16106 #[test]
16123 #[test]
16144 #[test]
16448 #[cfg_attr(not(test), rustc_diagnostic_item = "string_type")]
16585 // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is
16590 #[cfg(test)]
16592 panic!("not available with cfg(test)");
17140 /// # process_data("rust").expect("why is the test harness OOMing on 4 bytes?");
17178 /// # process_data("rust").expect("why is the test harness OOMing on 4 bytes?");
18412 #[cfg_attr(not(test), rustc_diagnostic_item = "ToString")]
18537 // note: test pulls in libstd, which causes errors here
18538 #[cfg(not(test))]
18849 #[cfg_attr(not(test), rustc_diagnostic_item = "ToOwned")]
19364 test(no_crate_inject, attr(allow(unused_variables), deny(warnings)))
19374 #![cfg_attr(not(test), feature(generator_trait))]
19375 #![cfg_attr(test, feature(test))]
19376 #![cfg_attr(test, feature(new_uninit))]
19449 #[cfg(test)]
19452 #[cfg(test)]
19453 extern crate test;
19466 // duplicating the lang-items when building in test cfg; but also need
19468 #[cfg(not(test))]
19470 #[cfg(test)]
19487 #[cfg(test)]
19740 #[cfg(not(test))]
19742 #[cfg(test)]
19768 #[cfg(test)]
19791 #[cfg_attr(not(test), rustc_diagnostic_item = "Rc")]
22052 // Many of the usings in this module are only used in the test configuration.
22054 #![cfg_attr(test, allow(unused_imports, dead_code))]
22103 #[cfg(test)]
22108 #[cfg(test)]
22111 // HACK(japaric): With cfg(test) `impl [T]` is not available, these three
22114 // `test_permutations` test
22196 #[cfg(not(test))]
22605 #[cfg(not(test))]
22778 #[cfg(not(test))]
22783 #[cfg(test)]
23304 #[cfg(test)]
23493 #[cfg_attr(not(test), rustc_diagnostic_item = "Arc")]
25878 //! format!("{argument}", argument = "test"); // => "test"
26394 #[test]
26402 #[test]
26408 #[test]
26416 #[test]
26422 #[test]
26429 #[test]
26437 #[test]
26450 #[test]
26464 #[test]
26481 #[test]
26498 #[test]
26525 #[test]
26537 #[test]
26554 #[test]
26576 #[test]
26594 #[test]
26618 #[test]
26631 #[test]
26655 #[test]
26678 #[test]
26692 #[test]
26698 #[test]
26704 #[test]
26706 // If/when custom thin DSTs exist, this test should be updated to use one
26721 #[test]
26728 #[test]
26734 #[test]
26744 #[test]
26751 #[test]
26759 #[test]
26770 #[test]
26793 #[test]
26801 #[test]
26811 #[test]
26819 #[test]
26830 #[test]
26840 #[test]
26848 #[test]
26868 #[test]
26880 #[test]
26898 #[test]
26920 #[test]
26970 #[cfg(test)]
26982 #[cfg_attr(not(test), rustc_diagnostic_item = "LinkedList")]
28812 #[test]
28869 #[test]
28912 #[test]
28926 #[test]
28936 #[test]
28955 #[test]
28963 // test all splits
29012 #[test]
29024 #[test]
29036 #[test]
29129 #[test]
29292 /// A blueprint for crash test dummy instances that monitor particular events.
29296 /// Crash test dummies are identified and ordered by an id, so they can be used
29308 /// Creates a crash test dummy design. The `id` determines order and equality of instances.
29318 /// Creates an instance of a crash test dummy that records what events it experiences
29934 #[cfg_attr(not(test), rustc_diagnostic_item = "BTreeMap")]
32011 #[cfg(test)]
32058 #[cfg(test)]
32230 #[cfg_attr(not(test), rustc_diagnostic_item = "BTreeSet")]
33747 #[cfg(test)]
34285 #[cfg(test)]
34295 #[test]
34312 #[test]
34368 #[test]
34400 #[test]
34416 #[test]
34452 #[test]
34516 #[test]
34528 #[test]
34540 #[test]
34556 #[test]
34568 #[test]
34576 #[test]
34614 #[test]
34625 #[test]
34636 #[test]
34656 #[test]
34679 #[test]
34688 #[test]
34708 #[test]
34719 #[test]
34733 #[test]
34761 #[test]
34924 #[test]
34948 #[test]
34983 // and the test cases using this function explore slightly different trees.
34989 #[test]
35001 #[test]
35013 #[test]
35029 #[test]
35698 // during insertion, otherwise other test cases may fail or be less useful.
35699 #[test]
35736 #[test]
35746 #[test]
35754 #[test]
35807 #[test]
35893 #[test]
35900 fn test<T>(size: usize, mut iter: T)
35911 test(size, map.iter().map(|(&k, &v)| (k, v)));
35912 test(size, map.iter_mut().map(|(&k, &mut v)| (k, v)));
35913 test(size, map.into_iter());
35916 #[test]
35923 fn test<T>(size: usize, mut iter: T)
35934 test(size, map.iter().rev().map(|(&k, &v)| (k, v)));
35935 test(size, map.iter_mut().rev().map(|(&k, &mut v)| (k, v)));
35936 test(size, map.into_iter().rev());
35986 #[test]
36010 #[test]
36017 #[test]
36032 #[test]
36049 #[test]
36064 #[test]
36071 fn test<T>(size: usize, mut iter: T)
36087 test(size, map.iter().map(|(&k, &v)| (k, v)));
36088 test(size, map.iter_mut().map(|(&k, &mut v)| (k, v)));
36089 test(size, map.into_iter());
36092 #[test]
36137 #[test]
36196 #[test]
36216 #[test]
36285 #[test]
36293 #[test]
36300 #[test]
36307 #[test]
36314 #[test]
36321 #[test]
36328 #[test]
36335 #[test]
36347 #[test]
36387 #[test]
36393 fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<&u32>, max: Bound<&u32>) {
36403 test(&map, size, Included(&0), Excluded(&size));
36404 test(&map, size, Unbounded, Excluded(&size));
36405 test(&map, size, Included(&0), Included(&(size - 1)));
36406 test(&map, size, Unbounded, Included(&(size - 1)));
36407 test(&map, size, Included(&0), Unbounded);
36408 test(&map, size, Unbounded, Unbounded);
36411 #[test]
36425 #[test]
36446 #[test]
36468 #[test]
36482 #[test]
36490 // Explicitly consumes the iterator, where most test cases drop it instantly.
36491 #[test]
36499 // Explicitly consumes the iterator, where most test cases drop it instantly.
36500 #[test]
36510 #[test]
36527 #[test]
36542 #[test]
36551 #[test]
36562 #[test]
36573 #[test]
36582 #[test]
36591 #[test]
36602 #[test]
36613 #[test]
36622 #[test]
36630 #[test]
36639 #[test]
36650 #[test]
36661 #[test]
36672 #[test]
36683 #[test]
36692 #[test]
36712 #[test]
36738 #[test]
36770 #[test]
36843 #[test]
36895 #[test]
36912 #[test]
36936 // This test's only purpose is to ensure that zero-sized keys with nonsensical orderings
36939 #[test]
36972 #[test]
36986 #[test]
37009 #[test]
37054 #[test]
37083 #[test]
37353 #[test]
37372 #[test]
37391 #[test]
37416 #[test]
37426 #[test]
37444 #[test]
37498 #[test]
37517 #[test]
37543 #[test]
37557 #[test]
37573 #[test]
37588 #[test]
37603 #[test]
37622 #[test]
37639 #[test]
37662 #[test]
37680 #[test]
37692 #[test]
37704 #[test]
37718 #[test]
39628 #[cfg(test)]
39673 #[test]
39697 #[test]
39723 #[test]
40412 #[cfg(test)]
40438 #[cfg_attr(not(test), rustc_diagnostic_item = "vecdeque_type")]
41037 /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");
41075 /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");
43466 fn bench_push_back_100(b: &mut test::Bencher) {
43479 fn bench_push_front_100(b: &mut test::Bencher) {
43492 fn bench_pop_back_100(b: &mut test::Bencher) {
43499 test::black_box(deq.pop_back());
43506 fn bench_pop_front_100(b: &mut test::Bencher) {
43513 test::black_box(deq.pop_front());
43518 #[test]
43520 fn test(back: bool) {
43521 // This test checks that every single combination of tail position and length is tested.
43555 test(true);
43556 test(false);
43559 #[test]
43561 // This test checks that every single combination of tail position, length, and
43567 // this test isn't covering what it wants to
43593 #[test]
43615 #[test]
43634 #[test]
43674 #[test]
43688 #[test]
43690 // Another test case for #79808, taken from #80293.
43703 #[test]
43705 // This test checks that every single combination of tail position, length, and
43711 // this test isn't covering what it wants to
43741 #[test]
43767 #[test]
43801 #[test]
43836 #[test]
43838 // This test checks that every single combination of head and tail position,
43844 // this test isn't covering what it wants to
43868 #[test]
43870 // This test checks that every single combination of tail position, length, and
43876 // this test isn't covering what it wants to
43907 #[test]
43928 #[test]
43938 #[test]
44003 #[test]
44027 #[test]
44062 #[test]
44079 #[test]
44517 #[cfg_attr(not(test), rustc_diagnostic_item = "BinaryHeap")]
46075 #[cfg(not(test))]
46079 #[cfg(test)]
46650 #[cfg(not(test))]
46655 // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is
46657 // `slice::to_vec` function which is only available with cfg(test)
46659 #[cfg(test)]
47181 #[cfg_attr(not(test), rustc_diagnostic_item = "vec_type")]
47647 /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");
47689 /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");
49144 #[cfg(not(test))]
49150 // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is
49152 // `slice::to_vec` function which is only available with cfg(test)
49154 #[cfg(test)]
49533 #[cfg(not(test))]
49537 #[cfg(test)]
49552 #[cfg(not(test))]
49556 #[cfg(test)]
49564 #[cfg(not(test))]
49575 #[cfg(test)]
49605 // note: test pulls in libstd, which causes errors here
49606 #[cfg(not(test))]
49623 // note: test pulls in libstd, which causes errors here
49624 #[cfg(not(test))]
49770 /// The filter test predicate.
49772 /// A flag that indicates a panic has occurred in the filter test predicate.
50143 extern crate test;
50145 use test::Bencher;
50147 #[test]
51869 #[test]
51873 // Writing a test of integration between third-party
51914 #[test]
51939 // exponentially. At the time of writing this test grow
51955 #[test]
51965 #[test]
51990 #[test]
52009 #[test]
52015 #[test]
52027 #[test]
52056 #[test]
52063 #[test]
52070 #[test]
52077 #[test]
52085 #[test]