Lines Matching defs:foo
3501 assert!("" <= "foo");
3502 assert!("foo" <= "foo");
3503 assert_ne!("foo", "bar");
4273 assert_eq!(" *** foo *** ".trim_start_matches(v), " *** foo *** ");
4275 assert_eq!(" *** foo *** ".trim_start_matches(chars), "foo *** ");
4277 assert_eq!("foo *** ".trim_start_matches(chars), "foo *** ");
4288 assert_eq!(" *** foo *** ".trim_end_matches(v), " *** foo *** ");
4290 assert_eq!(" *** foo *** ".trim_end_matches(chars), " *** foo");
4292 assert_eq!(" *** foo".trim_end_matches(chars), " *** foo");
4303 assert_eq!(" *** foo *** ".trim_matches(v), " *** foo *** ");
4305 assert_eq!(" *** foo *** ".trim_matches(chars), "foo");
4307 assert_eq!("foo".trim_matches(chars), "foo");
5420 ("foo.bar.baz", '.') -> ["foo", "bar", "baz"];
5421 ("foo::bar::baz", "::") -> ["foo", "bar", "baz"];
5428 ("foo;bar;baz;", ';') -> ["foo", "bar", "baz"];
5449 ("foo::bar::baz", 2, "::") -> ["foo", "bar::baz"];
5456 ("foo::bar::baz", 2, "::") -> ["baz", "foo::bar"];
5465 fn foo<'a, P>(p: P)
5474 foo::<&str>("x");
5507 let foo = &A as *const u8;
5508 assert_eq!(foo, C);
5703 String::from("\u{FFFD}foo\u{FFFD}\u{FFFD}bar").into_cow()
5709 String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}baz").into_cow()
5715 String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}\u{FFFD}baz").into_cow()
5721 String::from("\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}foo\u{10000}bar").into_cow()
5728 String::from("\u{FFFD}\u{FFFD}\u{FFFD}foo\u{FFFD}\u{FFFD}\u{FFFD}bar").into_cow()
6049 assert_eq!(s, "ệfooยbar");
6067 assert_eq!("foo", &s[..3]);
6257 let mut a = "foo".to_string();
6917 let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
6920 assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
6922 let mut vec = vec![("foo", 1), ("foo", 2), ("bar", 3), ("bar", 4), ("bar", 5)];
6930 assert_eq!(vec, [("foo", 3), ("bar", 12)]);
10503 assert!(b"foobar".starts_with(b"foo"));
10506 assert!(!b"foo".starts_with(b"foobar"));
10511 assert!(!empty.starts_with(b"foo"));
10519 assert!(!b"foobar".ends_with(b"foo"));
10520 assert!(!b"foo".ends_with(b"foobar"));
10525 assert!(!empty.ends_with(b"foo"));
13029 t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\"");
13030 t!(format!("{:?}", "foo\n\"bar\"\r\n\'baz\'\t\\qux\\"), r#""foo\n\"bar\"\r\n'baz'\t\\qux\\""#);
13031 t!(format!("{:?}", "foo\0bar\x01baz\u{7f}q\u{75}x"), r#""foo\u{0}bar\u{1}baz\u{7f}qux""#);
13035 t!(format!("{}", "foo"), "foo");
13036 t!(format!("{}", "foo".to_string()), "foo");
13048 t!(format!("foo {} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");
13050 t!(format!("{foo} {bar}", foo = 0, bar = 1), "0 1");
13051 t!(format!("{foo} {1} {bar} {0}", 0, 1, foo = 2, bar = 3), "2 1 3 0");
13190 format!("{foo}", foo = "test",);
13201 let _ = write!(w, "{foo}", foo = 4);
13204 let _ = writeln!(w, "{foo}", foo = "bar");
13220 println!("{foo}", foo = "bar");
13247 fn foo() -> isize {
13255 format!("{} {} {a} {b} {} {c}", foo(), foo(), foo(), a = foo(), b = foo(), c = foo()),
13264 fn foo() -> isize {
13271 assert_eq!(format!("{0} {0} {0} {a} {a} {a}", foo(), a = foo()), "1 1 1 2 2 2".to_string());
15263 /// let s = "foo foo 123 foo";
15264 /// assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));
15265 /// assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));
15266 /// assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1));
15677 let arc: Arc<str> = Arc::from("foo");
15682 assert_eq!(unsafe { &*ptr }, "foo");
15717 let arc: Arc<str> = Arc::from("foo");
15723 assert_eq!(unsafe { &*ptr }, "foo");
15926 let foo = 123;
15927 let foo_arc = Arc::from(foo);
15933 let foo: Weak<usize> = Weak::new();
15934 assert!(foo.upgrade().is_none());
15972 let r: Arc<str> = Arc::from("foo");
15974 assert_eq!(&r[..], "foo");
16013 &[Fail(0, "foo".to_string()), Fail(1, "bar".to_string()), Fail(2, "baz".to_string())];
16031 let s = String::from("foo").into_boxed_str();
16034 assert_eq!(&r[..], "foo");
16949 /// let s = String::from("foo");
16951 /// assert_eq!("foo", s.as_str());
16986 /// let mut s = String::from("foo");
17192 /// let mut s = String::from("foo");
17217 /// let mut s = String::from("foo");
17319 /// let mut s = String::from("foo");
17353 /// let mut s = String::from("foo");
17524 /// assert_eq!("foo", s);
17567 /// s.insert_str(0, "foo");
17620 /// let a = String::from("foo");
17695 /// let mut s = String::from("foo");
19078 /// let mut cow = Cow::Borrowed("foo");
19567 //! let foo = Rc::new(vec![1.0, 2.0, 3.0]);
19569 //! let a = foo.clone();
19570 //! let b = Rc::clone(&foo);
19571 //! // a and b both point to the same memory location as foo.
19576 //! this code is creating a new reference rather than copying the whole content of foo.
20535 /// Rc::get_mut_unchecked(&mut x).push_str("foo")
20537 /// assert_eq!(*x, "foo");
20902 /// let foo = Rc::new(Foo);
20903 /// let foo2 = Rc::clone(&foo);
20905 /// drop(foo); // Doesn't print anything
21774 /// let foo = Rc::new(Foo);
21775 /// let weak_foo = Rc::downgrade(&foo);
21779 /// drop(foo); // Prints "dropped!"
23392 /// let foo = Arc::new(vec![1.0, 2.0, 3.0]);
23394 /// let a = foo.clone();
23395 /// let b = Arc::clone(&foo);
23396 /// // a, b, and foo are all Arcs that point to the same memory location
23626 /// let foo = Arc::new_cyclic(|me| Foo {
24733 /// Arc::get_mut_unchecked(&mut x).push_str("foo")
24735 /// assert_eq!(*x, "foo");
24795 /// let foo = Arc::new(Foo);
24796 /// let foo2 = Arc::clone(&foo);
24798 /// drop(foo); // Doesn't print anything
25282 /// let foo = Arc::new(Foo);
25283 /// let weak_foo = Arc::downgrade(&foo);
25287 /// drop(foo); // Prints "dropped!"
26225 //! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
26559 let rc: Rc<str> = Rc::from("foo");
26564 assert_eq!(unsafe { &*ptr }, "foo");
26599 let arc: Rc<str> = Rc::from("foo");
26605 assert_eq!(unsafe { &*ptr }, "foo");
26694 let foo = Rc::new(75);
26695 assert_eq!(format!("{:?}", foo), "75");
26700 let foo: Rc<[i32]> = Rc::new([1, 2, 3]);
26701 assert_eq!(foo, foo.clone());
26723 let foo = 123;
26724 let foo_rc = Rc::from(foo);
26730 let foo: Weak<usize> = Weak::new();
26731 assert!(foo.upgrade().is_none());
26746 let r: Rc<str> = Rc::from("foo");
26748 assert_eq!(&r[..], "foo");
26787 &[Fail(0, "foo".to_string()), Fail(1, "bar".to_string()), Fail(2, "baz".to_string())];
26805 let s = String::from("foo").into_boxed_str();
26808 assert_eq!(&r[..], "foo");
27512 /// dl.push_front("foo");
34696 y.insert("foo");
34704 assert_eq!(z.next().unwrap(), (&11, &("foo")));
48062 /// let mut v = vec!["foo", "bar", "baz", "qux"];
48065 /// assert_eq!(v, ["foo", "qux", "baz"]);
48067 /// assert_eq!(v.swap_remove(0), "foo");
48324 /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
48328 /// assert_eq!(vec, ["foo", "bar", "baz", "bar"]);