Delete unportable test part

Mismatching address family behaves different on macos. It returns a
valid ipv4 address in ipv6 format.

Author: lucic71

tests/unit/netdb.c

@@ -56,20 +56,6 @@ static void test_ipv6_literal(void) {
   freeaddrinfo(res);
 }
 
-static void test_family_mismatch(void) {
-  struct addrinfo hints;
-  hints.ai_flags = 0;
-  hints.ai_protocol = 0;
-  hints.ai_addrlen = 0;
-  hints.ai_addr = NULL;
-  hints.ai_canonname = NULL;
-  hints.ai_next = NULL;
-  hints.ai_family = AF_INET6;
-  hints.ai_socktype = SOCK_STREAM;
-  struct addrinfo *res = NULL;
-  assert(getaddrinfo("127.0.0.1", "80", &hints, &res) != 0);
-}
-
 static void test_null_hints(void) {
   struct addrinfo *res = NULL;
   assert(getaddrinfo("127.0.0.1", "80", NULL, &res) == 0);
@@ -84,7 +70,6 @@ static void test_null_hints(void) {
 int main(void) {
   test_ipv4_literal();
   test_ipv6_literal();
-  test_family_mismatch();
   test_null_hints();
   return 0;
 }

tests/unit/out/refcount/netdb.rs

@@ -347,112 +347,7 @@ pub fn test_ipv6_literal_1() {
         }
     };
 }
