// Path: src/main/java/com/lmax/disruptor/SequenceBarrier.java
// public interface SequenceBarrier
// {
//     /**
//      * Wait for the given sequence to be available for consumption.
//      *
//      * @param sequence to wait for
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence) throws AlertException, InterruptedException;
// 
//     /**
//      * Wait for the given sequence to be available for consumption with a time out.
//      *
//      * @param sequence to wait for
//      * @param timeout value
//      * @param units for the timeout value
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence, long timeout, TimeUnit units) throws AlertException, InterruptedException;
// 
//     /**
//      * Delegate a call to the {@link Sequencer#getCursor()}
//      *
//      * @return value of the cursor for entries that have been published.
//      */
//     long getCursor();
// 
//     /**
//      * The current alert status for the barrier.
//      *
//      * @return true if in alert otherwise false.
//      */
//     boolean isAlerted();
// 
//     /**
//      * Alert the {@link EventProcessor}s of a status change and stay in this status until cleared.
//      */
//     void alert();
// 
//     /**
//      * Clear the current alert status.
//      */
//     void clearAlert();
// 
//     /**
//      * Check if an alert has been raised and throw an {@link AlertException} if it has.
//      *
//      * @throws AlertException if alert has been raised.
//      */
//     void checkAlert() throws AlertException;
// }
// 
// Path: src/main/java/com/lmax/disruptor/RingBuffer.java
// public final class RingBuffer<T> extends Sequencer
// {
//     private final int indexMask;
//     private final Object[] entries;
// 
//     /**
//      * Construct a RingBuffer with the full option set.
//      *
//      * @param eventFactory to newInstance entries for filling the RingBuffer
//      * @param claimStrategy threading strategy for publisher claiming entries in the ring.
//      * @param waitStrategy waiting strategy employed by processorsToTrack waiting on entries becoming available.
//      *
//      * @throws IllegalArgumentException if bufferSize is not a power of 2
//      */
//     public RingBuffer(final EventFactory<T> eventFactory,
//                       final ClaimStrategy claimStrategy,
//                       final WaitStrategy waitStrategy)
//     {
//         super(claimStrategy, waitStrategy);
// 
//         if (Integer.bitCount(claimStrategy.getBufferSize()) != 1)
//         {
//             throw new IllegalArgumentException("bufferSize must be a power of 2");
//         }
// 
//         indexMask = claimStrategy.getBufferSize() - 1;
//         entries = new Object[claimStrategy.getBufferSize()];
// 
//         fill(eventFactory);
//     }
// 
//     /**
//      * Construct a RingBuffer with default strategies of:
//      * {@link MultiThreadedClaimStrategy} and {@link BlockingWaitStrategy}
//      *
//      * @param eventFactory to newInstance entries for filling the RingBuffer
//      * @param bufferSize of the RingBuffer that will be rounded up to the next power of 2
//      */
//     public RingBuffer(final EventFactory<T> eventFactory, final int bufferSize)
//     {
//         this(eventFactory,
//              new MultiThreadedClaimStrategy(bufferSize),
//              new BlockingWaitStrategy());
//     }
// 
//     /**
//      * Get the event for a given sequence in the RingBuffer.
//      *
//      * @param sequence for the event
//      * @return event for the sequence
//      */
//     @SuppressWarnings("unchecked")
//     public T get(final long sequence)
//     {
//         return (T)entries[(int)sequence & indexMask];
//     }
// 
//     private void fill(final EventFactory<T> eventFactory)
//     {
//         for (int i = 0; i < entries.length; i++)
//         {
//             entries[i] = eventFactory.newInstance();
//         }
//     }
// }


