Skip to content

Commit c0d8ad4

Browse files
authored
refactor: move tests to the test dir (#2257)
* refactor: move tests to the test dir * try fixing it * try fixing it * fix Redox and FreeBSD * document it
1 parent 26b070a commit c0d8ad4

30 files changed

+1089
-1114
lines changed

CONVENTIONS.md

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -124,3 +124,10 @@ cases, it will be the version of the next release. And a user-friendly note
124124
should be added. Normally, there should be a new interface that will replace
125125
the old one, so a note should be something like: "`<New Interface>` should be
126126
used instead".
127+
128+
## Where to put a test
129+
130+
If you want to add a test for a feature that is in `xxx.rs`, then the test should
131+
be put in the corresponding `test_xxx.rs` file unless you cannot do this, e.g.,
132+
the test involves private stuff and thus cannot be added outside of Nix, then
133+
it is allowed to leave the test in `xxx.rs`.

src/sys/aio.rs

Lines changed: 0 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -1191,56 +1191,3 @@ pub fn lio_listio(
11911191
})
11921192
.map(drop)
11931193
}
1194-
1195-
#[cfg(test)]
1196-
mod t {
1197-
use super::*;
1198-
1199-
/// aio_suspend relies on casting Rust Aio* struct pointers to libc::aiocb
1200-
/// pointers. This test ensures that such casts are valid.
1201-
#[test]
1202-
fn casting() {
1203-
let sev = SigevNotify::SigevNone;
1204-
let aiof = AioFsync::new(666, AioFsyncMode::O_SYNC, 0, sev);
1205-
assert_eq!(
1206-
aiof.as_ref() as *const libc::aiocb,
1207-
&aiof as *const AioFsync as *const libc::aiocb
1208-
);
1209-
1210-
let mut rbuf = [];
1211-
let aior = AioRead::new(666, 0, &mut rbuf, 0, sev);
1212-
assert_eq!(
1213-
aior.as_ref() as *const libc::aiocb,
1214-
&aior as *const AioRead as *const libc::aiocb
1215-
);
1216-
1217-
let wbuf = [];
1218-
let aiow = AioWrite::new(666, 0, &wbuf, 0, sev);
1219-
assert_eq!(
1220-
aiow.as_ref() as *const libc::aiocb,
1221-
&aiow as *const AioWrite as *const libc::aiocb
1222-
);
1223-
}
1224-
1225-
#[cfg(target_os = "freebsd")]
1226-
#[test]
1227-
fn casting_vectored() {
1228-
let sev = SigevNotify::SigevNone;
1229-
1230-
let mut rbuf = [];
1231-
let mut rbufs = [IoSliceMut::new(&mut rbuf)];
1232-
let aiorv = AioReadv::new(666, 0, &mut rbufs[..], 0, sev);
1233-
assert_eq!(
1234-
aiorv.as_ref() as *const libc::aiocb,
1235-
&aiorv as *const AioReadv as *const libc::aiocb
1236-
);
1237-
1238-
let wbuf = [];
1239-
let wbufs = [IoSlice::new(&wbuf)];
1240-
let aiowv = AioWritev::new(666, 0, &wbufs, 0, sev);
1241-
assert_eq!(
1242-
aiowv.as_ref() as *const libc::aiocb,
1243-
&aiowv as *const AioWritev as *const libc::aiocb
1244-
);
1245-
}
1246-
}

src/sys/event.rs

Lines changed: 0 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -441,42 +441,3 @@ pub fn ev_set(
441441
ev.kevent.data = 0;
442442
ev.kevent.udata = udata as type_of_udata;
443443
}
444-
445-
#[test]
446-
fn test_struct_kevent() {
447-
use std::mem;
448-
449-
let udata: intptr_t = 12345;
450-
451-
let actual = KEvent::new(
452-
0xdead_beef,
453-
EventFilter::EVFILT_READ,
454-
EventFlag::EV_ONESHOT | EventFlag::EV_ADD,
455-
FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
456-
0x1337,
457-
udata,
458-
);
459-
assert_eq!(0xdead_beef, actual.ident());
460-
let filter = actual.kevent.filter;
461-
assert_eq!(libc::EVFILT_READ, filter);
462-
assert_eq!(libc::EV_ONESHOT | libc::EV_ADD, actual.flags().bits());
463-
assert_eq!(libc::NOTE_CHILD | libc::NOTE_EXIT, actual.fflags().bits());
464-
assert_eq!(0x1337, actual.data());
465-
assert_eq!(udata as type_of_udata, actual.udata() as type_of_udata);
466-
assert_eq!(mem::size_of::<libc::kevent>(), mem::size_of::<KEvent>());
467-
}
468-
469-
#[test]
470-
fn test_kevent_filter() {
471-
let udata: intptr_t = 12345;
472-
473-
let actual = KEvent::new(
474-
0xdead_beef,
475-
EventFilter::EVFILT_READ,
476-
EventFlag::EV_ONESHOT | EventFlag::EV_ADD,
477-
FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
478-
0x1337,
479-
udata,
480-
);
481-
assert_eq!(EventFilter::EVFILT_READ, actual.filter().unwrap());
482-
}

