cowstr 0.13.0

use std::borrow::Borrow;
use std::fmt;
use std::hash::Hash;
use std::hash::Hasher;
use std::num::NonZeroUsize;
use std::ops::Deref;

use constptr::ConstPtr;

use crate::*;

/// The errors that the `CowStr` API may return.
#[derive(Debug)]
pub enum Error {
    /// Tried to `try_push*()` more than the strings spare capacity can hold.
    Capacity,
    /// Tried to create a `SubStr` with a Range wider than the original `CowStr`.
    Range,
    /// Only a single thread can use `try_push*()` functions. This thread can't.
    ThreadOwnership,
}

/// A shared string that is copy-on-write and can be either static or dynamic shared with a
/// reference counter.  When a `CowStr` is dynamically created it can be mutated until it
/// becomes cloned, then mutation becomes copy-on-write as marked with **copy-on-write**
/// below.
#[repr(transparent)]
#[derive(Debug)]
pub struct CowStr(CowStrInner);

#[derive(Debug)]
enum CowStrInner {
    /// A static string can be shared immutably without reference counting.
    Static(&'static str),
    /// Shared strings are reference counted String.
    Shared(RcString),
}

impl CowStrInner {
    /// Creates a shared/recounted inner from a `RcString` pointer. This also handles the case
    /// when the allocation failed where None was returned from the `RcString` constructors.
    #[inline]
    fn new_shared(ptr: RcString) -> CowStrInner {
        CowStrInner::Shared(ptr)
    }
}

impl CowStr {
    /// Creates a new empty `CowStr`.
    #[must_use]
    #[inline]
    pub fn new() -> Self {
        CowStr(CowStrInner::new_shared(RcString::allocate(0)))
    }

    /// Creates a new empty `CowStr` with at least as much pre-allocated capacity.
    #[must_use]
    #[inline]
    pub fn with_capacity(capacity: usize) -> Self {
        CowStr(CowStrInner::new_shared(RcString::allocate(capacity)))
    }

    /// Creates a new `CowStr` that references a static string. This function can be used in
    /// 'const' contexts there should be no overhead over using a '&str'.
    #[must_use]
    #[inline]
    pub const fn from_static(s: &'static str) -> Self {
        CowStr(CowStrInner::Static(s))
    }

    /// Creates a copy of a `CowStr`, when `self` refers to a static string, then the new
    /// string will refer to the same string. When it refers to some shared string this will
    /// be copied (with minimal length) instead shared.
    #[must_use]
    #[inline]
    pub fn replicate(&self) -> Self {
        match &self.0 {
            CowStrInner::Static(s) => CowStr(CowStrInner::Static(s)),
            CowStrInner::Shared(_) => CowStr::from(self.as_str()),
        }
    }

    #[deprecated(since = "0.9.0", note = "use CowStr::replicate() instead")]
    #[allow(missing_docs)]
    #[must_use]
    #[inline]
    #[mutants::skip] /* deprecated */
    pub fn copy(&self) -> Self {
        self.replicate()
    }

    /// Gets a mutable reference to the underlying `RcString`, when the the `CowStr` is static
    /// or the reference count is more than one the String will be cloned. When the spare
    /// capacity is not sufficient the string will be resized. This is **the** copy-on-write
    /// operation.
    fn to_mut(&mut self, reserve: usize) -> &mut RcString {
        match self.0 {
            // The string is only shared when strong_count > 1, then we need to CoW it.
            CowStrInner::Shared(r) if r.strong_count() > 1 => {
                self.0 = CowStrInner::new_shared(RcString::from_str(r.as_str(), reserve));
                // When another thread decremented the refcount concurrently, the last one
                // needs to call dealloc.
                if r.decrement_strong_count() {
                    unsafe { RcString::dealloc(r) };
                }
            }
            CowStrInner::Shared(r) if r.spare_capacity() < reserve => {
                self.0 = CowStrInner::new_shared(RcString::grow(r, reserve));
            }
            CowStrInner::Static(s) => {
                self.0 = CowStrInner::new_shared(RcString::from_str(s, reserve));
            }
            CowStrInner::Shared(_) => { /* Nothing to do */ }
        }

        if let CowStrInner::Shared(ref mut rc) = self.0 {
            debug_assert_eq!(rc.strong_count(), 1);
            rc
        } else {
            /* this is really not reached, above we put a CowStrInner::Shared in place */
            unsafe { std::hint::unreachable_unchecked() }
        }
    }