-pub fn test_family_mismatch_2() {
-    let hints: Value<libcc2rs::Addrinfo> = Rc::new(RefCell::new(Default::default()));
-    (*(*hints.borrow()).ai_flags.borrow_mut()) = 0;
-    (*(*hints.borrow()).ai_protocol.borrow_mut()) = 0;
-    (*(*hints.borrow()).ai_addrlen.borrow_mut()) = 0_u32;
-    (*(*hints.borrow()).ai_addr.borrow_mut()) = Ptr::<libcc2rs::Sockaddr>::null();
-    (*(*hints.borrow()).ai_canonname.borrow_mut()) = Ptr::<u8>::null();
-    (*(*hints.borrow()).ai_next.borrow_mut()) = Ptr::<libcc2rs::Addrinfo>::null();
-    (*(*hints.borrow()).ai_family.borrow_mut()) = libc::AF_INET6;
-    (*(*hints.borrow()).ai_socktype.borrow_mut()) = libc::SOCK_STREAM;
-    let res: Value<Ptr<libcc2rs::Addrinfo>> =
-        Rc::new(RefCell::new(Ptr::<libcc2rs::Addrinfo>::null()));
-    assert!(
-        ((({
-            let __node = Ptr::from_string_literal(b"127.0.0.1").clone();
-            let __service = Ptr::from_string_literal(b"80").clone();
-            let __hints = (hints.as_pointer()).clone();
-            let __out = (res.as_pointer()).clone();
-            let __family = if __hints.is_null() {
-                ::libc::AF_UNSPEC
-            } else {
-                __hints.with(|__h| *__h.ai_family.borrow())
-            };
-            let __socktype = if __hints.is_null() {
-                0
-            } else {
-                __hints.with(|__h| *__h.ai_socktype.borrow())
-            };
-            let __protocol = if __hints.is_null() {
-                0
-            } else {
-                __hints.with(|__h| *__h.ai_protocol.borrow())
-            };
-            let __port: u16 = if __service.is_null() {
-                0
-            } else {
-                __service.to_rust_string().parse().unwrap_or(0)
-            };
-            let mut __addrs: Vec<::std::net::IpAddr> = Vec::new();
-            if __node.is_null() {
-                if __family == ::libc::AF_INET6 {
-                    __addrs.push(::std::net::IpAddr::V6(::std::net::Ipv6Addr::UNSPECIFIED));
-                } else {
-                    __addrs.push(::std::net::IpAddr::V4(::std::net::Ipv4Addr::UNSPECIFIED));
-                }
-            } else {
-                let __host = __node.to_rust_string();
-                match __host.parse::<::std::net::IpAddr>() {
-                    Ok(__ip) => __addrs.push(__ip),
-                    Err(_) => {
-                        use ::std::net::ToSocketAddrs;
-                        match (__host.as_str(), __port).to_socket_addrs() {
-                            Ok(__it) => {
-                                for __sa in __it {
-                                    __addrs.push(__sa.ip());
-                                }
-                            }
-                            Err(_) => {}
-                        }
-                    }
-                }
-            }
-            __addrs.retain(|__ip| match __family {
-                ::libc::AF_INET => __ip.is_ipv4(),
-                ::libc::AF_INET6 => __ip.is_ipv6(),
-                _ => true,
-            });
-            if __addrs.is_empty() {
-                ::libc::EAI_NONAME
-            } else {
-                let mut __next = Ptr::<Addrinfo>::null();
-                for __ip in __addrs.iter().rev() {
-                    let __ai = Addrinfo::default();
-                    *__ai.ai_socktype.borrow_mut() = __socktype;
-                    *__ai.ai_protocol.borrow_mut() = __protocol;
-                    let __storage = Ptr::alloc(SockaddrStorage::default());
-                    match __ip {
-                        ::std::net::IpAddr::V4(__v4) => {
-                            *__ai.ai_family.borrow_mut() = ::libc::AF_INET;
-                            *__ai.ai_addrlen.borrow_mut() =
-                                ::std::mem::size_of::<::libc::sockaddr_in>() as u32;
-                            __storage
-                                .reinterpret_cast::<SockaddrIn>()
-                                .write(SockaddrIn::from_ipv4(__v4, __port));
-                        }
-                        ::std::net::IpAddr::V6(__v6) => {
-                            *__ai.ai_family.borrow_mut() = ::libc::AF_INET6;
-                            *__ai.ai_addrlen.borrow_mut() =
-                                ::std::mem::size_of::<::libc::sockaddr_in6>() as u32;
-                            __storage
-                                .reinterpret_cast::<SockaddrIn6>()
-                                .write(SockaddrIn6::from_ipv6(__v6, __port));
-                        }
-                    }
-                    *__ai.ai_addr.borrow_mut() = __storage.reinterpret_cast::<Sockaddr>();
-                    *__ai.ai_next.borrow_mut() = __next.clone();
-                    __next = Ptr::alloc(__ai);
-                }
-                __out.write(__next);
-                0
-            }
-        } != 0) as i32)
-            != 0)
-    );
-}
-pub fn test_null_hints_3() {
+pub fn test_null_hints_2() {
     let res: Value<Ptr<libcc2rs::Addrinfo>> =
         Rc::new(RefCell::new(Ptr::<libcc2rs::Addrinfo>::null()));
     assert!(
@@ -588,7 +483,6 @@ pub fn main() {
 fn main_0() -> i32 {
     ({ test_ipv4_literal_0() });
     ({ test_ipv6_literal_1() });
-    ({ test_family_mismatch_2() });
-    ({ test_null_hints_3() });
+    ({ test_null_hints_2() });
     return 0;
 }

tests/unit/out/unsafe/netdb.rs

@@ -165,28 +165,7 @@ pub unsafe fn test_ipv6_literal_1() {
     );
     libc::freeaddrinfo(res);
 }
-pub unsafe fn test_family_mismatch_2() {
-    let mut hints: ::libc::addrinfo = unsafe { std::mem::zeroed() };
-    hints.ai_flags = 0;
-    hints.ai_protocol = 0;
-    hints.ai_addrlen = 0_u32;
-    hints.ai_addr = std::ptr::null_mut();
-    hints.ai_canonname = std::ptr::null_mut();
-    hints.ai_next = std::ptr::null_mut();
-    hints.ai_family = libc::AF_INET6;
-    hints.ai_socktype = libc::SOCK_STREAM;
-    let mut res: *mut ::libc::addrinfo = std::ptr::null_mut();
-    assert!(
-        ((((libc::getaddrinfo(
-            (c"127.0.0.1".as_ptr().cast_mut()).cast_const(),
-            (c"80".as_ptr().cast_mut()).cast_const(),
-            (&mut hints as *mut ::libc::addrinfo).cast_const(),
-            (&mut res as *mut *mut ::libc::addrinfo)
-        )) != (0)) as i32)
-            != 0)
-    );
-}
-pub unsafe fn test_null_hints_3() {
+pub unsafe fn test_null_hints_2() {
     let mut res: *mut ::libc::addrinfo = std::ptr::null_mut();
     assert!(
         ((((libc::getaddrinfo(
@@ -233,7 +212,6 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     (unsafe { test_ipv4_literal_0() });
     (unsafe { test_ipv6_literal_1() });
-    (unsafe { test_family_mismatch_2() });
-    (unsafe { test_null_hints_3() });
+    (unsafe { test_null_hints_2() });
     return 0;
 }