1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
#![allow(non_snake_case)]
extern crate nsstring;
use nsstring::*;
use std::ffi::CString;
use std::fmt::Write;
use std::os::raw::c_char;
fn nonfatal_fail(msg: String) {
extern "C" {
fn GTest_ExpectFailure(message: *const c_char);
}
unsafe {
let msg = CString::new(msg).unwrap();
GTest_ExpectFailure(msg.as_ptr());
}
}
/// This macro checks if the two arguments are equal, and causes a non-fatal
/// GTest test failure if they are not.
macro_rules! expect_eq {
($x:expr, $y:expr) => {
match (&$x, &$y) {
(x, y) => {
if *x != *y {
nonfatal_fail(format!(
"check failed: (`{:?}` == `{:?}`) at {}:{}",
x,
y,
file!(),
line!()
))
}
}
}
};
}
#[no_mangle]
pub extern "C" fn Rust_StringFromCpp(cs: *const nsACString, s: *const nsAString) {
unsafe {
expect_eq!(&*cs, "Hello, World!");
expect_eq!(&*s, "Hello, World!");
}
}
#[no_mangle]
pub extern "C" fn Rust_AssignFromRust(cs: *mut nsACString, s: *mut nsAString) {
unsafe {
(*cs).assign(&nsCString::from("Hello, World!"));
expect_eq!(&*cs, "Hello, World!");
(*s).assign(&nsString::from("Hello, World!"));
expect_eq!(&*s, "Hello, World!");
}
}
extern "C" {
fn Cpp_AssignFromCpp(cs: *mut nsACString, s: *mut nsAString);
}
#[no_mangle]
pub extern "C" fn Rust_AssignFromCpp() {
let mut cs = nsCString::new();
let mut s = nsString::new();
unsafe {
Cpp_AssignFromCpp(&mut *cs, &mut *s);
}
expect_eq!(cs, "Hello, World!");
expect_eq!(s, "Hello, World!");
}
#[no_mangle]
pub extern "C" fn Rust_StringWrite() {
let mut cs = nsCString::new();
let mut s = nsString::new();
write!(s, "a").unwrap();
write!(cs, "a").unwrap();
expect_eq!(s, "a");
expect_eq!(cs, "a");
write!(s, "bc").unwrap();
write!(cs, "bc").unwrap();
expect_eq!(s, "abc");
expect_eq!(cs, "abc");
write!(s, "{}", 123).unwrap();
write!(cs, "{}", 123).unwrap();
expect_eq!(s, "abc123");
expect_eq!(cs, "abc123");
}
#[no_mangle]
pub extern "C" fn Rust_FromEmptyRustString() {
let mut test = nsString::from("Blah");
test.assign_utf8(&nsCString::from(String::new()));
assert!(test.is_empty());
}
#[no_mangle]
pub extern "C" fn Rust_WriteToBufferFromRust(
cs: *mut nsACString,
s: *mut nsAString,
fallible_cs: *mut nsACString,
fallible_s: *mut nsAString,
) {
unsafe {
let cs_buf = (*cs).to_mut();
let s_buf = (*s).to_mut();
let fallible_cs_buf = (*fallible_cs).fallible_to_mut().unwrap();
let fallible_s_buf = (*fallible_s).fallible_to_mut().unwrap();
cs_buf[0] = b'A';
cs_buf[1] = b'B';
cs_buf[2] = b'C';
s_buf[0] = b'A' as u16;
s_buf[1] = b'B' as u16;
s_buf[2] = b'C' as u16;
fallible_cs_buf[0] = b'A';
fallible_cs_buf[1] = b'B';
fallible_cs_buf[2] = b'C';
fallible_s_buf[0] = b'A' as u16;
fallible_s_buf[1] = b'B' as u16;
fallible_s_buf[2] = b'C' as u16;
}
}
#[no_mangle]
pub extern "C" fn Rust_VoidStringFromRust(cs: &mut nsACString, s: &mut nsAString) {
cs.set_is_void(true);
s.set_is_void(true);
}
|
