From 088543caf91d7ce3a17bbffb3a7a6cf0e34971f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Kr=C3=B6ning?= Date: Thu, 2 Jan 2025 17:06:39 +0100 Subject: [PATCH] fix(tests): clean up comments --- tests/basic_math.rs | 5 -- tests/basic_mem.rs | 5 +- tests/basic_print.rs | 6 -- tests/common/mod.rs | 168 ++----------------------------------------- 4 files changed, 7 insertions(+), 177 deletions(-) diff --git a/tests/basic_math.rs b/tests/basic_math.rs index 1b105470cd..f1bf705e61 100644 --- a/tests/basic_math.rs +++ b/tests/basic_math.rs @@ -5,11 +5,6 @@ #![feature(custom_test_frameworks)] #![reexport_test_harness_main = "test_main"] -/// Regarding `#[test]` and `#[test_case]` this comment explains the current implementation -/// https://github.com/rust-lang/rust/issues/50297#issuecomment-524180479 -/// This is of course subject to change, since the whole feature is not stable -/// -//extern crate x86_64; #[macro_use] extern crate float_cmp; diff --git a/tests/basic_mem.rs b/tests/basic_mem.rs index 75aaf7c5be..5099fa0dc7 100644 --- a/tests/basic_mem.rs +++ b/tests/basic_mem.rs @@ -7,12 +7,11 @@ extern crate alloc; +mod common; + use alloc::vec::Vec; use core::mem::size_of; -//no-std otherwise std::mem::size_of -mod common; - const PATTERN: u8 = 0xab; /// Mainly test if memcpy works as expected. Also somewhat tests memcmp diff --git a/tests/basic_print.rs b/tests/basic_print.rs index 65b1bd199b..13b109734e 100644 --- a/tests/basic_print.rs +++ b/tests/basic_print.rs @@ -1,11 +1,5 @@ -#![feature(test)] #![no_std] #![no_main] -//#![test_runner(hermit::test_runner)] -//#![feature(custom_test_frameworks)] -//#![reexport_test_harness_main = "test_main"] - -//use core::panic::PanicInfo; extern crate alloc; diff --git a/tests/common/mod.rs b/tests/common/mod.rs index afdb932bf5..074465e023 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -1,168 +1,10 @@ -/// Common functionality for all integration tests -/// Note: If you encounter `error[E0463]: can't find crate for 'test'`, rememmber to add -/// `harness = false` to the [[test]] section of cargo.toml -use hermit::{print, println}; - -//use std::borrow::Cow; -//use std::fmt; - -//From libtest types.rs----------------------------------------------------- -/* -/// Type of the test according to the [rust book](https://doc.rust-lang.org/cargo/guide/tests.html) -/// conventions. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] -pub enum TestType { - /// Unit-tests are expected to be in the `src` folder of the crate. - UnitTest, - /// Integration-style tests are expected to be in the `tests` folder of the crate. - IntegrationTest, - /// Doctests are created by the `librustdoc` manually, so it's a different type of test. - DocTest, - /// Tests for the sources that don't follow the project layout convention - /// (e.g. tests in raw `main.rs` compiled by calling `rustc --test` directly). - Unknown, -} - -#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] -pub enum NamePadding { - PadNone, - PadOnRight, -} - -// The name of a test. By convention this follows the rules for rust -// paths; i.e., it should be a series of identifiers separated by double -// colons. This way if some test runner wants to arrange the tests -// hierarchically it may. -#[derive(Clone, PartialEq, Eq, Hash, Debug)] -pub enum TestName { - StaticTestName(&'static str), - DynTestName(String), - AlignedTestName(Cow<'static, str>, NamePadding), -} - -impl TestName { - pub fn as_slice(&self) -> &str { - match *self { - StaticTestName(s) => s, - DynTestName(ref s) => s, - AlignedTestName(ref s, _) => &*s, - } - } - - pub fn padding(&self) -> NamePadding { - match self { - &AlignedTestName(_, p) => p, - _ => PadNone, - } - } - - pub fn with_padding(&self, padding: NamePadding) -> TestName { - let name = match *self { - TestName::StaticTestName(name) => Cow::Borrowed(name), - TestName::DynTestName(ref name) => Cow::Owned(name.clone()), - TestName::AlignedTestName(ref name, _) => name.clone(), - }; - - TestName::AlignedTestName(name, padding) - } -} -impl fmt::Display for TestName { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt::Display::fmt(self.as_slice(), f) - } -} - -/// Represents a benchmark function. -pub trait TDynBenchFn: Send { - fn run(&self, harness: &mut Bencher); -} - -// A function that runs a test. If the function returns successfully, -// the test succeeds; if the function panics then the test fails. We -// may need to come up with a more clever definition of test in order -// to support isolation of tests into threads. -pub enum TestFn { - StaticTestFn(fn()), - StaticBenchFn(fn(&mut Bencher)), - DynTestFn(Box), - DynBenchFn(Box), -} +//! Common code for integration tests. +//! +//! See https://github.com/rust-lang/rust/blob/1.83.0/library/test/src/types.rs for reference. +//! See https://github.com/rust-lang/rust/issues/50297#issuecomment-524180479 for details. -impl TestFn { - pub fn padding(&self) -> NamePadding { - match *self { - StaticTestFn(..) => PadNone, - StaticBenchFn(..) => PadOnRight, - DynTestFn(..) => PadNone, - DynBenchFn(..) => PadOnRight, - } - } -} - -impl fmt::Debug for TestFn { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(match *self { - StaticTestFn(..) => "StaticTestFn(..)", - StaticBenchFn(..) => "StaticBenchFn(..)", - DynTestFn(..) => "DynTestFn(..)", - DynBenchFn(..) => "DynBenchFn(..)", - }) - } -} - -// The definition of a single test. A test runner will run a list of -// these. -#[derive(Clone, Debug, PartialEq, Eq, Hash)] -pub struct TestDesc { - pub name: TestName, - pub ignore: bool, - pub should_panic: options::ShouldPanic, - pub allow_fail: bool, - pub test_type: TestType, -} - -impl TestDesc { - pub fn padded_name(&self, column_count: usize, align: NamePadding) -> String { - let mut name = String::from(self.name.as_slice()); - let fill = column_count.saturating_sub(name.len()); - let pad = " ".repeat(fill); - match align { - PadNone => name, - PadOnRight => { - name.push_str(&pad); - name - } - } - } -} - -#[derive(Debug)] -pub struct TestDescAndFn { - pub desc: TestDesc, - pub testfn: TestFn, -} -*/ -// End from libtest ------------------------------------------------------------ -/* -extern crate test; -use self::test::TestFn::StaticTestFn; -use test::TestDescAndFn; - - -pub fn test_runner(tests: &[&TestDescAndFn]) { - println!("Running {} tests", tests.len()); - for test in tests { - let TestDescAndFn { desc, testfn } = test; - println!("Running {}", desc.name); - match testfn { - StaticTestFn(f) => f(), - _ => panic!("hermit currently only support Static test functions"), - } - } - exit(false); -}*/ +use hermit::{print, println}; -/// For test_case (without `TestDesc`) pub trait Testable { fn run(&self); }