Unit Testing Boundary Conditions and Edge Cases

Overview

This skill provides systematic patterns for testing boundary conditions, edge cases, and limit values using JUnit 5. It covers numeric boundaries (Integer.MIN_VALUE, MAX_VALUE), string edge cases (null, empty, whitespace), collection boundaries, floating-point precision, date/time limits, and concurrent access patterns.

When to Use

Use this skill when:

• Testing minimum and maximum values

• Testing null and empty inputs

• Testing whitespace-only strings

• Testing overflow/underflow scenarios

• Testing collections with zero/one/many items

• Verifying behavior at API boundaries

• Want comprehensive edge case coverage

Instructions

• Identify boundaries: List all numeric limits (MIN_VALUE, MAX_VALUE, zero), string states (null, empty, whitespace), and collection sizes (empty, single, many)

• Use parameterized tests: Apply @ParameterizedTest with @ValueSource for testing multiple boundary values efficiently

• Test both sides of boundaries: Test values just below, at, and just above each boundary

• Verify floating point precision: Use isCloseTo(expected, within(tolerance)) for floating point comparisons

• Test collection states: Explicitly test empty (0), single (1), and many (>1) element scenarios

• Handle overflow scenarios: Use Math.addExact() and Math.subtractExact() to detect overflow/underflow

• Test date/time edges: Verify leap years, month boundaries, and timezone transitions

• Document boundary rationale: Explain why specific boundaries matter for your domain

Examples

Setup: Boundary Testing

Maven

<dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-params</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.assertj</groupId> <artifactId>assertj-core</artifactId> <scope>test</scope> </dependency>

Gradle

dependencies { testImplementation("org.junit.jupiter:junit-jupiter") testImplementation("org.junit.jupiter:junit-jupiter-params") testImplementation("org.assertj:assertj-core") }

Numeric Boundary Testing

Integer Limits

import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; import static org.assertj.core.api.Assertions.*;

class IntegerBoundaryTest {

@ParameterizedTest @ValueSource(ints = {Integer.MIN_VALUE, Integer.MIN_VALUE + 1, 0, Integer.MAX_VALUE - 1, Integer.MAX_VALUE}) void shouldHandleIntegerBoundaries(int value) { assertThat(value).isNotNull(); }

@Test void shouldHandleIntegerOverflow() { int maxInt = Integer.MAX_VALUE; int result = Math.addExact(maxInt, 1); // Will throw ArithmeticException

assertThatThrownBy(() -> Math.addExact(Integer.MAX_VALUE, 1))
  .isInstanceOf(ArithmeticException.class);

}

@Test void shouldHandleIntegerUnderflow() { assertThatThrownBy(() -> Math.subtractExact(Integer.MIN_VALUE, 1)) .isInstanceOf(ArithmeticException.class); }

@Test void shouldHandleZero() { int result = MathUtils.divide(0, 5); assertThat(result).isZero();

assertThatThrownBy(() -> MathUtils.divide(5, 0))
  .isInstanceOf(ArithmeticException.class);

} }

String Boundary Testing

Null, Empty, and Whitespace

import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource;

class StringBoundaryTest {

@ParameterizedTest @ValueSource(strings = {"", " ", " ", "\t", "\n"}) void shouldConsiderEmptyAndWhitespaceAsInvalid(String input) { boolean result = StringUtils.isNotBlank(input); assertThat(result).isFalse(); }

@Test void shouldHandleNullString() { String result = StringUtils.trim(null); assertThat(result).isNull(); }

@Test void shouldHandleSingleCharacter() { String result = StringUtils.capitalize("a"); assertThat(result).isEqualTo("A");

String result2 = StringUtils.trim("x");
assertThat(result2).isEqualTo("x");

}

@Test void shouldHandleVeryLongString() { String longString = "x".repeat(1000000);

assertThat(longString.length()).isEqualTo(1000000);
assertThat(StringUtils.isNotBlank(longString)).isTrue();

}

@Test void shouldHandleSpecialCharacters() { String special = "!@#$%^&*()_+-={}[]|\:;<>?,./";

assertThat(StringUtils.length(special)).isEqualTo(31);

} }

Collection Boundary Testing

