Testing is an essential part of software development, especially when coding professionally and improving your code’s quality.
In Rust, testing is built into the language, making writing and running tests straightforward.
This article will introduce you to the basics of testing in Rust with practical examples.
If you prefer a video version
<a href="https://youtu.be/UyJ1mEqKMvE" target="_blank" rel="noopener nofollow"><img src="https://media.daily.dev/image/upload/s--A-DL_waS--/f_auto/v1722342953/ugc/content_008d6952-67a9-4958-b46c-d5ff1f9816f5" alt="VARIABLES (40)"></a>
<h3>Basic Test Function</h3>
Let’s start with a simple test function. In Rust, test functions are annotated with #[test].
<pre><code class="language-rust">#[cfg(test)]
mod tests {
 #[test]
 fn it_works() {
 assert_eq!(2 + 2, 4);
 }
}
</code></pre>
In this example, the #[cfg(test)] attribute ensures that the test module is only compiled when running tests. The #[test] attribute marks the function as a test.
The assert_eq! macro checks if the two arguments are equal. If they are not, the test will fail.
The output of the test will look like this:
<pre><code class="language-shell">running 1 test
test tests::it_works ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
</code></pre>
<h3>Making a Test That Fails</h3>
It’s often useful to see what happens when a test fails.
Here’s an example:
<pre><code class="language-rust">#[cfg(test)]
mod tests {
 #[test]
 fn it_fails() {
 assert_eq!(2 + 2, 5);
 }
}
</code></pre>
When you run this test, it will fail, and you’ll see an error message like this:
<pre><code>---- it_fails stdout ----
thread &#x27;tests::it_fails&#x27; panicked at &#x27;assertion failed: `(left == right)`
 left: `4`,
 right: `5`&#x27;, src/lib.rs:4:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
</code></pre>
<h3>Using the assert! Macro</h3>
The assert! macro is used to check boolean expressions. If the expression evaluates to false, the test will fail.
<pre><code class="language-rust">#[cfg(test)]
mod tests {
 #[test]
 fn check_true() {
 assert!(true);
 }
}
</code></pre>
<h3>Testing Equality with assert_eq! and assert_ne!</h3>
The assert_eq! macro checks if two values are equal, while assert_ne! checks if they are not.
<pre><code class="language-rust">#[cfg(test)]
mod tests {
 #[test]
 fn test_equality() {
 assert_eq!(3 * 3, 9);
 assert_ne!(3 * 3, 8);
 }
}
</code></pre>
<h3>Adding Custom Failure Messages</h3>
You can add custom failure messages to your tests using the assert! macro.
<pre><code class="language-rust">#[cfg(test)]
mod tests {
 #[test]
 fn custom_message() {
 assert_eq!(2 + 2, 5, &quot;Math is broken!&quot;);
 }
}
</code></pre>
In this example, the test will fail with the message “Math is broken!”.
The output will look like this:
<pre><code>---- custom_message stdout ----
thread &#x27;tests::custom_message&#x27; panicked at &#x27;assertion failed: `(left == right)`
 left: `4`,
 right: `5`: Math is broken!&#x27;, src/lib.rs:4:9
</code></pre>
<h3>Checking for Panics with should_panic</h3>
You can test if a function panics using the should_panic attribute.
<pre><code class="language-rust">#[cfg(test)]
mod tests {
 #[test]
 #[should_panic]
 fn it_panics() {
 panic!(&quot;This test will panic&quot;);
 }
}
</code></pre>
<h3>Using Result in Tests</h3>
Test functions can return Result&lt;(), E&gt; to use the ? operator for error handling.
<pre><code class="language-rust">#[cfg(test)]
mod tests {
 #[test]
 fn test_with_result() -&gt; Result&lt;(), String&gt; {
 if 2 + 2 == 4 {
 Ok(())
 } else {
 Err(&quot;Math is broken&quot;.into())
 }
 }
}
</code></pre>
<h3>Conclusion</h3>
Rust makes testing easy and powerful with its built-in features.
By using attributes like #[test], assert!, assert_eq!, and should_panic, you can write robust tests for your code.
If you prefer a video version
<a href="https://youtu.be/UyJ1mEqKMvE" target="_blank" rel="noopener nofollow"><img src="https://media.daily.dev/image/upload/s--A-DL_waS--/f_auto/v1722342953/ugc/content_008d6952-67a9-4958-b46c-d5ff1f9816f5" alt="VARIABLES (40)"></a>

Welcome to the Rust Developers Community, founded by Francesco Ciulla, a passionate Rust Developer who loves making videos about this cool language.

Join us to learn Rust, share knowledge, and connect with fellow Rustaceans 🦀

Rust Developers

Testing is an integral part of software development, and Rust simplifies this process with built-in functionalities. The post explores basic testing in Rust, showcasing sample test functions using #[test] and macros like assert! and assert_eq!. It also covers scenarios of failing tests, adding custom failure messages, and testing for panics using #[should_panic]. Error handling in tests through Result<(), E> is also demonstrated.

Testing in Rust