Unit testing is a critical aspect of software development that ensures individual components of a program work as intended. In R, svUnit provides a robust framework for unit testing, helping developers validate their code systematically.

Overview of svUnit

svUnit is a unit testing framework for R Programming Language designed to provide a structured approach to testing R code. It helps keep a check if the software is doing the calculations correctly or not. The framework is inspired by the xUnit architecture, common in other programming languages.

Key Features of svUnit

Several features of svUnit make it easy to use, some of them are:

• Integration with R Packages: svUnit integrates seamlessly with R packages, enabling package developers to include unit tests within their package structure.
• Test Suites and Test Cases: The framework supports the creation of test suites and test cases, allowing for organized and comprehensive testing.
• Detailed Reports: svUnit generates detailed reports on test results, highlighting passed and failed tests, which helps in debugging and improving code quality.
• Support for Different Environments: The framework can be used in various environments, including R console, RStudio, and batch scripts.

Installation of svUnit

It is installed as a package in R. The syntax is quite simple to apply install.packages(“package_name”)

# Install package 
install.packages("svUnit")

# Load package
library(svUnit)

To use svUnit, you create test suites and define test cases within these suites. A test suite is a collection of test cases that are logically grouped together.

1. Defining Test Cases

Test cases are functions that contain assertions to verify the correctness of the code.

# Function to be tested
Cube <- function(x) return(x^3)

# Define tests for Cube function
test(Cube) <- function() {
  checkEqualsNumeric(27, Cube(3))           # Should pass
  checkEqualsNumeric(64, Cube(4))           # Should pass
  checkEqualsNumeric(0, Cube(0))            # Should pass
  checkEqualsNumeric(1, Cube(1))            # Should pass
  checkEqualsNumeric(-27, Cube(-3))         # Should pass
  checkException(Cube("xx"))                # Should pass
}

2. Running Tests

Execute the defined tests using runTest to evaluate the function Cube against the specified test cases:

# Clear previous log
clearLog()

# Run tests
(runTest(test(Cube)))

Output:

== test(Cube) run in less than 0.1 sec: OK

//Pass: 6 Fail: 0 Errors: 0//

Writing Tests using svUnit

Now we will write the test cases that should be checked using this library. Define your functions and associate test cases with them using the test keyword. This example will write the functions that calculate the sum of a list and check if a number is even.

library(svUnit)

# Function to be tested: Sum of elements in a list
SumList <- function(x) {
  return(sum(x))
}

# Define tests for SumList function
test(SumList) <- function() {
  checkEqualsNumeric(6, SumList(c(1, 2, 3)))          # Should pass
  checkEqualsNumeric(0, SumList(c(-1, 1, 0)))         # Should pass
  checkEqualsNumeric(10, SumList(c(5, 5)))            # Should pass
  checkEqualsNumeric(11, SumList(c(1, 2, 3)))         # Should fail
}

# Function to be tested: Check if a number is even
IsEven <- function(n) {
  return(n %% 2 == 0)
}

# Define tests for IsEven function
test(IsEven) <- function() {
  checkTrue(IsEven(2))                                # Should pass
  checkTrue(IsEven(4))                                # Should pass
  checkTrue(!IsEven(5))                               # Should pass
  checkTrue(IsEven(3))                                # Should fail
  checkException(IsEven("a"))                         # Should pass
}

# Add a separate test case for vector operations
test_VectorOperations <- svTest(function() {
  checkTrue(length(1:5) == 5)                         # Should pass
  expected <- c(2, 4, 6)
  actual <- 2 * 1:3
  checkEquals(expected, actual)                       # Should pass
})

Run the defined tests using runTest to check if the functions behave as expected:

# Clear previous log
clearLog()

# Run tests for SumList function and print results
print(runTest(test(SumList)))

# Run tests for IsEven function and print results
print(runTest(test(IsEven)))

# Run the separate vector operations test and print results
print(runTest(test_VectorOperations))

Output:

== test(SumList) run in less than 0.1 sec: **FAILS**

//Pass: 3 Fail: 1 Errors: 0//

* : checkEqualsNumeric(11, SumList(c(1, 2, 3))) run in less than 0.001 sec ... **FAILS**
Mean relative difference: 0.4545455
 num 6

== test(IsEven) run in less than 0.1 sec: **FAILS**

//Pass: 4 Fail: 1 Errors: 0//

* : checkTrue(IsEven(3)) run in less than 0.001 sec ... **FAILS**
 logi FALSE

== test_VectorOperations run in less than 0.1 sec: OK

//Pass: 2 Fail: 0 Errors: 0//

These results indicate that while most of the tests passed, there are specific issues with the SumList and IsEven functions that need to be addressed. The SumList function did not sum the list correctly, and the IsEven function did not correctly identify whether a number is even or odd. These failures suggest potential bugs or issues in the implementation of these functions that require further investigation and correction.

Conclusion

In this article, we discussed how to install svUnit framework and how to use it to test case and define function. This process will help us increase efficiency and avoid errors in our work.

svUnit – A framework for unit testing in R-FAQs

Is there alternatives to svUnit for unit testing in R?

Yes, there are other frameworks that can be used like testthat or RUnit.

How do I install svUnit?

You can install svUnit from CRAN using the following command: install.packages(“svUnit”)

Can I group multiple tests together?

Yes, we can group tests.