Empty, Single, and Large Collections

import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource;

class CollectionBoundaryTest {

@Test void shouldHandleEmptyList() { List<String> empty = List.of();

assertThat(empty).isEmpty();
assertThat(CollectionUtils.first(empty)).isNull();
assertThat(CollectionUtils.count(empty)).isZero();

}

@Test void shouldHandleSingleElementList() { List<String> single = List.of("only");

assertThat(single).hasSize(1);
assertThat(CollectionUtils.first(single)).isEqualTo("only");
assertThat(CollectionUtils.last(single)).isEqualTo("only");

}

@Test void shouldHandleLargeList() { List<Integer> large = new ArrayList<>(); for (int i = 0; i < 100000; i++) { large.add(i); }

assertThat(large).hasSize(100000);
assertThat(CollectionUtils.first(large)).isZero();
assertThat(CollectionUtils.last(large)).isEqualTo(99999);

}

@Test void shouldHandleNullInCollection() { List<String> withNull = new ArrayList<>(List.of("a", null, "c"));

assertThat(withNull).contains(null);
assertThat(CollectionUtils.filterNonNull(withNull)).hasSize(2);

}

@Test void shouldHandleDuplicatesInCollection() { List<Integer> duplicates = List.of(1, 1, 2, 2, 3, 3);

assertThat(duplicates).hasSize(6);
Set<Integer> unique = new HashSet<>(duplicates);
assertThat(unique).hasSize(3);

} }

Floating Point Boundary Testing

Precision and Special Values