    /// Pushes a single character to the end of the `CowStr`. This is **copy-on-write**.
    #[inline]
    pub fn push_char(&mut self, c: char) {
        self.to_mut(c.len_utf8()).push(c);
    }

    #[doc(hidden)]
    #[deprecated(since = "0.11.0", note = "use push_char()")]
    #[mutants::skip]
    #[inline]
    pub fn push(&mut self, c: char) {
        self.push_char(c);
    }

    /// Pushes a string slice to the end of the `CowStr`. This is **copy-on-write**
    #[inline]
    pub fn push_str(&mut self, s: &str) {
        self.to_mut(s.len()).push_str(s);
    }

    /// Tries to push a single character to the end of the `CowStr`. This succeeds only when
    /// there is enough reserved capacity in the underlying string it will never reallocate
    /// (Thus will always fail on statically allocated `CowStr`). This is **not**
    /// copy-on-write.
    ///
    /// # Safety
    ///
    /// This method is always memory safe but it breaks the promise that `CowStr` are
    /// immutable. Any clone done from this `CowStr` will see the appended character as
    /// well. `SubStr` taken from a `CowStr` will keep their immutability promise when
    /// characters are appended.
    #[inline]
    pub unsafe fn try_push_char(&self, c: char) -> Result<(), Error> {
        match self.0 {
            CowStrInner::Static(_) => Err(Error::Capacity),
            CowStrInner::Shared(r) => r.try_push(c),
        }
    }

    #[doc(hidden)]
    #[deprecated(since = "0.11.0", note = "use try_push_char()")]
    #[mutants::skip]
    #[inline]
    pub unsafe fn try_push(&mut self, c: char) -> Result<(), Error> {
        self.try_push_char(c)
    }

    //PLANNED: try_|push(&mut self, c: impl ExactSizeIterator<Item = char>)

    /// Tries to push a string slice to the end of the `CowStr`. This succeeds only when
    /// there is enough reserved capacity in the underlying string it will never reallocate
    /// (Thus will always fail on statically allocated `CowStr`). This is **not**
    /// copy-on-write.
    ///
    /// # Safety
    ///
    /// This method is always memory safe but it breaks the promise that `CowStr` are
    /// immutable. Any clone done from this `CowStr` will see the appended characters as
    /// well. `SubStr` taken from a `CowStr` will keep their immutability promise when
    /// characters are appended.
    #[inline]
    pub unsafe fn try_push_str(&self, s: &str) -> Result<(), Error> {
        match self.0 {
            CowStrInner::Static(_) => Err(Error::Capacity),
            CowStrInner::Shared(r) => r.try_push_str(s),
        }
    }

    /// Creates a `Guard` for the current thread to protect the `try_push*()` methods against
    /// races.
    #[cfg(feature = "multithreaded")]
    #[inline]
    pub fn guard(&self) -> Result<Guard, Error> {
        match self.0 {
            CowStrInner::Static(_) => Err(Error::Capacity),
            CowStrInner::Shared(ref rc) => {
                if rc.acquire() {
                    Ok(Guard(self.clone(), Default::default()))
                } else {
                    Err(Error::ThreadOwnership)
                }
            }
        }
    }

    /// Create a `SubStr` that from a `CowStr`.
    #[must_use]
    #[inline]
    #[doc(hidden)]
    #[deprecated(since = "0.11.2", note = "use SubStr::new()")]
    pub fn into_substr(self) -> SubStr {
        let substr = ConstPtr::from(&self[..]);
        SubStr {
            string: self,
            substr,
        }
    }

    /// Create an `SubStr` as span of a `CowStr`.
    #[doc(hidden)]
    #[deprecated(since = "0.11.2", note = "use SubStr::new_range()")]
    pub fn into_range(self, start: usize, end: usize) -> Result<SubStr, RangeError> {
        if let Some(substr) = self.get(start..end) {
            let substr = ConstPtr::from(substr);
            Ok(SubStr {
                string: self,
                substr,
            })
        } else {
            Err(RangeError)
        }
    }

