Delete tests parts containing mutable char ptr into string literals

Author: lucic71

tests/unit/out/refcount/string_literals.rs

@@ -16,36 +16,21 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let mutable_strings: Value<Box<[Ptr<u8>]>> = Rc::new(RefCell::new(Box::new([
-        Ptr::from_string_literal("a"),
-        Ptr::from_string_literal("b"),
-        Ptr::from_string_literal("c"),
-    ])));
     let immutable_strings: Value<Box<[Ptr<u8>]>> = Rc::new(RefCell::new(Box::new([
         Ptr::from_string_literal("a"),
         Ptr::from_string_literal("b"),
         Ptr::from_string_literal("c"),
     ])));
-    let mutable_string: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("hello")));
     let immutable_string: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("hello")));
     let mutable_string_arr: Value<Box<[u8]>> =
         Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
     let immutable_string_arr: Value<Box<[u8]>> =
         Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
-    let mutable_empty: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("")));
     let immutable_empty: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal("")));
     let mutable_empty_arr: Value<Box<[u8]>> =
         Rc::new(RefCell::new(Box::<[u8]>::from(b"\0".as_slice())));
     let immutable_empty_arr: Value<Box<[u8]>> =
         Rc::new(RefCell::new(Box::<[u8]>::from(b"\0".as_slice())));
-    ({
-        let _str: Ptr<u8> = Ptr::from_string_literal("world");
-        foo_mut_0(_str)
-    });
-    ({
-        let _str: Ptr<u8> = (*mutable_string.borrow()).clone();
-        foo_mut_0(_str)
-    });
     ({
         let _str: Ptr<u8> = (mutable_string_arr.as_pointer() as Ptr<u8>);
         foo_mut_0(_str)
@@ -54,18 +39,10 @@ fn main_0() -> i32 {
         let _str: Ptr<u8> = Ptr::from_string_literal("world");
         foo_const_1(_str)
     });
-    ({
-        let _str: Ptr<u8> = (*mutable_string.borrow()).clone();
-        foo_const_1(_str)
-    });
     ({
         let _str: Ptr<u8> = (*immutable_string.borrow()).clone();
         foo_const_1(_str)
     });
-    ({
-        let _str: Ptr<u8> = (mutable_string_arr.as_pointer() as Ptr<u8>);
-        foo_const_1(_str)
-    });
     ({
         let _str: Ptr<u8> = (immutable_string_arr.as_pointer() as Ptr<u8>);
         foo_const_1(_str)
@@ -74,18 +51,10 @@ fn main_0() -> i32 {
         let _str: Ptr<u8> = Ptr::from_string_literal("");
         foo_const_1(_str)
     });
-    ({
-        let _str: Ptr<u8> = (*mutable_empty.borrow()).clone();
-        foo_const_1(_str)
-    });
     ({
         let _str: Ptr<u8> = (*immutable_empty.borrow()).clone();
         foo_const_1(_str)
     });
-    ({
-        let _str: Ptr<u8> = (mutable_empty_arr.as_pointer() as Ptr<u8>);
-        foo_const_1(_str)
-    });
     ({
         let _str: Ptr<u8> = (immutable_empty_arr.as_pointer() as Ptr<u8>);
         foo_const_1(_str)

tests/unit/out/unsafe/string_literals.rs

@@ -14,28 +14,13 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut mutable_strings: [*mut u8; 3] = [
-        b"a\0".as_ptr().cast_mut(),
-        b"b\0".as_ptr().cast_mut(),
-        b"c\0".as_ptr().cast_mut(),
-    ];
     let mut immutable_strings: [*const u8; 3] = [b"a\0".as_ptr(), b"b\0".as_ptr(), b"c\0".as_ptr()];
-    let mut mutable_string: *mut u8 = b"hello\0".as_ptr().cast_mut();
     let mut immutable_string: *const u8 = b"hello\0".as_ptr();
     let mut mutable_string_arr: [u8; 9] = *b"papanasi\0";
     let immutable_string_arr: [u8; 9] = *b"papanasi\0";
-    let mut mutable_empty: *mut u8 = b"\0".as_ptr().cast_mut();
     let mut immutable_empty: *const u8 = b"\0".as_ptr();
     let mut mutable_empty_arr: [u8; 1] = *b"\0";
     let immutable_empty_arr: [u8; 1] = *b"\0";
-    (unsafe {
-        let _str: *mut u8 = b"world\0".as_ptr().cast_mut();
-        foo_mut_0(_str)
-    });
-    (unsafe {
-        let _str: *mut u8 = mutable_string;
-        foo_mut_0(_str)
-    });
     (unsafe {
         let _str: *mut u8 = mutable_string_arr.as_mut_ptr();
         foo_mut_0(_str)
@@ -44,18 +29,10 @@ unsafe fn main_0() -> i32 {
         let _str: *const u8 = b"world\0".as_ptr();
         foo_const_1(_str)
     });
-    (unsafe {
-        let _str: *const u8 = mutable_string.cast_const();
-        foo_const_1(_str)
-    });
     (unsafe {
         let _str: *const u8 = immutable_string;
         foo_const_1(_str)
     });
-    (unsafe {
-        let _str: *const u8 = mutable_string_arr.as_mut_ptr().cast_const();
-        foo_const_1(_str)
-    });
     (unsafe {
         let _str: *const u8 = immutable_string_arr.as_ptr();
         foo_const_1(_str)
@@ -64,18 +41,10 @@ unsafe fn main_0() -> i32 {
         let _str: *const u8 = b"\0".as_ptr();
         foo_const_1(_str)
     });
-    (unsafe {
-        let _str: *const u8 = mutable_empty.cast_const();
-        foo_const_1(_str)
-    });
     (unsafe {
         let _str: *const u8 = immutable_empty;
         foo_const_1(_str)
     });
-    (unsafe {
-        let _str: *const u8 = mutable_empty_arr.as_mut_ptr().cast_const();
-        foo_const_1(_str)
-    });
     (unsafe {
         let _str: *const u8 = immutable_empty_arr.as_ptr();
         foo_const_1(_str)

tests/unit/string_literals.cpp

@@ -2,34 +2,25 @@ void foo_mut(char *str) {}
 void foo_const(const char *str) {}
 
 int main() {
-  char *mutable_strings[] = {"a", "b", "c"};
   const char *immutable_strings[] = {"a", "b", "c"};
 
-  char *mutable_string = "hello";
   const char *immutable_string = "hello";
 
   char mutable_string_arr[] = "papanasi";
   const char immutable_string_arr[] = "papanasi";
 
-  char *mutable_empty = "";
   const char *immutable_empty = "";
   char mutable_empty_arr[] = "";
   const char immutable_empty_arr[] = "";
 
-  foo_mut("world");
-  foo_mut(mutable_string);
   foo_mut(mutable_string_arr);
 
   foo_const("world");
-  foo_const(mutable_string);
   foo_const(immutable_string);
-  foo_const(mutable_string_arr);
   foo_const(immutable_string_arr);
 
   foo_const("");
-  foo_const(mutable_empty);
   foo_const(immutable_empty);
-  foo_const(mutable_empty_arr);
   foo_const(immutable_empty_arr);
   return 0;
 }