import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.RingBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;
/*
 * Copyright 2011 LMAX Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.lmax.disruptor.support;



public final class TestWaiter implements Callable<List<StubEvent>>
{
    private final long toWaitForSequence;
    private final long initialSequence;
    private final CyclicBarrier cyclicBarrier;
// Path: src/main/java/com/lmax/disruptor/SequenceBarrier.java
// public interface SequenceBarrier
// {
//     /**
//      * Wait for the given sequence to be available for consumption.
//      *
//      * @param sequence to wait for
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence) throws AlertException, InterruptedException;
// 
//     /**
//      * Wait for the given sequence to be available for consumption with a time out.
//      *
//      * @param sequence to wait for
//      * @param timeout value
//      * @param units for the timeout value
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence, long timeout, TimeUnit units) throws AlertException, InterruptedException;
// 
//     /**
//      * Delegate a call to the {@link Sequencer#getCursor()}
//      *
//      * @return value of the cursor for entries that have been published.
//      */
//     long getCursor();
// 
//     /**
//      * The current alert status for the barrier.
//      *
//      * @return true if in alert otherwise false.
//      */
//     boolean isAlerted();
// 
//     /**
//      * Alert the {@link EventProcessor}s of a status change and stay in this status until cleared.
//      */
//     void alert();
// 
//     /**
//      * Clear the current alert status.
//      */
//     void clearAlert();
// 
//     /**
//      * Check if an alert has been raised and throw an {@link AlertException} if it has.
//      *
//      * @throws AlertException if alert has been raised.
//      */
//     void checkAlert() throws AlertException;
// }
// 
// Path: src/main/java/com/lmax/disruptor/RingBuffer.java
// public final class RingBuffer<T> extends Sequencer
// {
//     private final int indexMask;
//     private final Object[] entries;
// 
//     /**
//      * Construct a RingBuffer with the full option set.
//      *
//      * @param eventFactory to newInstance entries for filling the RingBuffer
//      * @param claimStrategy threading strategy for publisher claiming entries in the ring.
//      * @param waitStrategy waiting strategy employed by processorsToTrack waiting on entries becoming available.
//      *
//      * @throws IllegalArgumentException if bufferSize is not a power of 2
//      */
//     public RingBuffer(final EventFactory<T> eventFactory,
//                       final ClaimStrategy claimStrategy,
//                       final WaitStrategy waitStrategy)
//     {
//         super(claimStrategy, waitStrategy);
// 
//         if (Integer.bitCount(claimStrategy.getBufferSize()) != 1)
//         {
//             throw new IllegalArgumentException("bufferSize must be a power of 2");
//         }
// 
//         indexMask = claimStrategy.getBufferSize() - 1;
//         entries = new Object[claimStrategy.getBufferSize()];
// 
//         fill(eventFactory);
//     }
// 
//     /**
//      * Construct a RingBuffer with default strategies of:
//      * {@link MultiThreadedClaimStrategy} and {@link BlockingWaitStrategy}
//      *
//      * @param eventFactory to newInstance entries for filling the RingBuffer
//      * @param bufferSize of the RingBuffer that will be rounded up to the next power of 2
//      */
//     public RingBuffer(final EventFactory<T> eventFactory, final int bufferSize)
//     {
//         this(eventFactory,
//              new MultiThreadedClaimStrategy(bufferSize),
//              new BlockingWaitStrategy());
//     }
// 
//     /**
//      * Get the event for a given sequence in the RingBuffer.
//      *
//      * @param sequence for the event
//      * @return event for the sequence
//      */
//     @SuppressWarnings("unchecked")
//     public T get(final long sequence)
//     {
//         return (T)entries[(int)sequence & indexMask];
//     }
// 
//     private void fill(final EventFactory<T> eventFactory)
//     {
//         for (int i = 0; i < entries.length; i++)
//         {
//             entries[i] = eventFactory.newInstance();
//         }
//     }
// }


// Path: src/test/java/com/lmax/disruptor/support/TestWaiter.java
import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.RingBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CyclicBarrier;

/*
 * Copyright 2011 LMAX Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.lmax.disruptor.support;



public final class TestWaiter implements Callable<List<StubEvent>>
{
    private final long toWaitForSequence;
    private final long initialSequence;
    private final CyclicBarrier cyclicBarrier;
    private final SequenceBarrier sequenceBarrier;