Revert "Restructure tests to avoid future conflicts"

This reverts commit 0cadc91.

Author: lucic71

tests/unit/fd_io.c

@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <fcntl.h>
 #include <string.h>
+#include <sys/socket.h>
 #include <unistd.h>
 
 int main(void) {
@@ -18,5 +19,18 @@ int main(void) {
   assert(read(fd, buf, sizeof(buf)) == 0);
   assert(close(fd) == 0);
   assert(unlink(path) == 0);
+  int fds[2];
+  assert(pipe(fds) == 0);
+  assert(write(fds[1], "ab", 2) == 2);
+  char buf2[4];
+  memset(buf2, 0, sizeof(buf2));
+  assert(read(fds[0], buf2, sizeof(buf2)) == 2);
+  assert(strcmp(buf2, "ab") == 0);
+  assert(close(fds[1]) == 0);
+  assert(read(fds[0], buf2, sizeof(buf2)) == 0);
+  assert(close(fds[0]) == 0);
+  int s = socket(AF_INET, SOCK_STREAM, 0);
+  assert(s >= 0);
+  assert(close(s) == 0);
   return 0;
 }

tests/unit/isatty.c

@@ -138,5 +138,129 @@ fn main_0() -> i32 {
         } == 0) as i32)
             != 0)
     );
+    let fds: Value<Box<[i32]>> = Rc::new(RefCell::new(
+        (0..2).map(|_| <i32>::default()).collect::<Box<[i32]>>(),
+    ));
+    assert!(
+        (((match nix::unistd::pipe() {
+            Ok((__r, __w)) => {
+                let __fds = (fds.as_pointer() as Ptr<i32>).clone();
+                __fds.write(FdRegistry::register(__r));
+                __fds.offset(1).write(FdRegistry::register(__w));
+                0
+            }
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((match FdRegistry::with_fd((*fds.borrow())[(1) as usize], |__fd| {
+            Ptr::from_string_literal(b"ab")
+                .to_any()
+                .reinterpret_cast::<u8>()
+                .with_slice(2_usize, |__buf| nix::unistd::write(__fd, __buf))
+        }) {
+            Ok(__n) => __n as isize,
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        } == 2_isize) as i32)
+            != 0)
+    );
+    let buf2: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..4).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    {
+        ((buf2.as_pointer() as Ptr<u8>) as Ptr<u8>)
+            .to_any()
+            .memset((0) as u8, ::std::mem::size_of::<[u8; 4]>() as usize);
+        ((buf2.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+    };
+    assert!(
+        (((match FdRegistry::with_fd((*fds.borrow())[(0) as usize], |__fd| {
+            ((buf2.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                .to_any()
+                .reinterpret_cast::<u8>()
+                .with_slice_mut(::std::mem::size_of::<[u8; 4]>(), |__buf| {
+                    nix::unistd::read(__fd, __buf)
+                })
+        }) {
+            Ok(__n) => __n as isize,
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        } == 2_isize) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __it1 = (buf2.as_pointer() as Ptr<u8>).to_c_string_iterator();
+            let mut __it2 = Ptr::from_string_literal(b"ab").to_c_string_iterator();
+            loop {
+                let __c1 = __it1.next();
+                let __c2 = __it2.next();
+                if __c1 != __c2 {
+                    break (__c1.unwrap_or(0) as i32) - (__c2.unwrap_or(0) as i32);
+                }
+                if __c1.is_none() {
+                    break 0;
+                }
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!((((FdRegistry::close((*fds.borrow())[(1) as usize]) == 0) as i32) != 0));
+    assert!(
+        (((match FdRegistry::with_fd((*fds.borrow())[(0) as usize], |__fd| {
+            ((buf2.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                .to_any()
+                .reinterpret_cast::<u8>()
+                .with_slice_mut(::std::mem::size_of::<[u8; 4]>(), |__buf| {
+                    nix::unistd::read(__fd, __buf)
+                })
+        }) {
+            Ok(__n) => __n as isize,
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        } == 0_isize) as i32)
+            != 0)
+    );
+    assert!((((FdRegistry::close((*fds.borrow())[(0) as usize]) == 0) as i32) != 0));
+    let s: Value<i32> = Rc::new(RefCell::new({
+        let __family = match libc::AF_INET {
+            ::libc::AF_INET => nix::sys::socket::AddressFamily::Inet,
+            ::libc::AF_INET6 => nix::sys::socket::AddressFamily::Inet6,
+            ::libc::AF_UNIX => nix::sys::socket::AddressFamily::Unix,
+            __d => panic!("socket: unsupported domain {__d}"),
+        };
+        let __flags = nix::sys::socket::SockFlag::from_bits_truncate(libc::SOCK_STREAM);
+        let __ty = match libc::SOCK_STREAM & !nix::sys::socket::SockFlag::all().bits() {
+            ::libc::SOCK_STREAM => nix::sys::socket::SockType::Stream,
+            ::libc::SOCK_DGRAM => nix::sys::socket::SockType::Datagram,
+            __t => panic!("socket: unsupported type {__t}"),
+        };
+        let __proto = match 0 {
+            0 => None,
+            ::libc::IPPROTO_TCP => Some(nix::sys::socket::SockProtocol::Tcp),
+            ::libc::IPPROTO_UDP => Some(nix::sys::socket::SockProtocol::Udp),
+            __p => panic!("socket: unsupported protocol {__p}"),
+        };
+        match nix::sys::socket::socket(__family, __ty, __flags, __proto) {
+            Ok(__ofd) => FdRegistry::register(__ofd),
+            Err(__e) => {
+                libcc2rs::cpp2rust_errno().write(__e as i32);
+                -1
+            }
+        }
+    }));
+    assert!(((((*s.borrow()) >= 0) as i32) != 0));
+    assert!((((FdRegistry::close((*s.borrow())) == 0) as i32) != 0));
     return 0;
 }