src/sys/resource.rs

Lines changed: 0 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -396,28 +396,3 @@ pub fn getrusage(who: UsageWho) -> Result<Usage> {
396396
Errno::result(res).map(|_| Usage(rusage.assume_init()))
397397
}
398398
}
399-
400-
#[cfg(test)]
401-
mod test {
402-
use super::{getrusage, UsageWho};
403-
404-
#[test]
405-
pub fn test_self_cpu_time() {
406-
// Make sure some CPU time is used.
407-
let mut numbers: Vec<i32> = (1..1_000_000).collect();
408-
numbers.iter_mut().for_each(|item| *item *= 2);
409-
410-
// FIXME: this is here to help ensure the compiler does not optimize the whole
411-
// thing away. Replace the assert with test::black_box once stabilized.
412-
assert_eq!(numbers[100..200].iter().sum::<i32>(), 30_100);
413-
414-
let usage = getrusage(UsageWho::RUSAGE_SELF)
415-
.expect("Failed to call getrusage for SELF");
416-
let rusage = usage.as_ref();
417-
418-
let user = usage.user_time();
419-
assert!(user.tv_sec() > 0 || user.tv_usec() > 0);
420-
assert_eq!(user.tv_sec(), rusage.ru_utime.tv_sec);
421-
assert_eq!(user.tv_usec(), rusage.ru_utime.tv_usec);
422-
}
423-
}

src/sys/select.rs