    /// Returns `Ok(&'static str)` when the underlying string has static lifetime and
    /// `Err(&'self str)` when it is dynamically allocated.
    #[inline]
    pub fn deref_static(&self) -> Result<&'static str, &str> {
        match &self.0 {
            CowStrInner::Static(s) => Ok(s),
            CowStrInner::Shared(s) => Err(s.as_str()),
        }
    }

    /// Returns the reference count of the underlying allocation. Will be 'None' when self
    /// refers to a static string.
    #[must_use]
    #[inline]
    #[allow(clippy::missing_panics_doc)]
    pub fn strong_count(&self) -> Option<NonZeroUsize> {
        match self.0 {
            CowStrInner::Static(_) => None,
            CowStrInner::Shared(r) => Some(NonZeroUsize::new(r.strong_count()).unwrap()),
        }
    }

    /// Returns the string as string slice.
    #[must_use]
    #[inline]
    pub fn as_str(&self) -> &str {
        match self.deref_static() {
            Ok(s) | Err(s) => s,
        }
    }

    /// Returns the string as mutable string slice. This is **copy-on-write**.
    #[inline]
    pub fn as_mut_str(&mut self) -> &mut str {
        unsafe {
            // Safety: to_mut() ensures refcount == 1
            self.to_mut(0).as_mut_str()
        }
    }

    /// Returns the capacity of the string, for static strings this equals their length.
    ///
    /// ```
    /// # use cowstr::CowStr;
    /// let cowstr = CowStr::from_static("foobar");
    /// assert_eq!(cowstr.capacity(), 6);
    ///
    /// let cowstr = CowStr::with_capacity(100);
    /// assert!(cowstr.capacity() >= 100);
    /// ```
    #[must_use]
    #[inline]
    pub fn capacity(&self) -> usize {
        match self.0 {
            CowStrInner::Static(s) => s.len(),
            CowStrInner::Shared(r) => r.capacity(),
        }
    }

    /// Returns the spare capacity of the string, for static strings this is zero.
    ///
    /// ```
    /// # use cowstr::CowStr;
    /// let cowstr = CowStr::from_static("foobar");
    /// assert_eq!(cowstr.spare_capacity(), 0);
    ///
    /// let mut cowstr = CowStr::with_capacity(100);
    /// cowstr.push('x');
    /// assert!(cowstr.capacity() >= 99);
    /// ```
    #[must_use]
    #[inline]
    pub fn spare_capacity(&self) -> usize {
        match self.0 {
            CowStrInner::Static(_) => 0,
            CowStrInner::Shared(r) => r.spare_capacity(),
        }
    }

    /// Reserves space for at least additional bytes. This is **copy-on-write**.
    ///
    /// # Example
    ///
    /// ```
    /// # use cowstr::CowStr;
    /// let mut cowstr = CowStr::from_static("foobar");
    /// assert_eq!(cowstr.spare_capacity(), 0);
    ///
    /// cowstr.reserve(100);
    /// assert!(cowstr.spare_capacity() >= 100);
    /// ```
    ///
    /// # Allocation Strategy
    ///
    /// Albeit the allocation strategy is an implementation detail which may change in future
    /// here is some information about it:
    ///
    /// A string in `CowStr` is managed by a single block of memory (no double dereference to
    /// the actual string data). This block of memory consists of a header for managing the
    /// string followed by the data. This block header contains (among other) the actual
    /// allocated capacity and the current used length of the string. Pushing to the end of a
    /// `CowStr` can append data as long the capacity is not exceeded. When the capacity would
    /// be overflown a reallocation is needed. Reallocating guarantees that at least the
    /// required new size will be allocated but usually extends the block capacity beyond that
    /// to reduce the chance of frequent reallocation.
    ///
    /// ## Growing is currently done by the following strategy:
    ///
    ///  * The block has an alignment and minimal size of 32 bytes.
    ///  * Between 32 byte and 8MB each reallocation doubles the capacity.
    ///  * Between 8MB and 1GB reallocation grows the block by 50% (8MB, 12MB, 18MB ..).
    ///  * Above 1GB each reallocation will grow by a constant 512MB.
    ///
    /// # Shrinking
    ///
    /// Shrinking is only done on request and done exactly to the next (32byte) alignment.
    #[inline]
    pub fn reserve(&mut self, additional: usize) {
        self.to_mut(additional);
    }

