core/src/test/java/org/apache/accumulo/core/util/OpTimerTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.accumulo.core.util;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.util.concurrent.TimeUnit;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Exercise basic timer (org.apache.hadoop.util.StopWatch) functionality. Current usage requires
 * ability to reset timer.
 */
public class OpTimerTest {

  private static Logger log = LoggerFactory.getLogger(OpTimerTest.class);

  /**
   * Validate reset functionality
   */
  @Test
  public void verifyReset() {

    OpTimer timer = new OpTimer().start();

    try {
      Thread.sleep(50);
    } catch (InterruptedException ex) {
      log.info("sleep sleep interrupted");
      Thread.currentThread().interrupt();
    }

    timer.stop();

    long tValue = timer.now();

    log.debug("Time value before reset {}",
        String.format("%.3f ms", timer.scale(TimeUnit.MILLISECONDS)));

    timer.reset().start();

    try {
      Thread.sleep(1);
    } catch (InterruptedException ex) {
      log.info("sleep sleep interrupted");
      Thread.currentThread().interrupt();
    }

    timer.stop();

    assertTrue(timer.now() > 0);

    assertTrue(tValue > timer.now());

    timer.reset();

    log.debug("Time value after reset {}",
        String.format("%.3f ms", timer.scale(TimeUnit.MILLISECONDS)));

    assertEquals(0, timer.now());

  }

  /**
   * Verify that IllegalStateException is thrown when calling stop when timer has not been started.
   */
  @Test(expected = IllegalStateException.class)
  public void verifyExceptionCallingStopWhenNotStarted() {

    OpTimer timer = new OpTimer();

    assertFalse(timer.isRunning());

    // should throw exception - not running
    timer.stop();
  }

  /**
   * Verify that IllegalStateException is thrown when calling start on running timer.
   */
  @Test(expected = IllegalStateException.class)
  public void verifyExceptionCallingStartWhenRunning() {

    OpTimer timer = new OpTimer().start();

    try {
      Thread.sleep(50);
    } catch (InterruptedException ex) {
      log.info("sleep sleep interrupted");
      Thread.currentThread().interrupt();
    }

    assertTrue(timer.isRunning());

    // should throw exception - already running
    timer.start();
  }

  /**
   * Verify that IllegalStateException is thrown when calling stop when not running.
   */
  @Test(expected = IllegalStateException.class)
  public void verifyExceptionCallingStopWhenNotRunning() {

    OpTimer timer = new OpTimer().start();

    try {
      Thread.sleep(50);
    } catch (InterruptedException ex) {
      log.info("sleep sleep interrupted");
      Thread.currentThread().interrupt();
    }

    assertTrue(timer.isRunning());

    timer.stop();

    assertFalse(timer.isRunning());

    // should throw exception
    timer.stop();
  }

  /**
   * Validate that start / stop accumulates time.
   */
  @Test
  public void verifyElapsed() {

    OpTimer timer = new OpTimer().start();

    try {
      Thread.sleep(50);
    } catch (InterruptedException ex) {
      log.info("sleep sleep interrupted");
      Thread.currentThread().interrupt();
    }

    timer.stop();

    long tValue = timer.now();

    log.debug("Time value after first stop {}",
        String.format("%.3f ms", timer.scale(TimeUnit.MILLISECONDS)));

    timer.start();

    try {
      Thread.sleep(10);
    } catch (InterruptedException ex) {
      log.info("sleep sleep interrupted");
      Thread.currentThread().interrupt();
    }

    timer.stop();

    log.debug("Time value after second stop {}",
        String.format("%.3f ms", timer.scale(TimeUnit.MILLISECONDS)));

    assertTrue(tValue < timer.now());

  }

  /**
   * Validate that scale returns correct values.
   */
  @Test
  public void scale() {
    OpTimer timer = new OpTimer().start();

    try {
      Thread.sleep(50);
    } catch (InterruptedException ex) {
      log.info("sleep sleep interrupted");
      Thread.currentThread().interrupt();
    }

    timer.stop();

    long tValue = timer.now();

    assertEquals(tValue / 1000000.0, timer.scale(TimeUnit.MILLISECONDS), 0.00000001);

    assertEquals(tValue / 1000000000.0, timer.scale(TimeUnit.SECONDS), 0.00000001);

  }
}