Inner function cannot be tested

I really would like to be able to this:

fn outer(x: i32) -> i32 {
    fn inner(a: i32, b: i32) -> i32 {
        a + b
    }
    #[test]
    fn test_inner() {
        assert_eq!(inner(3, 5), 8);
    }
    inner(x, 5)
}

#[test]
fn test_outer() {
    assert_eq!(outer(3), 8);
}

But why though ? Do you want to be able to test things inner to your function ? How about an assert_test! that would compile / trigger only when in test mode ? Just an idea.

Because this is convenient for testing nested functions. Currently I'd have to move the fn outside to be able to test it separately.

@Cobrand

@Cobrand Yeah, something like this will be great:

assert!
assert_eq!
debug_assert!
debug_assert_eq!
test_assert!
test_assert_eq!

I'm just arguing against my own idea here, but that would require either :

Require to recompile everything related for "test", which I don't know which is a good idea or not
Compile this only in debug mode, but only run it when doing test (so it's still in the binary but there is a conditional for whether or not this is in test mode)

My code is horrible so it doesn't have that much tests, is it possible to run tests in release mode ? If that is the case, the second option is a no-no I guess.

The problem with this is that the test harness needs to access the inner functions, which it can't do because you can't name them.

I'm marking as a diagnostics issue so that we print a warning in this case at least.

@pnkfelix

Auto merge of #51450 - estebank:inner-fn-test, r=@pnkfelix

Why was the #51450 PR accepted, while the RFC is still unmerged?

I disagree with the approach taken (a new lint), we should either (rust-lang/rfcs#2471 (comment)):

figure out why unused_attribute isn't firing, and let that handle the lint side
properly support #[test] functions anywhere, as per Add lint warning for inner function marked as #[test] rfcs#2471 (comment)

Auto merge of rust-lang#114414 - cjgillot:early-unnameable-test, r=pe…

Auto merge of #114414 - cjgillot:early-unnameable-test, r=petrochenkov

I would like this in order for a macro to be able to generate tests without having to come up with a name for the tests.

Example: something like

macro_rules! tested_varule {
    ($type:path, $bytes:expr) => {{
        const BYTES: &[u8] = $bytes;
        #[test]
        fn test_tested_varule() {
            use $crate::ule::VarULE;
            assert!(<$type>::validate_bytes(BYTES).is_ok());
        }
        // Safety: If the above test passes, then these are valid bytes
        unsafe {
            &*(BYTES as *const [u8] as *const $type)
        }
    }};
}

const MY_STR_1: &str = tested_varule!(str, &[0x61, 0x62, 0x63]);

Navigation Menu

Repository navigation

Inner function cannot be tested #36629

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Inner function cannot be tested #36629

Description

Activity

Cobrand commented on Sep 21, 2016

kineticz commented on Sep 21, 2016

kineticz commented on Sep 21, 2016

Cobrand commented on Sep 21, 2016

Aatch commented on Sep 22, 2016

Mark-Simulacrum commented on May 13, 2017

eddyb commented on Jul 13, 2018

PaulDotSH commented on Jun 12, 2022

sffc commented on Apr 25, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions