wip

Author: glebpom

src/header/map.rs

@@ -658,7 +658,7 @@ impl<T> HeaderMap<T> {
     /// # map.insert(HOST, "bar".parse().unwrap());
     /// ```
     pub fn reserve(&mut self, additional: usize) {
-        self.try_reserve(additional).expect("reservation failed")
+        self.try_reserve(additional).expect("size overflows MAX_SIZE")
     }
 
     /// Reserves capacity for at least `additional` more headers to be inserted
@@ -1110,7 +1110,7 @@ impl<T> HeaderMap<T> {
     where
         K: IntoHeaderName,
     {
-        key.try_entry(self).expect("reservation error")
+        key.try_entry(self).expect("size overflows MAX_SIZE")
     }
 
     /// Gets the given key's corresponding entry in the map for in-place
@@ -1204,7 +1204,7 @@ impl<T> HeaderMap<T> {
     where
         K: IntoHeaderName,
     {
-        self.try_insert(key, val).expect("reservation failed")
+        self.try_insert(key, val).expect("size overflows MAX_SIZE")
     }
 
     /// Inserts a key-value pair into the map.
@@ -1345,7 +1345,7 @@ impl<T> HeaderMap<T> {
         where
             K: IntoHeaderName,
     {
-        self.try_append(key, value).expect("reservation error")
+        self.try_append(key, value).expect("size overflows MAX_SIZE")
     }
 
     /// Inserts a key-value pair into the map.
@@ -2104,10 +2104,10 @@ impl<T> Extend<(HeaderName, T)> for HeaderMap<T> {
             (iter.size_hint().0 + 1) / 2
         };
 
-        self.try_reserve(reserve).expect("reservation error");
+        self.try_reserve(reserve).expect("size overflows MAX_SIZE");
 
         for (k, v) in iter {
-            self.try_append(k, v).expect("reservation error");
+            self.try_append(k, v).expect("size overflows MAX_SIZE");
         }
     }
 }
@@ -2445,7 +2445,7 @@ impl<'a, T> Entry<'a, T> {
     /// assert_eq!(map["x-hello"], 1);
     /// ```
     pub fn or_insert(self, default: T) -> &'a mut T {
-        self.or_try_insert(default).expect("capacity error")
+        self.or_try_insert(default).expect("size overflows MAX_SIZE")
     }
 
     /// Ensures a value is in the entry by inserting the default if empty.
@@ -2522,7 +2522,7 @@ impl<'a, T> Entry<'a, T> {
     /// assert_eq!(res, "world");
     /// ```
     pub fn or_insert_with<F: FnOnce() -> T>(self, default: F) -> &'a mut T {
-        self.or_try_insert_with(default).expect("reservation error")
+        self.or_try_insert_with(default).expect("size overflows MAX_SIZE")
     }
 
     /// Ensures a value is in the entry by inserting the result of the default
@@ -2641,7 +2641,7 @@ impl<'a, T> VacantEntry<'a, T> {
     /// assert_eq!(map["x-hello"], "world");
     /// ```
     pub fn insert(self, value: T) -> &'a mut T {
-        self.try_insert(value).expect("reservation failed")
+        self.try_insert(value).expect("size overflows MAX_SIZE")
     }
 
     /// Insert the value into the entry.
@@ -2689,7 +2689,7 @@ impl<'a, T> VacantEntry<'a, T> {
     /// assert_eq!(map["x-hello"], "world2");
     /// ```
     pub fn insert_entry(self, value: T) -> OccupiedEntry<'a, T> {
-        self.try_insert_entry(value).expect("reserve failed")
+        self.try_insert_entry(value).expect("size overflows MAX_SIZE")
     }
 
     /// Insert the value into the entry.