Back to Repositories

Testing Atomic Sequence Operations in LMAX-Disruptor

This test suite validates the core functionality of the Sequence class in the LMAX Disruptor library. It focuses on atomic operations and sequence value management, which are critical for the concurrent processing capabilities of the Disruptor pattern.

Test Coverage Overview

The test suite provides comprehensive coverage of Sequence class operations including:

Addition operations with addAndGet()
Increment operations with incrementAndGet()
Retrieval operations with getAndAdd()

Each test case validates both the operation result and the final sequence state, ensuring atomic behavior and value consistency.

Implementation Analysis

The testing approach uses JUnit Jupiter to verify atomic operations on the Sequence class. Tests follow the Arrange-Act-Assert pattern with clear isolation of test scenarios. Each method tests a specific atomic operation while maintaining sequence state verification.

The implementation leverages JUnit’s assertion methods for precise value comparison and verification of sequence state changes.

Technical Details

Testing tools and configuration:

JUnit Jupiter test framework
Static assertions for value comparison
Sequence class initialization with zero value
Atomic operation verification
State consistency checks

Best Practices Demonstrated

The test suite exemplifies several testing best practices:

Single responsibility principle in test methods
Clear test method naming conventions
Consistent test structure and organization
Proper initialization and state verification
Explicit assertion messages for clarity

lmax-exchange/disruptor

src/test/java/com/lmax/disruptor/SequenceTest.java

            
package com.lmax.disruptor;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

class SequenceTest
{
    @Test
    void shouldReturnChangedValueAfterAddAndGet()
    {
        final Sequence sequence = new Sequence(0);

        assertEquals(10, sequence.addAndGet(10));
        assertEquals(10, sequence.get());
    }

    @Test
    void shouldReturnIncrementedValueAfterIncrementAndGet()
    {
        final Sequence sequence = new Sequence(0);

        assertEquals(1, sequence.incrementAndGet());
        assertEquals(1, sequence.get());
    }

    @Test
    void shouldReturnPreviousValueAfterGetAndAdd()
    {
        final Sequence sequence = new Sequence(0);

        assertEquals(0, sequence.getAndAdd(1));
        assertEquals(1, sequence.get());
    }
}