Lines changed: 0 additions & 224 deletions
Original file line numberDiff line numberDiff line change
@@ -317,227 +317,3 @@ where
317317
Errno::result(res)
318318
}
319319
}
320-
321-
#[cfg(test)]
322-
mod tests {
323-
use super::*;
324-
use crate::sys::time::{TimeVal, TimeValLike};
325-
use crate::unistd::{pipe, write};
326-
use std::os::unix::io::{AsFd, RawFd};
327-
328-
#[test]
329-
fn fdset_insert() {
330-
let mut fd_set = FdSet::new();
331-
332-
for i in 0..FD_SETSIZE {
333-
let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
334-
assert!(!fd_set.contains(borrowed_i));
335-
}
336-
337-
let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
338-
fd_set.insert(fd_seven);
339-
340-
assert!(fd_set.contains(fd_seven));
341-
}
342-
343-
#[test]
344-
fn fdset_remove() {
345-
let mut fd_set = FdSet::new();
346-
347-
for i in 0..FD_SETSIZE {
348-
let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
349-
assert!(!fd_set.contains(borrowed_i));
350-
}
351-
352-
let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
353-
fd_set.insert(fd_seven);
354-
fd_set.remove(fd_seven);
355-
356-
for i in 0..FD_SETSIZE {
357-
let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
358-
assert!(!fd_set.contains(borrowed_i));
359-
}
360-
}
361-
362-
#[test]
363-
#[allow(non_snake_case)]
364-
fn fdset_clear() {
365-
let mut fd_set = FdSet::new();
366-
let fd_one = unsafe { BorrowedFd::borrow_raw(1) };
367-
let fd_FD_SETSIZE_divided_by_two =
368-
unsafe { BorrowedFd::borrow_raw((FD_SETSIZE / 2) as RawFd) };
369-
let fd_FD_SETSIZE_minus_one =
370-
unsafe { BorrowedFd::borrow_raw((FD_SETSIZE - 1) as RawFd) };
371-
fd_set.insert(fd_one);
372-
fd_set.insert(fd_FD_SETSIZE_divided_by_two);
373-
fd_set.insert(fd_FD_SETSIZE_minus_one);
374-
375-
fd_set.clear();
376-
377-
for i in 0..FD_SETSIZE {
378-
let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
379-
assert!(!fd_set.contains(borrowed_i));
380-
}
381-
}
382-
383-
#[test]
384-
fn fdset_highest() {
385-
let mut set = FdSet::new();
386-
assert_eq!(
387-
set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
388-
None
389-
);
390-
let fd_zero = unsafe { BorrowedFd::borrow_raw(0) };
391-
let fd_ninety = unsafe { BorrowedFd::borrow_raw(90) };
392-
set.insert(fd_zero);
393-
assert_eq!(
394-
set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
395-
Some(0)
396-
);
397-
set.insert(fd_ninety);
398-
assert_eq!(
399-
set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
400-
Some(90)
401-
);
402-
set.remove(fd_zero);
403-
assert_eq!(
404-
set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
405-
Some(90)
406-
);
407-
set.remove(fd_ninety);
408-
assert_eq!(
409-
set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
410-
None
411-
);
412-
413-
let fd_four = unsafe { BorrowedFd::borrow_raw(4) };
414-
let fd_five = unsafe { BorrowedFd::borrow_raw(5) };
415-
let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
416-
set.insert(fd_four);
417-
set.insert(fd_five);
418-
set.insert(fd_seven);
419-
assert_eq!(
420-
set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
421-
Some(7)
422-
);
423-
}
424-
425-
#[test]
426-
fn fdset_fds() {
427-
let mut set = FdSet::new();
428-
let fd_zero = unsafe { BorrowedFd::borrow_raw(0) };
429-
let fd_ninety = unsafe { BorrowedFd::borrow_raw(90) };
430-
assert_eq!(
431-
set.fds(None)
432-
.map(|borrowed_fd| borrowed_fd.as_raw_fd())
433-
.collect::<Vec<_>>(),
434-
vec![]
435-
);
436-
set.insert(fd_zero);
437-
assert_eq!(
438-
set.fds(None)
439-
.map(|borrowed_fd| borrowed_fd.as_raw_fd())
440-
.collect::<Vec<_>>(),
441-
vec![0]
442-
);
443-
set.insert(fd_ninety);
444-
assert_eq!(
445-
set.fds(None)
446-
.map(|borrowed_fd| borrowed_fd.as_raw_fd())
447-
.collect::<Vec<_>>(),
448-
vec![0, 90]
449-
);
450-
451-
// highest limit
452-
assert_eq!(
453-
set.fds(Some(89))
454-
.map(|borrowed_fd| borrowed_fd.as_raw_fd())
455-
.collect::<Vec<_>>(),
456-
vec![0]
457-
);
458-
assert_eq!(
459-
set.fds(Some(90))
460-
.map(|borrowed_fd| borrowed_fd.as_raw_fd())
461-
.collect::<Vec<_>>(),
462-
vec![0, 90]
463-
);
464-
}
465-
466-
#[test]
467-
fn test_select() {
468-
let (r1, w1) = pipe().unwrap();
469-
let (r2, _w2) = pipe().unwrap();
470-
471-
write(&w1, b"hi!").unwrap();
472-
let mut fd_set = FdSet::new();
473-
fd_set.insert(r1.as_fd());
474-
fd_set.insert(r2.as_fd());
475-
476-
let mut timeout = TimeVal::seconds(10);
477-
assert_eq!(
478-
1,
479-
select(None, &mut fd_set, None, None, &mut timeout).unwrap()
480-
);
481-
assert!(fd_set.contains(r1.as_fd()));
482-
assert!(!fd_set.contains(r2.as_fd()));
483-
}
484-
485-
#[test]
486-
fn test_select_nfds() {
487-
let (r1, w1) = pipe().unwrap();
488-
let (r2, _w2) = pipe().unwrap();
489-
490-
write(&w1, b"hi!").unwrap();
491-
let mut fd_set = FdSet::new();
492-
fd_set.insert(r1.as_fd());
493-
fd_set.insert(r2.as_fd());
494-
495-
let mut timeout = TimeVal::seconds(10);
496-
{
497-
assert_eq!(
498-
1,
499-
select(
500-
Some(
501-
fd_set
502-
.highest()
503-
.map(|borrowed_fd| borrowed_fd.as_raw_fd())
504-
.unwrap()
505-
+ 1
506-
),
507-
&mut fd_set,
508-
None,
509-
None,
510-
&mut timeout
511-
)
512-
.unwrap()
513-
);
514-
}
515-
assert!(fd_set.contains(r1.as_fd()));
516-
assert!(!fd_set.contains(r2.as_fd()));
517-
}
518-
519-
#[test]
520-
fn test_select_nfds2() {
521-
let (r1, w1) = pipe().unwrap();
522-
write(&w1, b"hi!").unwrap();
523-
let (r2, _w2) = pipe().unwrap();
524-
let mut fd_set = FdSet::new();
525-
fd_set.insert(r1.as_fd());
526-
fd_set.insert(r2.as_fd());
527-
528-
let mut timeout = TimeVal::seconds(10);
529-
assert_eq!(
530-
1,
531-
select(
532-
std::cmp::max(r1.as_raw_fd(), r2.as_raw_fd()) + 1,
533-
&mut fd_set,
534-
None,
535-
None,
536-
&mut timeout
537-
)
538-
.unwrap()
539-
);
540-
assert!(fd_set.contains(r1.as_fd()));
541-
assert!(!fd_set.contains(r2.as_fd()));
542-
}
543-
}

0 commit comments

Comments
 (0)