    /// Shrinks the capacity to `new_capacity` or `self.len()` whatever is larger. When `self`
    /// is already shared or static or `new_capacity` is larger than its current capacity then
    /// this is a no-op. The exact resulting capacity can still have some excess bytes for
    /// alignment.
    ///
    /// ```
    /// # use cowstr::CowStr;
    /// let mut cowstr = CowStr::with_capacity(1000);
    /// assert!(cowstr.capacity() >= 1000);
    ///
    /// cowstr.shrink_to(100);
    /// assert!(cowstr.capacity() >= 100);
    /// assert!(cowstr.capacity() < 1000);
    /// ```
    pub fn shrink_to(&mut self, new_capacity: usize) {
        match self.0 {
            CowStrInner::Shared(r) if r.strong_count() == 1 => {
                self.0 = CowStrInner::new_shared(RcString::shrink(r, new_capacity));
            }
            _ => { /* NOP */ }
        }
    }

    /// Shrinks the capacity to the minimum. This is just a convenience function calling
    /// `cowstr.shrink_to(0)`.
    #[inline]
    #[mutants::skip] /* shrinking has no deterministic side effect (implementation defined) */
    pub fn shrink_to_fit(&mut self) {
        self.shrink_to(0);
    }

    /// Combines `shrink_to_fit()` and `clone()`. Tries to shrink `self` first and then
    /// returns a new shared `CowStr`.
    ///
    /// ```
    /// # use cowstr::CowStr;
    /// let mut cowstr = CowStr::with_capacity(1000);
    /// cowstr.push_str("foobar");
    /// assert!(cowstr.capacity() >= 1000);
    ///
    /// let cloned = cowstr.shrink_clone();
    /// assert!(cowstr.capacity() < 1000);
    /// assert!(cloned.capacity() < 1000);
    /// ```
    #[inline]
    pub fn shrink_clone(&mut self) -> Self {
        self.shrink_to(0);
        self.clone()
    }

    /// Returns the string as bytes slice.
    ///
    /// ```
    /// # use cowstr::CowStr;
    /// let s = CowStr::from("hello");
    ///
    /// assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
    /// ```
    #[inline]
    #[must_use]
    pub fn as_bytes(&self) -> &[u8] {
        self.as_str().as_bytes()
    }

    /// Returns 'true' when two `CowStrs` point to the same underlying memory.
    ///
    /// # Example
    ///
    /// ```
    /// use cowstr::CowStr;
    /// let first = CowStr::from("foobar");
    /// let second = first.clone();
    /// let other = first.replicate();
    /// assert!(first.is_same_as(&second));
    /// assert!(!first.is_same_as(&other));
    /// ```
    #[inline]
    #[must_use]
    pub fn is_same_as(&self, other: &Self) -> bool {
        std::ptr::eq(self.as_str(), other.as_str())
    }

    /// Gets the range of `substr` within a `Cowstr`
    ///
    /// # Panics
    ///
    /// When `substr` is not within `self`.
    ///
    /// # Example
    ///
    /// ```
    /// use cowstr::CowStr;
    /// let main = CowStr::from("foobar");
    /// let substr = &main[2..5];
    /// assert_eq!(substr, "oba");
    /// assert_eq!(main.range_of(substr), 2..5);
    /// ```
    #[must_use]
    pub fn range_of(&self, substr: &str) -> std::ops::Range<usize> {
        assert!(
            self.as_bytes().as_ptr_range().contains(&substr.as_ptr()),
            "`substr` is not part of `self`"
        );

        let start = (substr.as_ptr() as usize) - (self.as_ptr() as usize);
        start..start + substr.len()
    }
}

impl Clone for CowStr {
    fn clone(&self) -> Self {
        match self.0 {
            CowStrInner::Static(s) => CowStr(CowStrInner::Static(s)),
            CowStrInner::Shared(rc) => {
                rc.increment_strong_count();
                CowStr(CowStrInner::Shared(rc))
            }
        }
    }
}

impl Drop for CowStr {
    fn drop(&mut self) {
        match self.0 {
            CowStrInner::Shared(rc) => unsafe {
                if rc.decrement_strong_count() {
                    RcString::dealloc(rc);
                }
            },
            CowStrInner::Static(_) => { /* NOP */ }
        }
    }
}

