Code review comment: ```suggestion                                 "There should be always data available because the test utilizes no rate-limiting strategy and splits are provided.") ```

Code under review:
void testReaderCheckpoints() throws Exception {
        final int numCycles = 3;
        final long from = 0;
        final long mid = 156;
        final long to = 383;
        final long elementsPerCycle = (to - from + 1) / numCycles;

        final TestingReaderOutput<Long> out = new TestingReaderOutput<>();

        SourceReader<Long, NumberSequenceSource.NumberSequenceSplit> reader = createReader();
        reader.addSplits(
                Arrays.asList(
                        new NumberSequenceSource.NumberSequenceSplit("split-1", from, mid),
                        new NumberSequenceSource.NumberSequenceSplit("split-2", mid + 1, to)));

        for (int cycle = 0; cycle < numCycles; cycle++) {
            
            assertThat(reader.pollNext(out))
                    .as(
                            "Each poll should return a NOTHING_AVAILABLE status to explicitly trigger the availability check through in SourceReader.isAvailable")
                    .isSameAs(InputStatus.NOTHING_AVAILABLE);
            for (int elementInCycle = 0; elementInCycle < elementsPerCycle; elementInCycle++) {
                assertThat(reader.isAvailable())
                        .as(
                                "There should be always data available because the test doesn't rely on any no rate-limiting strategy and splits are provided.")
                        .isCompleted();
                
                
                assertThat(reader.pollNext(out))
                        .as(
                                "Each poll should return a NOTHING_AVAILABLE status to explicitly trigger the availability check through in SourceReader.isAvailable")
                        .isSameAs(InputStatus.NOTHING_AVAILABLE);
            }
            
            List<NumberSequenceSource.NumberSequenceSplit> splits = reader.snapshotState(1L);
            
            
            
            assertThat(splits).hasSize(numCycles - cycle - 1);

            
            reader = createReader();
            if (splits.isEmpty()) {
                reader.notifyNoMoreSplits();
            } else {
                reader.addSplits(splits);
            }
        }

        
        
        assertThat(reader.isAvailable())
                .as(
                        "There should be always data available because the test doesn't rely on any no rate-limiting strategy and splits are provided.")
                .isCompleted();
        assertThat(reader.pollNext(out)).isSameAs(InputStatus.END_OF_INPUT);

        final List<Long> result = out.getEmittedRecords();
        final Iterable<Long> expected = LongStream.range(from, to + 1)::iterator;

        assertThat(result).containsExactlyElementsOf(expected);
    }

Line commented on: "There should be always data available because the test doesn't rely on any no rate-limiting strategy and splits are provided.")

Revised code:
void testReaderCheckpoints() throws Exception {
        final int numCycles = 3;
        final long from = 0;
        final long mid = 156;
        final long to = 383;
        final long elementsPerCycle = (to - from + 1) / numCycles;

        final TestingReaderOutput<Long> out = new TestingReaderOutput<>();

        SourceReader<Long, NumberSequenceSource.NumberSequenceSplit> reader = createReader();
        reader.addSplits(
                Arrays.asList(
                        new NumberSequenceSource.NumberSequenceSplit("split-1", from, mid),
                        new NumberSequenceSource.NumberSequenceSplit("split-2", mid + 1, to)));

        for (int cycle = 0; cycle < numCycles; cycle++) {
            
            assertThat(reader.pollNext(out))
                    .as(
                            "Each poll should return a NOTHING_AVAILABLE status to explicitly trigger the availability check through in SourceReader.isAvailable")
                    .isSameAs(InputStatus.NOTHING_AVAILABLE);
            for (int elementInCycle = 0; elementInCycle < elementsPerCycle; elementInCycle++) {
                assertThat(reader.isAvailable())
                        .as(
                                "There should be always data available because the test utilizes no rate-limiting strategy and splits are provided.")
                        .isCompleted();
                
                
                assertThat(reader.pollNext(out))
                        .as(
                                "Each poll should return a NOTHING_AVAILABLE status to explicitly trigger the availability check through in SourceReader.isAvailable")
                        .isSameAs(InputStatus.NOTHING_AVAILABLE);
            }
            
            List<NumberSequenceSource.NumberSequenceSplit> splits = reader.snapshotState(1L);
            
            
            
            assertThat(splits).hasSize(numCycles - cycle - 1);

            
            reader = createReader();
            if (splits.isEmpty()) {
                reader.notifyNoMoreSplits();
            } else {
                reader.addSplits(splits);
            }
        }

        
        
        assertThat(reader.isAvailable())
                .as(
                        "There should be always data available because the test utilizes no rate-limiting strategy and splits are provided.")
                .isCompleted();
        assertThat(reader.pollNext(out)).isSameAs(InputStatus.END_OF_INPUT);

        final List<Long> result = out.getEmittedRecords();
        final Iterable<Long> expected = LongStream.range(from, to + 1)::iterator;

        assertThat(result).containsExactlyElementsOf(expected);
    }