Add ThreadInfo and WorkQueueInfo examples and tests (#137)

* Remove redundant imports and simplify doc example
* Add doc example for TaskInfo
* Add ThreadInfo doc example/test and a unit test for it
* Add WorkQueueInfo doc example/test and a unit test for it

Author: andrewdavidmackenzie

src/libproc/file_info.rs

@@ -87,8 +87,8 @@ impl From<u32> for ProcFDType {
     }
 }
 
-/// The `PIDFDInfo` trait is needed for polymorphism on pidfdinfo types, also abstracting flavor in order to provide
-/// type-guaranteed flavor correctness
+/// The `PIDFDInfo` trait is needed for polymorphism on pidfdinfo types, also abstracting flavor
+/// in order to provide type-guaranteed flavor correctness
 pub trait PIDFDInfo: Default {
     /// Return the Pid File Descriptor Info flavor of the implementing struct
     fn flavor() -> PIDFDInfoFlavor;
@@ -105,7 +105,7 @@ pub trait PIDFDInfo: Default {
 /// ```
 /// use std::io::Write;
 /// use std::net::TcpListener;
-/// use libproc::libproc::proc_pid::{listpidinfo, pidinfo, ListThreads};
+/// use libproc::libproc::proc_pid::{listpidinfo, pidinfo};
 /// use libproc::libproc::bsd_info::{BSDInfo};
 /// use libproc::libproc::net_info::{SocketFDInfo, SocketInfoKind};
 /// use libproc::libproc::file_info::{pidfdinfo, ListFDs, ProcFDType};
@@ -116,45 +116,38 @@ pub trait PIDFDInfo: Default {
 /// // Open TCP port:8000 to test.
 /// let _listener = TcpListener::bind("127.0.0.1:8000");
 ///
-/// if let Ok(info) = pidinfo::<BSDInfo>(pid, 0) {
-///     if let Ok(fds) = listpidinfo::<ListFDs>(pid, info.pbi_nfiles as usize) {
-///         for fd in &fds {
-///             match fd.proc_fdtype.into() {
-///                 ProcFDType::Socket => {
-///                     if let Ok(socket) = pidfdinfo::<SocketFDInfo>(pid, fd.proc_fd) {
-///                         match socket.psi.soi_kind.into() {
-///                             SocketInfoKind::Tcp => {
-///                                 // access to the member of `soi_proto` is unsafe becasuse of union type.
-///                                let info = unsafe { socket.psi.soi_proto.pri_tcp };
+/// let info = pidinfo::<BSDInfo>(pid, 0).expect("Could not get BSDInfo on {pid}");///
+/// let fds = listpidinfo::<ListFDs>(pid, info.pbi_nfiles as usize)
+///     .expect("Could not list FD of {pid}");
+/// for fd in &fds {
+///     if let(ProcFDType::Socket) = fd.proc_fdtype.into() {
+///         let socket = pidfdinfo::<SocketFDInfo>(pid, fd.proc_fd)
+///             .expect("Could not get SocketFDInfo");
+///         if let(SocketInfoKind::Tcp) = socket.psi.soi_kind.into() {
+///             // access to the member of `soi_proto` is unsafe becasuse of union type.
+///             let info = unsafe { socket.psi.soi_proto.pri_tcp };
 ///
-///                                 // change endian and cut off because insi_lport is network endian and 16bit witdh.
-///                                 let mut port = 0;
-///                                 port |= info.tcpsi_ini.insi_lport >> 8 & 0x00ff;
-///                                 port |= info.tcpsi_ini.insi_lport << 8 & 0xff00;
+///             // change endian and cut off because insi_lport is network endian and 16bit witdh.
+///             let mut port = 0;
+///             port |= info.tcpsi_ini.insi_lport >> 8 & 0x00ff;
+///             port |= info.tcpsi_ini.insi_lport << 8 & 0xff00;
 ///
-///                                 // access to the member of `insi_laddr` is unsafe becasuse of union type.
-///                                 let s_addr = unsafe { info.tcpsi_ini.insi_laddr.ina_46.i46a_addr4.s_addr };
+///             // access to the member of `insi_laddr` is unsafe becasuse of union type.
+///             let s_addr = unsafe { info.tcpsi_ini.insi_laddr.ina_46.i46a_addr4.s_addr };
 ///
-///                                 // change endian because insi_laddr is network endian.
-///                                 let mut addr = 0;
-///                                 addr |= s_addr >> 24 & 0x000000ff;
-///                                 addr |= s_addr >> 8  & 0x0000ff00;
-///                                 addr |= s_addr << 8  & 0x00ff0000;
-///                                 addr |= s_addr << 24 & 0xff000000;
+///             // change endian because insi_laddr is network endian.
+///             let mut addr = 0;
+///             addr |= s_addr >> 24 & 0x000000ff;
+///             addr |= s_addr >> 8  & 0x0000ff00;
+///             addr |= s_addr << 8  & 0x00ff0000;
+///             addr |= s_addr << 24 & 0xff000000;
 ///
-///                                 println!("{}.{}.{}.{}:{}", addr >> 24 & 0xff, addr >> 16 & 0xff, addr >> 8 & 0xff, addr & 0xff, port);
-///                             }
-///                             _ => (),
-///                         }
-///                     }
-///                 }
-///                 _ => (),
-///             }
+///             println!("{}.{}.{}.{}:{}", addr >> 24 & 0xff, addr >> 16 & 0xff, addr >> 8 & 0xff,
+///                         addr & 0xff, port);
 ///         }
 ///     }
 /// }
 /// ```
-///
 #[cfg(target_os = "macos")]
 pub fn pidfdinfo<T: PIDFDInfo>(pid: i32, fd: i32) -> Result<T, String> {
     let flavor = T::flavor() as i32;

src/libproc/proc_pid.rs

@@ -205,11 +205,11 @@ pub fn listpidspath(proc_types: ProcType, path: &str) -> Result<Vec<u32>, String
 }
 
 /// Get info about a process, task, thread or work queue by specifying the appropriate type for `T`:
-/// - `BSDInfo`
-/// - `TaskInfo`
-/// - `TaskAllInfo`
-/// - `ThreadInfo`
-/// - `WorkQueueInfo`
+/// - `BSDInfo` - see struct `proc_bsdinfo` in generated `osx_libproc_bindings.rs`
+/// - `TaskInfo` - see struct `proc_taskinfo` in generated `osx_libproc_bindings.rs`
+/// - `TaskAllInfo` - see struct `TaskAllInfo` in `task_info.rs` that contains the two structs above
+/// - `ThreadInfo` - see struct `proc_threadinfo` in generated `osx_libproc_bindings.rs`
+/// - `WorkQueueInfo` - see struct `proc_workqueueinfo` in generated `osx_libproc_bindings.rs`
 ///
 /// # Errors
 ///
@@ -219,17 +219,47 @@ pub fn listpidspath(proc_types: ProcType, path: &str) -> Result<Vec<u32>, String
 ///
 /// ```
 /// use std::io::Write;
-/// use libproc::libproc::proc_pid::pidinfo;
-/// use libproc::libproc::bsd_info::BSDInfo;
+/// use libproc::proc_pid::pidinfo;
+/// use libproc::bsd_info::BSDInfo;
+/// use libproc::task_info::{TaskAllInfo, TaskInfo};
 /// use std::process;
+/// use libproc::thread_info::ThreadInfo;
+/// use libproc::work_queue_info::WorkQueueInfo;
 ///
 /// let pid = process::id() as i32;
 ///
-/// // Get the `BSDInfo` for Process of pid 0
+/// // Get the `BSDInfo` for process with pid 0
 /// match pidinfo::<BSDInfo>(pid, 0) {
 ///     Ok(info) => assert_eq!(info.pbi_pid as i32, pid),
 ///     Err(err) => eprintln!("Error retrieving process info: {}", err)
 /// };
+///
+/// // Get the `TaskInfo` for process with pid 0
+/// match pidinfo::<TaskInfo>(pid, 0) {
+///     Ok(info) => assert!(info.pti_threadnum  > 0),
+///     Err(err) => eprintln!("Error retrieving process info: {}", err)
+/// };
+///
+/// // Get the `TaskAllInfo` for process with pid 0
+/// match pidinfo::<TaskAllInfo>(pid, 0) {
+///     Ok(info) => {
+///         assert_eq!(info.pbsd.pbi_pid as i32, pid);
+///         assert!(info.ptinfo.pti_threadnum  > 0);
+///     }
+///     Err(err) => eprintln!("Error retrieving process info: {}", err)
+/// };
+///
+/// // Get the `ThreadInfo` for process with pid 0
+/// match pidinfo::<ThreadInfo>(pid, 0) {
+///     Ok(info) => assert!(!info.pth_name.is_empty()),
+///     Err(err) => eprintln!("Error retrieving process info: {}", err)
+/// };
+///
+/// // Get the `WorkQueueInfo` for process with pid 0
+/// match pidinfo::<WorkQueueInfo>(pid, 0) {
+///     Ok(info) => assert!(info.pwq_nthreads > 0),
+///     Err(err) => eprintln!("Error retrieving process info: {}", err)
+/// };
 /// ```
 #[cfg(target_os = "macos")]
 pub fn pidinfo<T: PIDInfo>(pid: i32, arg: u64) -> Result<T, String> {
@@ -670,25 +700,19 @@ mod test {
         };
     }
 
-    #[ignore]
     #[cfg(target_os = "macos")]
     #[test]
     fn threadinfo_test() {
-        let pid = process::id() as i32;
-
-        match pidinfo::<ThreadInfo>(pid, 0) {
-            Ok(info) => assert!(info.pth_user_time > 0),
+        match pidinfo::<ThreadInfo>(0, 0) {
+            Ok(info) => assert!(!info.pth_name.is_empty()),
             Err(e) => panic!("Error retrieving ThreadInfo: {}", e),
         };
     }
 
-    #[ignore]
     #[cfg(target_os = "macos")]
     #[test]
     fn workqueueinfo_test() {
-        let pid = process::id() as i32;
-
-        match pidinfo::<WorkQueueInfo>(pid, 0) {
+        match pidinfo::<WorkQueueInfo>(1, 0) {
             Ok(info) => assert!(info.pwq_nthreads > 0),
             Err(e) => panic!("{}: {}", "Error retrieving WorkQueueInfo", e),
         };