impl Default for CowStr {
    #[inline]
    fn default() -> Self {
        Self::new()
    }
}

impl From<&str> for CowStr {
    #[inline]
    fn from(source: &str) -> Self {
        CowStr(CowStrInner::new_shared(RcString::from_str(source, 0)))
    }
}

/// `CowStr` dereferences to `&str`.
impl Deref for CowStr {
    type Target = str;

    #[inline]
    fn deref(&self) -> &Self::Target {
        self.as_str()
    }
}

impl AsRef<str> for CowStr {
    #[inline]
    fn as_ref(&self) -> &str {
        self
    }
}

impl Borrow<str> for CowStr {
    #[inline]
    fn borrow(&self) -> &str {
        self
    }
}

impl Eq for CowStr {}

impl PartialEq for CowStr {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.as_ref() == other.as_ref()
    }
}

impl PartialOrd for CowStr {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.as_ref().partial_cmp(other.as_ref())
    }
}

impl Ord for CowStr {
    #[inline]
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.as_ref().cmp(other.as_ref())
    }
}

impl Hash for CowStr {
    #[inline]
    #[mutants::skip] /* we just pretend it works */
    fn hash<H: Hasher>(&self, state: &mut H) {
        (**self).hash(state);
    }
}

impl fmt::Display for CowStr {
    #[inline]
    #[mutants::skip] /* we just pretend it works */
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&**self, f)
    }
}

#[derive(Default)]
struct NotSend(std::marker::PhantomData<*const ()>);

/// The unsafe `try_push*()` methods are would be somewhat fragile when multiple threads could
/// push to a `CowStr`. To mitigate this only one thread is allowed to `try_push*()` to a
/// `CowStr`. This is implemented by a guard pattern. A thread that wishes to use the
/// `try_push*()` API's has to get a guard on the `CowStr` in question first. Dropping the
/// `Guard` will release the threads ownership on this `CowStr`. These guards are implemented
/// with a `ThreadCell` and thus ownership must be passed cooperatively. Creating a `Guard`
/// will not block the requesting thread but return Ok or Err immediately.
///
/// Guards are only available when the 'multithreaded' feature is set.
#[cfg(feature = "multithreaded")]
pub struct Guard(CowStr, NotSend);

#[cfg(feature = "multithreaded")]
impl Drop for Guard {
    fn drop(&mut self) {
        if let CowStrInner::Shared(r) = self.0 .0 {
            r.release();
        }
    }
}

