testRotate(new double[] {1, 2}, -3, new double[] {2, 1});
    testRotate(new double[] {1, 2}, -1, new double[] {2, 1});
    testRotate(new double[] {1, 2}, -2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 0, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 1, new double[] {2, 1});
    testRotate(new double[] {1, 2}, 2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 3, new double[] {2, 1});

  private final TearDownStack tearDownStack = new TearDownStack();
  private TestThread<Monitor> thread1;
  private TestThread<Monitor> thread2;

  protected MonitorTestCase(boolean interruptible) {
    this.interruptible = interruptible;
  }

  @Override
  protected final void setUp() throws Exception {
    boolean fair = new Random().nextBoolean();
    monitor = new Monitor(fair);

        if (queueSize < 1 || batchMaxSize < 1) {
            throw new IllegalArgumentException("Queue and batch sizes must be greater than 1");
        }
        this.batchMaxSize = batchMaxSize;
        this.blockOnLastEvent = blockOnLastEvent;

        this.eventQueue = new ArrayBlockingQueue<>(queueSize);
        Thread updater = new Thread(this::feedConsumer);
        updater.setDaemon(true);
        updater.start();

    private final Completion completed;

    static TimedThread createWithDelay(long countdownInMillis) {
      return new TimedThread(countdownInMillis);
    }

    private TimedThread(long expectedCompletionWaitMillis) {
      completed = new Completion(expectedCompletionWaitMillis);
      thread = new Thread(new JoinTarget(expectedCompletionWaitMillis));
      thread.start();
    }

    void joinSuccessfully() {

public class ActivityHelperTest extends UnitFessTestCase {

    private ActivityHelper activityHelper;

    private ThreadLocal<String> localLogMsg = new ThreadLocal<>();

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        activityHelper = new ActivityHelper() {
            @Override
            protected void printByLtsv(final Map<String, String> valueMap) {

    testRotate(new long[] {1, 2}, -1, new long[] {2, 1});
    testRotate(new long[] {1, 2}, -2, new long[] {1, 2});
    testRotate(new long[] {1, 2}, 0, new long[] {1, 2});
    testRotate(new long[] {1, 2}, 1, new long[] {2, 1});
    testRotate(new long[] {1, 2}, 2, new long[] {1, 2});
    testRotate(new long[] {1, 2}, 3, new long[] {2, 1});

    testRotate(new long[] {1, 2, 3}, -5, new long[] {3, 1, 2});

    testRotate(new short[] {1, 2}, -3, new short[] {2, 1});
    testRotate(new short[] {1, 2}, -1, new short[] {2, 1});
    testRotate(new short[] {1, 2}, -2, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 0, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 1, new short[] {2, 1});
    testRotate(new short[] {1, 2}, 2, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 3, new short[] {2, 1});

        DynamicProperties systemProps = new DynamicProperties(file);
        ComponentUtil.register(systemProps, "systemProperties");

        relatedContentHelper = new RelatedContentHelper() {
            @Override
            public List<RelatedContent> getAvailableRelatedContentList() {
                return mockBhv.getTestData();
            }
        };

        mockBhv = new MockRelatedContentBhv();

                return (T) new DefaultArtifactResolver();
            } else if (clazz == ArtifactManager.class) {
                return (T) new DefaultArtifactManager(this);
            } else if (clazz == RepositoryFactory.class) {
                return (T) new DefaultRepositoryFactory(new DefaultRemoteRepositoryManager(
                        new DefaultUpdatePolicyAnalyzer(),
                        new DefaultChecksumPolicyProvider(),

    Type t1 = new TypeCapture<T1>() {}.capture();
    Type t2 = new TypeCapture<T2>() {}.capture();
    assertEquals(t2, new TypeResolver().where(t1, t2).resolveType(t1));
  }

  public <T> void testWhere_genericArrayMapping() {
    Type t = new TypeCapture<T>() {}.capture();
    assertEquals(
        String.class,
        new TypeResolver()
            .where(new TypeCapture<T[]>() {}.capture(), String[].class)