1use std::{
2 borrow::{Borrow, BorrowMut, Cow},
3 cmp::Ordering,
4 convert::Infallible,
5 ffi::OsStr,
6 fmt::{self, Debug, Display},
7 hash::{Hash, Hasher},
8 net::{SocketAddr, ToSocketAddrs},
9 ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut},
10 path::Path,
11 slice::SliceIndex,
12 str::{FromStr, Utf8Error},
13};
14
15use bytes::{Bytes, BytesMut};
16
17#[derive(Clone, Default, PartialEq, Eq)]
28pub struct BytesString {
29 pub(crate) bytes: BytesMut,
30}
31
32impl BytesString {
33 pub fn new() -> Self {
45 Self {
46 bytes: BytesMut::new(),
47 }
48 }
49
50 pub fn with_capacity(capacity: usize) -> Self {
66 Self {
67 bytes: BytesMut::with_capacity(capacity),
68 }
69 }
70
71 pub fn len(&self) -> usize {
83 self.bytes.len()
84 }
85
86 pub fn capacity(&self) -> usize {
98 self.bytes.capacity()
99 }
100
101 pub fn reserve(&mut self, additional: usize) {
120 self.bytes.reserve(additional);
121 }
122
123 pub fn split_off(&mut self, at: usize) -> Self {
142 Self {
143 bytes: self.bytes.split_off(at),
144 }
145 }
146
147 pub fn as_bytes(&self) -> &[u8] {
159 self.bytes.as_ref()
160 }
161
162 pub fn is_empty(&self) -> bool {
174 self.bytes.is_empty()
175 }
176
177 pub fn truncate(&mut self, new_len: usize) {
208 if new_len <= self.len() {
209 assert!(self.is_char_boundary(new_len));
210 self.bytes.truncate(new_len);
211 }
212 }
213
214 pub fn clear(&mut self) {
228 self.bytes.clear();
229 }
230
231 pub fn push(&mut self, ch: char) {
245 let mut buf = [0; 4];
246 let bytes = ch.encode_utf8(&mut buf);
247 self.bytes.extend_from_slice(bytes.as_bytes());
248 }
249
250 pub fn push_str(&mut self, s: &str) {
264 self.bytes.extend_from_slice(s.as_bytes());
265 }
266
267 pub fn as_str(&self) -> &str {
279 unsafe { std::str::from_utf8_unchecked(&self.bytes) }
280 }
281
282 pub fn as_mut_str(&mut self) -> &mut str {
296 unsafe { std::str::from_utf8_unchecked_mut(&mut self.bytes) }
297 }
298
299 pub fn into_bytes(self) -> BytesMut {
314 self.bytes
315 }
316
317 pub unsafe fn from_bytes_unchecked(bytes: BytesMut) -> Self {
325 Self { bytes }
326 }
327
328 pub fn from_utf8(bytes: BytesMut) -> Result<Self, Utf8Error> {
343 std::str::from_utf8(bytes.as_ref())?;
344
345 Ok(Self { bytes })
346 }
347
348 pub fn from_utf8_slice(bytes: &[u8]) -> Result<Self, Utf8Error> {
363 std::str::from_utf8(bytes)?;
364
365 Ok(Self {
366 bytes: BytesMut::from(bytes),
367 })
368 }
369}
370
371impl Deref for BytesString {
372 type Target = str;
373
374 fn deref(&self) -> &Self::Target {
375 self.as_str()
376 }
377}
378
379impl DerefMut for BytesString {
380 fn deref_mut(&mut self) -> &mut Self::Target {
381 self.as_mut_str()
382 }
383}
384
385impl AsRef<str> for BytesString {
386 fn as_ref(&self) -> &str {
387 self.as_str()
388 }
389}
390
391impl Borrow<str> for BytesString {
392 fn borrow(&self) -> &str {
393 self.as_str()
394 }
395}
396
397impl From<String> for BytesString {
398 fn from(s: String) -> Self {
399 Self {
400 bytes: Bytes::from(s.into_bytes()).into(),
401 }
402 }
403}
404
405impl From<&str> for BytesString {
406 fn from(s: &str) -> Self {
407 Self {
408 bytes: BytesMut::from(s),
409 }
410 }
411}
412
413impl From<BytesString> for BytesMut {
414 fn from(s: BytesString) -> Self {
415 s.bytes
416 }
417}
418
419impl From<BytesString> for Bytes {
420 fn from(s: BytesString) -> Self {
421 s.bytes.into()
422 }
423}
424
425impl From<char> for BytesString {
426 fn from(ch: char) -> Self {
427 let mut bytes = BytesString::with_capacity(ch.len_utf8());
428 bytes.push(ch);
429 bytes
430 }
431}
432
433impl PartialEq<str> for BytesString {
434 fn eq(&self, other: &str) -> bool {
435 self.as_str() == other
436 }
437}
438
439impl PartialEq<&'_ str> for BytesString {
440 fn eq(&self, other: &&str) -> bool {
441 self.as_str() == *other
442 }
443}
444
445impl PartialEq<Cow<'_, str>> for BytesString {
446 fn eq(&self, other: &Cow<'_, str>) -> bool {
447 self.as_str() == *other
448 }
449}
450
451impl PartialEq<BytesString> for str {
452 fn eq(&self, other: &BytesString) -> bool {
453 self == other.as_str()
454 }
455}
456
457impl PartialEq<BytesString> for &'_ str {
458 fn eq(&self, other: &BytesString) -> bool {
459 *self == other.as_str()
460 }
461}
462
463impl PartialEq<BytesString> for Bytes {
464 fn eq(&self, other: &BytesString) -> bool {
465 self == other.as_bytes()
466 }
467}
468
469impl PartialEq<String> for BytesString {
470 fn eq(&self, other: &String) -> bool {
471 self.as_str() == other
472 }
473}
474
475impl PartialEq<BytesString> for String {
476 fn eq(&self, other: &BytesString) -> bool {
477 self == other.as_str()
478 }
479}
480
481impl Add<&str> for BytesString {
482 type Output = Self;
483
484 fn add(mut self, other: &str) -> Self::Output {
485 self += other;
486 self
487 }
488}
489
490impl AddAssign<&str> for BytesString {
491 fn add_assign(&mut self, other: &str) {
492 self.push_str(other);
493 }
494}
495
496impl Add<BytesString> for BytesString {
497 type Output = Self;
498
499 fn add(mut self, other: BytesString) -> Self::Output {
500 self += other;
501 self
502 }
503}
504
505impl AddAssign<BytesString> for BytesString {
506 fn add_assign(&mut self, other: BytesString) {
507 self.bytes.extend(other.bytes);
508 }
509}
510
511impl AsMut<str> for BytesString {
512 fn as_mut(&mut self) -> &mut str {
513 self.as_mut_str()
514 }
515}
516
517impl AsRef<[u8]> for BytesString {
518 fn as_ref(&self) -> &[u8] {
519 self.as_bytes()
520 }
521}
522
523impl AsRef<OsStr> for BytesString {
524 fn as_ref(&self) -> &OsStr {
525 OsStr::new(self.as_str())
526 }
527}
528
529impl AsRef<Path> for BytesString {
530 fn as_ref(&self) -> &Path {
531 Path::new(self.as_str())
532 }
533}
534
535impl BorrowMut<str> for BytesString {
536 fn borrow_mut(&mut self) -> &mut str {
537 self.as_mut_str()
538 }
539}
540
541impl Debug for BytesString {
542 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
543 Debug::fmt(self.as_str(), f)
544 }
545}
546
547impl Display for BytesString {
548 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
549 Display::fmt(self.as_str(), f)
550 }
551}
552
553impl PartialOrd for BytesString {
554 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
555 Some(self.cmp(other))
556 }
557}
558
559impl Ord for BytesString {
560 fn cmp(&self, other: &Self) -> Ordering {
561 self.as_str().cmp(other.as_str())
562 }
563}
564
565impl<'a> Extend<&'a char> for BytesString {
566 fn extend<T: IntoIterator<Item = &'a char>>(&mut self, iter: T) {
567 self.extend(iter.into_iter().copied());
568 }
569}
570
571impl Extend<char> for BytesString {
572 fn extend<T: IntoIterator<Item = char>>(&mut self, iter: T) {
573 let mut buf = [0; 4];
574 for ch in iter {
575 let bytes = ch.encode_utf8(&mut buf);
576 self.bytes.extend_from_slice(bytes.as_bytes());
577 }
578 }
579}
580
581impl<'a> Extend<&'a str> for BytesString {
582 fn extend<T: IntoIterator<Item = &'a str>>(&mut self, iter: T) {
583 for s in iter {
584 self.push_str(s);
585 }
586 }
587}
588
589impl<'a, 'b> Extend<&'a &'b str> for BytesString {
590 fn extend<T: IntoIterator<Item = &'a &'b str>>(&mut self, iter: T) {
591 for s in iter {
592 self.push_str(s);
593 }
594 }
595}
596
597impl Extend<Box<str>> for BytesString {
598 fn extend<T: IntoIterator<Item = Box<str>>>(&mut self, iter: T) {
599 for s in iter {
600 self.push_str(&s);
601 }
602 }
603}
604
605impl<'a> Extend<Cow<'a, str>> for BytesString {
606 fn extend<T: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: T) {
607 for s in iter {
608 self.push_str(&s);
609 }
610 }
611}
612
613impl Extend<String> for BytesString {
614 fn extend<T: IntoIterator<Item = String>>(&mut self, iter: T) {
615 for s in iter {
616 self.push_str(&s);
617 }
618 }
619}
620
621impl<'a> Extend<&'a String> for BytesString {
622 fn extend<T: IntoIterator<Item = &'a String>>(&mut self, iter: T) {
623 for s in iter {
624 self.push_str(s);
625 }
626 }
627}
628
629impl Extend<BytesString> for BytesString {
630 fn extend<T: IntoIterator<Item = BytesString>>(&mut self, iter: T) {
631 for s in iter {
632 self.bytes.extend(s.bytes);
633 }
634 }
635}
636
637impl FromIterator<char> for BytesString {
638 fn from_iter<T: IntoIterator<Item = char>>(iter: T) -> Self {
639 let mut bytes = BytesString::new();
640 bytes.extend(iter);
641 bytes
642 }
643}
644
645impl<'a> FromIterator<&'a str> for BytesString {
646 fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self {
647 let mut bytes = BytesString::new();
648 bytes.extend(iter);
649 bytes
650 }
651}
652
653impl FromIterator<Box<str>> for BytesString {
654 fn from_iter<T: IntoIterator<Item = Box<str>>>(iter: T) -> Self {
655 let mut bytes = BytesString::new();
656 bytes.extend(iter);
657 bytes
658 }
659}
660
661impl<'a> FromIterator<Cow<'a, str>> for BytesString {
662 fn from_iter<T: IntoIterator<Item = Cow<'a, str>>>(iter: T) -> Self {
663 let mut bytes = BytesString::new();
664 bytes.extend(iter);
665 bytes
666 }
667}
668
669impl FromIterator<String> for BytesString {
670 fn from_iter<T: IntoIterator<Item = String>>(iter: T) -> Self {
671 let mut bytes = BytesString::new();
672 bytes.extend(iter);
673 bytes
674 }
675}
676
677impl FromIterator<BytesString> for BytesString {
678 fn from_iter<T: IntoIterator<Item = BytesString>>(iter: T) -> Self {
679 let mut bytes = BytesString::new();
680 bytes.extend(iter);
681 bytes
682 }
683}
684
685impl FromStr for BytesString {
686 type Err = Infallible;
687
688 fn from_str(s: &str) -> Result<Self, Self::Err> {
689 Ok(Self {
690 bytes: BytesMut::from(s),
691 })
692 }
693}
694
695impl<I> Index<I> for BytesString
696where
697 I: SliceIndex<str>,
698{
699 type Output = I::Output;
700
701 fn index(&self, index: I) -> &Self::Output {
702 self.as_str().index(index)
703 }
704}
705
706impl<I> IndexMut<I> for BytesString
707where
708 I: SliceIndex<str>,
709{
710 fn index_mut(&mut self, index: I) -> &mut Self::Output {
711 self.as_mut_str().index_mut(index)
712 }
713}
714
715impl ToSocketAddrs for BytesString {
716 type Iter = std::vec::IntoIter<SocketAddr>;
717
718 fn to_socket_addrs(&self) -> Result<Self::Iter, std::io::Error> {
719 self.as_str().to_socket_addrs()
720 }
721}
722
723impl Hash for BytesString {
725 fn hash<H: Hasher>(&self, state: &mut H) {
726 self.as_str().hash(state);
727 }
728}
729
730#[cfg(feature = "serde")]
731mod serde_impl {
732 use serde::{Deserialize, Deserializer, Serialize, Serializer};
733
734 use super::*;
735
736 impl<'de> Deserialize<'de> for BytesString {
737 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
738 where
739 D: Deserializer<'de>,
740 {
741 let s = String::deserialize(deserializer)?;
742 Ok(Self::from(s))
743 }
744 }
745
746 impl Serialize for BytesString {
747 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
748 where
749 S: Serializer,
750 {
751 serializer.serialize_str(self.as_str())
752 }
753 }
754}
755
756#[cfg(test)]
757mod tests {
758 use std::{
759 collections::{hash_map::DefaultHasher, HashMap},
760 hash::{Hash, Hasher},
761 };
762
763 use super::*;
764
765 #[test]
766 fn test_new() {
767 let s = BytesString::new();
768 assert!(s.is_empty());
769 assert_eq!(s.len(), 0);
770 assert_eq!(s.as_str(), "");
771 }
772
773 #[test]
774 fn test_with_capacity() {
775 let s = BytesString::with_capacity(10);
776 assert!(s.capacity() >= 10);
777 assert!(s.is_empty());
778 assert_eq!(s.len(), 0);
779 }
780
781 #[test]
782 fn test_from_str() {
783 let s = BytesString::from("hello");
784 assert_eq!(s.as_str(), "hello");
785 assert_eq!(s.len(), 5);
786 assert!(!s.is_empty());
787 }
788
789 #[test]
790 fn test_from_string() {
791 let original = String::from("hello world");
792 let s = BytesString::from(original);
793 assert_eq!(s.as_str(), "hello world");
794 assert_eq!(s.len(), 11);
795 }
796
797 #[test]
798 fn test_from_char() {
799 let s = BytesString::from('H');
800 assert_eq!(s.as_str(), "H");
801 assert_eq!(s.len(), 1);
802
803 let s = BytesString::from('한');
805 assert_eq!(s.as_str(), "한");
806 assert_eq!(s.len(), 3); }
808
809 #[test]
810 fn test_push() {
811 let mut s = BytesString::from("hello");
812 s.push(' ');
813 s.push('w');
814 assert_eq!(s.as_str(), "hello w");
815
816 s.push('한');
818 assert_eq!(s.as_str(), "hello w한");
819 }
820
821 #[test]
822 fn test_push_str() {
823 let mut s = BytesString::from("hello");
824 s.push_str(" world");
825 assert_eq!(s.as_str(), "hello world");
826
827 s.push_str("!");
828 assert_eq!(s.as_str(), "hello world!");
829
830 s.push_str(" 한국어");
832 assert_eq!(s.as_str(), "hello world! 한국어");
833 }
834
835 #[test]
836 fn test_clear() {
837 let mut s = BytesString::from("hello");
838 assert!(!s.is_empty());
839 s.clear();
840 assert!(s.is_empty());
841 assert_eq!(s.len(), 0);
842 assert_eq!(s.as_str(), "");
843 }
844
845 #[test]
846 fn test_truncate() {
847 let mut s = BytesString::from("hello world");
848 s.truncate(5);
849 assert_eq!(s.as_str(), "hello");
850
851 s.truncate(20);
853 assert_eq!(s.as_str(), "hello");
854
855 let mut s = BytesString::from("한국어");
857 s.truncate(6); assert_eq!(s.as_str(), "한국");
859 }
860
861 #[test]
862 #[should_panic]
863 fn test_truncate_panic_on_char_boundary() {
864 let mut s = BytesString::from("한국어");
865 s.truncate(1); }
867
868 #[test]
869 fn test_split_off() {
870 let mut s = BytesString::from("hello world");
871 let other = s.split_off(6);
872 assert_eq!(s.as_str(), "hello ");
873 assert_eq!(other.as_str(), "world");
874
875 let mut s = BytesString::from("hello");
877 let other = s.split_off(0);
878 assert_eq!(s.as_str(), "");
879 assert_eq!(other.as_str(), "hello");
880
881 let mut s = BytesString::from("hello");
883 let other = s.split_off(5);
884 assert_eq!(s.as_str(), "hello");
885 assert_eq!(other.as_str(), "");
886 }
887
888 #[test]
889 fn test_as_bytes() {
890 let s = BytesString::from("hello");
891 assert_eq!(s.as_bytes(), b"hello");
892
893 let s = BytesString::from("한국어");
894 assert_eq!(s.as_bytes(), "한국어".as_bytes());
895 }
896
897 #[test]
898 fn test_as_mut_str() {
899 let mut s = BytesString::from("hello");
900 s.as_mut_str().make_ascii_uppercase();
901 assert_eq!(s.as_str(), "HELLO");
902 }
903
904 #[test]
905 fn test_into_bytes() {
906 let s = BytesString::from("hello");
907 let bytes = s.into_bytes();
908 assert_eq!(bytes.as_ref(), b"hello");
909 }
910
911 #[test]
912 fn test_from_utf8() {
913 let bytes = BytesMut::from(&b"hello"[..]);
914 let s = BytesString::from_utf8(bytes).unwrap();
915 assert_eq!(s.as_str(), "hello");
916
917 let invalid_bytes = BytesMut::from(&[0xff, 0xfe][..]);
919 assert!(BytesString::from_utf8(invalid_bytes).is_err());
920 }
921
922 #[test]
923 fn test_from_utf8_slice() {
924 let s = BytesString::from_utf8_slice(b"hello").unwrap();
925 assert_eq!(s.as_str(), "hello");
926
927 assert!(BytesString::from_utf8_slice(&[0xff, 0xfe]).is_err());
929 }
930
931 #[test]
932 fn test_from_bytes_unchecked() {
933 let bytes = BytesMut::from(&b"hello"[..]);
934 let s = unsafe { BytesString::from_bytes_unchecked(bytes) };
935 assert_eq!(s.as_str(), "hello");
936 }
937
938 #[test]
939 fn test_reserve() {
940 let mut s = BytesString::from("hello");
941 let initial_capacity = s.capacity();
942 s.reserve(100);
943 assert!(s.capacity() >= initial_capacity + 100);
944 assert_eq!(s.as_str(), "hello"); }
946
947 #[test]
948 fn test_deref() {
949 let s = BytesString::from("hello world");
950 assert_eq!(s.len(), 11);
951 assert!(s.contains("world"));
952 assert!(s.starts_with("hello"));
953 assert!(s.ends_with("world"));
954 }
955
956 #[test]
957 fn test_partial_eq() {
958 let s = BytesString::from("hello");
959
960 assert_eq!(s, "hello");
962 assert_ne!(s, "world");
963
964 assert_eq!(s, String::from("hello"));
966 assert_ne!(s, String::from("world"));
967
968 assert_eq!(s, Cow::Borrowed("hello"));
970 assert_eq!(s, Cow::Owned(String::from("hello")));
971
972 assert_eq!(Bytes::from("hello"), s);
974 assert_ne!(Bytes::from("world"), s);
975
976 assert_eq!("hello", s);
978 assert_eq!(String::from("hello"), s);
979 }
980
981 #[test]
982 fn test_ordering() {
983 let s1 = BytesString::from("apple");
984 let s2 = BytesString::from("banana");
985 let s3 = BytesString::from("apple");
986
987 assert!(s1 < s2);
988 assert!(s2 > s1);
989 assert_eq!(s1, s3);
990 assert!(s1 <= s3);
991 assert!(s1 >= s3);
992 }
993
994 #[test]
995 fn test_hash() {
996 let s1 = BytesString::from("hello");
997 let s2 = BytesString::from("hello");
998 let s3 = BytesString::from("world");
999
1000 let mut hasher1 = DefaultHasher::new();
1001 let mut hasher2 = DefaultHasher::new();
1002 let mut hasher3 = DefaultHasher::new();
1003
1004 s1.hash(&mut hasher1);
1005 s2.hash(&mut hasher2);
1006 s3.hash(&mut hasher3);
1007
1008 assert_eq!(hasher1.finish(), hasher2.finish());
1009 assert_ne!(hasher1.finish(), hasher3.finish());
1010
1011 let mut str_hasher = DefaultHasher::new();
1013 "hello".hash(&mut str_hasher);
1014 assert_eq!(hasher1.finish(), str_hasher.finish());
1015 }
1016
1017 #[test]
1018 fn test_add() {
1019 let s1 = BytesString::from("hello");
1020 let s2 = s1 + " world";
1021 assert_eq!(s2.as_str(), "hello world");
1022
1023 let s3 = BytesString::from("foo");
1024 let s4 = BytesString::from("bar");
1025 let s5 = s3 + s4;
1026 assert_eq!(s5.as_str(), "foobar");
1027 }
1028
1029 #[test]
1030 fn test_add_assign() {
1031 let mut s = BytesString::from("hello");
1032 s += " world";
1033 assert_eq!(s.as_str(), "hello world");
1034
1035 let mut s1 = BytesString::from("foo");
1036 let s2 = BytesString::from("bar");
1037 s1 += s2;
1038 assert_eq!(s1.as_str(), "foobar");
1039 }
1040
1041 #[test]
1042 fn test_extend_char() {
1043 let mut s = BytesString::from("hello");
1044 s.extend(['!', ' ', '🎉'].iter());
1045 assert_eq!(s.as_str(), "hello! 🎉");
1046
1047 let mut s = BytesString::new();
1048 s.extend(['a', 'b', 'c']);
1049 assert_eq!(s.as_str(), "abc");
1050 }
1051
1052 #[test]
1053 fn test_extend_str() {
1054 let mut s = BytesString::from("hello");
1055 s.extend([" ", "world", "!"].iter());
1056 assert_eq!(s.as_str(), "hello world!");
1057
1058 let strings = vec![String::from("foo"), String::from("bar")];
1059 let mut s = BytesString::new();
1060 s.extend(&strings);
1061 assert_eq!(s.as_str(), "foobar");
1062 }
1063
1064 #[test]
1065 fn test_extend_bytes_string() {
1066 let mut s = BytesString::from("hello");
1067 let parts = vec![BytesString::from(" "), BytesString::from("world")];
1068 s.extend(parts);
1069 assert_eq!(s.as_str(), "hello world");
1070 }
1071
1072 #[test]
1073 fn test_from_iterator() {
1074 let s: BytesString = ['h', 'e', 'l', 'l', 'o'].into_iter().collect();
1075 assert_eq!(s.as_str(), "hello");
1076
1077 let s: BytesString = ["hello", " ", "world"].into_iter().collect();
1078 assert_eq!(s.as_str(), "hello world");
1079
1080 let strings = vec![String::from("foo"), String::from("bar")];
1081 let s: BytesString = strings.into_iter().collect();
1082 assert_eq!(s.as_str(), "foobar");
1083 }
1084
1085 #[test]
1086 fn test_from_str_trait() {
1087 let s: BytesString = "hello world".parse().unwrap();
1088 assert_eq!(s.as_str(), "hello world");
1089 }
1090
1091 #[test]
1092 fn test_index() {
1093 let s = BytesString::from("hello world");
1094 assert_eq!(&s[0..5], "hello");
1095 assert_eq!(&s[6..], "world");
1096 assert_eq!(&s[..5], "hello");
1097 assert_eq!(&s[6..11], "world");
1098 }
1099
1100 #[test]
1101 fn test_index_mut() {
1102 let mut s = BytesString::from("hello world");
1103 s[0..5].make_ascii_uppercase();
1104 assert_eq!(s.as_str(), "HELLO world");
1105 }
1106
1107 #[test]
1108 fn test_as_ref_implementations() {
1109 let s = BytesString::from("hello/world");
1110
1111 let str_ref: &str = s.as_ref();
1113 assert_eq!(str_ref, "hello/world");
1114
1115 let bytes_ref: &[u8] = s.as_ref();
1117 assert_eq!(bytes_ref, b"hello/world");
1118
1119 let os_str_ref: &OsStr = s.as_ref();
1121 assert_eq!(os_str_ref, OsStr::new("hello/world"));
1122
1123 let path_ref: &Path = s.as_ref();
1125 assert_eq!(path_ref, Path::new("hello/world"));
1126 }
1127
1128 #[test]
1129 fn test_borrow() {
1130 let s = BytesString::from("hello");
1131 let borrowed: &str = s.borrow();
1132 assert_eq!(borrowed, "hello");
1133
1134 let mut s = BytesString::from("hello");
1135 let borrowed_mut: &mut str = s.borrow_mut();
1136 borrowed_mut.make_ascii_uppercase();
1137 assert_eq!(s.as_str(), "HELLO");
1138 }
1139
1140 #[test]
1141 fn test_debug() {
1142 let s = BytesString::from("hello");
1143 assert_eq!(format!("{:?}", s), "\"hello\"");
1144 }
1145
1146 #[test]
1147 fn test_display() {
1148 let s = BytesString::from("hello world");
1149 assert_eq!(format!("{}", s), "hello world");
1150 }
1151
1152 #[test]
1153 fn test_conversions() {
1154 let s = BytesString::from("hello");
1155
1156 let bytes_mut: BytesMut = s.clone().into();
1158 assert_eq!(bytes_mut.as_ref(), b"hello");
1159
1160 let bytes: Bytes = s.into();
1162 assert_eq!(bytes.as_ref(), b"hello");
1163 }
1164
1165 #[test]
1166 fn test_to_socket_addrs() {
1167 let s = BytesString::from("127.0.0.1:8080");
1168 let addrs: Vec<_> = s.to_socket_addrs().unwrap().collect();
1169 assert!(!addrs.is_empty());
1170
1171 let s = BytesString::from("localhost:8080");
1172 let result = s.to_socket_addrs();
1173 let _ = result;
1176 }
1177
1178 #[test]
1179 fn test_unicode_handling() {
1180 let s = BytesString::from("Hello 🌍 한국어 🎉");
1181 assert_eq!(s.as_str(), "Hello 🌍 한국어 🎉");
1182 assert!(s.len() > 13); let mut s = BytesString::new();
1185 s.push('🌍');
1186 s.push_str(" 한국어");
1187 assert_eq!(s.as_str(), "🌍 한국어");
1188 }
1189
1190 #[test]
1191 fn test_empty_operations() {
1192 let mut s = BytesString::new();
1193 assert!(s.is_empty());
1194
1195 s.push_str("");
1196 assert!(s.is_empty());
1197
1198 s.clear();
1199 assert!(s.is_empty());
1200
1201 let other = s.split_off(0);
1202 assert!(s.is_empty());
1203 assert!(other.is_empty());
1204 }
1205
1206 #[test]
1207 fn test_large_string() {
1208 let large_str = "a".repeat(10000);
1209 let s = BytesString::from(large_str.as_str());
1210 assert_eq!(s.len(), 10000);
1211 assert_eq!(s.as_str(), large_str);
1212
1213 let mut s = BytesString::with_capacity(10000);
1214 for _ in 0..10000 {
1215 s.push('a');
1216 }
1217 assert_eq!(s.len(), 10000);
1218 assert_eq!(s.as_str(), large_str);
1219 }
1220
1221 #[test]
1222 fn test_clone() {
1223 let s1 = BytesString::from("hello world");
1224 let s2 = s1.clone();
1225 assert_eq!(s1, s2);
1226 assert_eq!(s1.as_str(), s2.as_str());
1227 }
1228
1229 #[test]
1230 fn test_default() {
1231 let s: BytesString = Default::default();
1232 assert!(s.is_empty());
1233 assert_eq!(s.as_str(), "");
1234 }
1235
1236 #[test]
1237 fn test_hash_map_usage() {
1238 let mut map = HashMap::new();
1239 let key = BytesString::from("key");
1240 map.insert(key, "value");
1241
1242 let lookup_key = BytesString::from("key");
1243 assert_eq!(map.get(&lookup_key), Some(&"value"));
1244
1245 assert_eq!(map.get("key"), Some(&"value"));
1247 }
1248}