impl Deref for Guard {
    type Target = CowStr;

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

#[test]
fn smoke() {
    let _empty_string = CowStr::new();
    let _static_string = CowStr::from_static("smoke 1");
    let _dynamic_string = CowStr::from("smoke 2");
}

#[test]
fn size() {
    // assumption about the implementation
    assert_eq!(std::mem::size_of::<CowStr>(), std::mem::size_of::<&str>());
}

#[test]
fn as_str_static() {
    let my_string = CowStr::from_static("as_str_static");
    assert_eq!(my_string.as_str(), "as_str_static");
}

#[test]
fn as_str_dynamic() {
    let my_string = CowStr::from("as_str_dynamic");
    let mut cloned = my_string.clone();
    cloned.push_str(" foobar"); /* will CoW */

    assert_eq!(my_string.as_str(), "as_str_dynamic");
    assert_eq!(cloned.as_str(), "as_str_dynamic foobar");
}

#[test]
fn as_mut_str() {
    let mut my_string = CowStr::from_static("as_mut_str");
    assert_eq!(my_string.as_mut_str(), "as_mut_str");
}

#[test]
#[should_panic(expected = "Capacity overflow")]
fn over_capacity() {
    let _boom = CowStr::with_capacity(usize::MAX);
}

#[test]
fn push_char() {
    let mut my_string = CowStr::from_static("push_char");

    my_string.push_char(' ');
    assert_eq!(&*my_string, "push_char ");
    my_string.push_char('1');
    my_string.push_char('2');
    my_string.push_char('3');
    my_string.push_char('4');
    my_string.push_char('5');
    my_string.push_char('6');
    my_string.push_char('7');
    my_string.push_char('8');
    assert_eq!(&*my_string, "push_char 12345678");
}

#[test]
fn push_str() {
    let mut my_string = CowStr::from_static("push_str");

    my_string.push_str(" foo");
    assert_eq!(&*my_string, "push_str foo");

    my_string.push_str(" bar");
    assert_eq!(&*my_string, "push_str foo bar");
}

#[cfg(feature = "multithreaded")]
#[test]
fn try_push() {
    let my_string = CowStr::with_capacity(100);
    let cloned = my_string.clone();

    let guard = my_string.guard().unwrap();
    unsafe {
        guard.try_push_str("try_push ").unwrap();
        guard.try_push_char('1').unwrap();
        guard.try_push_char('2').unwrap();
        guard.try_push_char('3').unwrap();
        guard.try_push_char('4').unwrap();
        guard.try_push_char('5').unwrap();
        guard.try_push_char('6').unwrap();
        guard.try_push_char('7').unwrap();
        guard.try_push_char('8').unwrap();
    }
    assert_eq!(&*cloned, "try_push 12345678");
}

#[test]
#[should_panic]
#[cfg(feature = "multithreaded")]
fn two_guard() {
    let my_string = CowStr::with_capacity(100);
    let _guard1 = my_string.guard().unwrap();
    let _guard2 = my_string.guard().unwrap();
}

#[test]
fn clone_static() {
    let my_string = CowStr::from_static("clone_static");
    assert_eq!(my_string.strong_count(), None);
    assert!(my_string.deref_static().is_ok());

    let my_string2 = my_string.clone();
    assert!(my_string.deref_static().is_ok());
    assert_eq!(&*my_string2, "clone_static");

    drop(my_string);
    assert_eq!(&*my_string2, "clone_static");
}

#[test]
fn clone_dynamic() {
    let my_string = CowStr::from("clone_dynamic");
    assert_eq!(
        my_string.strong_count(),
        Some(NonZeroUsize::new(1).unwrap())
    );

    let my_string2 = my_string.clone();
    assert_eq!(
        my_string.strong_count(),
        Some(NonZeroUsize::new(2).unwrap())
    );
    assert_eq!(
        my_string2.strong_count(),
        Some(NonZeroUsize::new(2).unwrap())
    );
    assert_eq!(&*my_string2, "clone_dynamic");

    let my_string3 = my_string.clone();
    assert_eq!(
        my_string3.strong_count(),
        Some(NonZeroUsize::new(3).unwrap())
    );

    drop(my_string);
    assert_eq!(
        my_string2.strong_count(),
        Some(NonZeroUsize::new(2).unwrap())
    );
}

#[test]
fn replicate() {
    let my_string = CowStr::from("replicate");
    assert_eq!(
        my_string.strong_count(),
        Some(NonZeroUsize::new(1).unwrap())
    );

    let my_string2 = my_string.replicate();
    assert_eq!(
        my_string.strong_count(),
        Some(NonZeroUsize::new(1).unwrap())
    );
    assert_eq!(
        my_string2.strong_count(),
        Some(NonZeroUsize::new(1).unwrap())
    );
    assert_eq!(my_string, my_string2);
}

#[test]
fn cmp() {
    let my_static_string = CowStr::from_static("cmp");
    let my_dynamic_string = CowStr::from("cmp");
    let my_dynamic_string2 = CowStr::from("other cmp");
    assert_eq!(my_static_string, my_dynamic_string);
    assert_ne!(my_dynamic_string, my_dynamic_string2);
}

#[test]
fn ord() {
    let my_static_string = CowStr::from_static("a ord");
    let my_dynamic_string = CowStr::from("b ord");
    assert!(my_static_string < my_dynamic_string);
}

#[test]
fn as_ref() {
    let my_string = CowStr::from("as_ref");
    assert_eq!(my_string.deref(), my_string.as_ref());
}

#[test]
fn borrow() {
    let my_string = CowStr::from("borrow");
    assert_eq!(
        my_string.deref(),
        <cowstr::CowStr as Borrow<str>>::borrow(&my_string)
    );
}

#[test]
#[ignore]
fn print() {
    let my_string = CowStr::from_static("static string");
    println!("static_string = {my_string}");
    let my_string = CowStr::from("dynamic string");
    println!("dynamic_string = {my_string}");
}