Idiomatic way to enable/disable check of invariants? / include code if feature or test

1

I want to include a method only when in test mode or when a feature is enabled.
In the playground I am not sure how to specify features; so the playground is not really showing the whole problem.

I tried to add the following before the method fn check_invariants(&self) { but these attempts do not work.

  • #[cfg(feature = "check_invariants", test)]
  • #[cfg(feature = "check_invariants" or test)]
  • #[cfg(feature = "check_invariants"),cfg(test)]
  • #[cfg(feature = "check_invariants")]#[cfg(test)]

Is there some better/idiomatic way to enable/disable online sanity checks?

2

I think you want to use the any() predicate. Here's an example from the reference on Conditional compilation:

// This function is only included when either foo or bar is defined
#[cfg(any(foo, bar))]
fn needs_foo_or_bar() {
  // ...
}

// This function is only included when compiling for a unixish OS with a 32-bit
// architecture
#[cfg(all(unix, target_pointer_width = "32"))]
fn on_32bit_unix() {
  // ...
}

// This function is only included when foo is not defined
#[cfg(not(foo))]
fn needs_not_foo() {
  // ...
}

In your case, that should be

#[cfg(any(feature = "check_invariants", test))]
3

debug_assert!()s are the idiomatic way to do this. Note this paragraph though:

An unchecked assertion allows a program in an inconsistent state to keep running, which might have unexpected consequences but does not introduce unsafety as long as this only happens in safe code. The performance cost of assertions, however, is not measurable in general. Replacing assert! with debug_assert! is thus only encouraged after thorough profiling, and more importantly, only in safe code!

2 Likes
4

Thanks! I was missing the any() syntax. It works now.

1 Like
5

Hm, "debug_assert is only included in non-optimized builds by default".
I guess that I want to have a little more control to enable/disable invariant checks by crate especially if/when my project becomes much larger.

Hm, now I wonder when debug_assert really makes sense for larger codebases: can one use another crate in release mode while compiling the current crate in debug mode? This seems to be the case for std.

6

It is better to put the cfg in the method, which makes it do nothing if not enabled. That way, you don't have to put the cfg on every usage of the method.

fn check_invariants(&self) {
    #[cfg(any(features = "check_invariants", test))]
    assert_eq!(self.val1, self.val2);
}
1 Like
7

You can do that with cargo profiles and overrides, e.g.

[profile.release.package.foo]
debug-assertions = true

[profile.dev.package.bar]
debug-assertions = false
2 Likes
8

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.