class FloatingPointBoundaryTest {

@Test void shouldHandleFloatingPointPrecision() { double result = 0.1 + 0.2;

// Floating point comparison needs tolerance
assertThat(result).isCloseTo(0.3, within(0.0001));

}

@Test void shouldHandleSpecialFloatingPointValues() { assertThat(Double.POSITIVE_INFINITY).isGreaterThan(Double.MAX_VALUE); assertThat(Double.NEGATIVE_INFINITY).isLessThan(Double.MIN_VALUE); assertThat(Double.NaN).isNotEqualTo(Double.NaN); // NaN != NaN }

@Test void shouldHandleVerySmallAndLargeNumbers() { double tiny = Double.MIN_VALUE; double huge = Double.MAX_VALUE;

assertThat(tiny).isGreaterThan(0);
assertThat(huge).isPositive();

}

@Test void shouldHandleZeroInDivision() { double result = 1.0 / 0.0;

assertThat(result).isEqualTo(Double.POSITIVE_INFINITY);

double result2 = -1.0 / 0.0;
assertThat(result2).isEqualTo(Double.NEGATIVE_INFINITY);

double result3 = 0.0 / 0.0;
assertThat(result3).isNaN();

} }

Date/Time Boundary Testing

Min/Max Dates and Edge Cases

class DateTimeBoundaryTest {

@Test void shouldHandleMinAndMaxDates() { LocalDate min = LocalDate.MIN; LocalDate max = LocalDate.MAX;

assertThat(min).isBefore(max);
assertThat(DateUtils.isValid(min)).isTrue();
assertThat(DateUtils.isValid(max)).isTrue();

}

@Test void shouldHandleLeapYearBoundary() { LocalDate leapYearEnd = LocalDate.of(2024, 2, 29);

assertThat(leapYearEnd).isNotNull();
assertThat(LocalDate.of(2024, 2, 29)).isEqualTo(leapYearEnd);

}

@Test void shouldHandleInvalidDateInNonLeapYear() { assertThatThrownBy(() -> LocalDate.of(2023, 2, 29)) .isInstanceOf(DateTimeException.class); }

@Test void shouldHandleYearBoundaries() { LocalDate newYear = LocalDate.of(2024, 1, 1); LocalDate lastDay = LocalDate.of(2024, 12, 31);

assertThat(newYear).isBefore(lastDay);

}

@Test void shouldHandleMidnightBoundary() { LocalTime midnight = LocalTime.MIDNIGHT; LocalTime almostMidnight = LocalTime.of(23, 59, 59);

assertThat(almostMidnight).isBefore(midnight);

} }

Array Index Boundary Testing

First, Last, and Out of Bounds

class ArrayBoundaryTest {

@Test void shouldHandleFirstElementAccess() { int[] array = {1, 2, 3, 4, 5};

assertThat(array[0]).isEqualTo(1);

}

@Test void shouldHandleLastElementAccess() { int[] array = {1, 2, 3, 4, 5};

assertThat(array[array.length - 1]).isEqualTo(5);

}

@Test void shouldThrowOnNegativeIndex() { int[] array = {1, 2, 3};

assertThatThrownBy(() -> {
  int value = array[-1];
}).isInstanceOf(ArrayIndexOutOfBoundsException.class);

}

@Test void shouldThrowOnOutOfBoundsIndex() { int[] array = {1, 2, 3};

assertThatThrownBy(() -> {
  int value = array[10];
}).isInstanceOf(ArrayIndexOutOfBoundsException.class);

}

@Test void shouldHandleEmptyArray() { int[] empty = {};

assertThat(empty.length).isZero();
assertThatThrownBy(() -> {
  int value = empty[0];
}).isInstanceOf(ArrayIndexOutOfBoundsException.class);

} }

Concurrent and Thread Boundary Testing

Null and Race Conditions

import java.util.concurrent.*;

class ConcurrentBoundaryTest {

@Test void shouldHandleNullInConcurrentMap() { ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

map.put("key", "value");
assertThat(map.get("nonexistent")).isNull();

}

@Test void shouldHandleConcurrentModification() { List<Integer> list = new CopyOnWriteArrayList<>(List.of(1, 2, 3, 4, 5));

// Should not throw ConcurrentModificationException
for (int num : list) {
  if (num == 3) {
    list.add(6);
  }
}

assertThat(list).hasSize(6);

}

@Test void shouldHandleEmptyBlockingQueue() throws InterruptedException { BlockingQueue<String> queue = new LinkedBlockingQueue<>();

assertThat(queue.poll()).isNull();

} }

Parameterized Boundary Testing

Multiple Boundary Cases

import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource;

class ParameterizedBoundaryTest {

@ParameterizedTest @CsvSource({ "null, false", // null "'', false", // empty "' ', false", // whitespace "a, true", // single char "abc, true" // normal }) void shouldValidateStringBoundaries(String input, boolean expected) { boolean result = StringValidator.isValid(input); assertThat(result).isEqualTo(expected); }

@ParameterizedTest @ValueSource(ints = {Integer.MIN_VALUE, 0, 1, -1, Integer.MAX_VALUE}) void shouldHandleNumericBoundaries(int value) { assertThat(value).isNotNull(); } }

Best Practices

• Test explicitly at boundaries - don't rely on random testing

• Test null and empty separately from valid inputs

• Use parameterized tests for multiple boundary cases

• Test both sides of boundaries (just below, at, just above)

• Verify error messages are helpful for invalid boundaries

• Document why specific boundaries matter

• Test overflow/underflow for numeric operations

Constraints and Warnings

• Integer overflow: Be aware that integer operations can overflow silently; use Math.addExact() to detect

• Floating point precision: Never use exact equality for floating point; always use tolerance-based assertions

• NaN behavior: Remember that NaN != NaN; use Float.isNaN() or Double.isNaN() for detection

• Collection size limits: Be mindful of memory when testing with very large collections

• String encoding: Test with various Unicode characters and encodings for internationalization

• Date/time boundaries: Be aware of timezone transitions and daylight saving time changes

• Array indexing: Always test index boundaries including 0, length-1, and out-of-bounds scenarios

Common Pitfalls

• Testing only "happy path" without boundary cases

• Forgetting null/empty cases

• Not testing floating point precision

• Not testing collection boundaries (empty, single, many)

• Not testing string boundaries (null, empty, whitespace)

Troubleshooting

Floating point comparison fails: Use isCloseTo(expected, within(tolerance)) .

Collection boundaries unclear: List cases explicitly: empty (0), single (1), many (>1).

Date boundary confusing: Use LocalDate.MIN , LocalDate.MAX for clear boundaries.

References

• Integer.MIN_VALUE/MAX_VALUE

• Double.MIN_VALUE/MAX_VALUE

• AssertJ Floating Point Assertions

• Boundary Value Analysis