(function(global) {

  // Information about the starting/ending times and starting/ending values for
  // each time interval.
  let timeValueInfo;

  // The difference between starting values between each time interval.
  let startingValueDelta;

  // For any automation function that has an end or target value, the end value
  // is based the starting value of the time interval.  The starting value will
  // be increased or decreased by |startEndValueChange|. We choose half of
  // |startingValueDelta| so that the ending value will be distinct from the
  // starting value for next time interval.  This allows us to detect where the
  // ramp begins and ends.
  let startEndValueChange;

  // Default threshold to use for detecting discontinuities that should appear
  // at each time interval.
  let discontinuityThreshold;

  // Time interval between value changes.  It is best if 1 / numberOfTests is
  // not close to timeInterval.
  let timeIntervalInternal = .03;

  let context;

  // Make sure we render long enough to capture all of our test data.
  function renderLength(numberOfTests) {
    return timeToSampleFrame((numberOfTests + 1) * timeInterval, sampleRate);
  }

  // Create a constant reference signal with the given |value|.  Basically the
  // same as |createConstantBuffer|, but with the parameters to match the other
  // create functions.  The |endValue| is ignored.
  function createConstantArray(
      startTime, endTime, value, endValue, sampleRate) {
    let startFrame = timeToSampleFrame(startTime, sampleRate);
    let endFrame = timeToSampleFrame(endTime, sampleRate);
    let length = endFrame - startFrame;

    let buffer = createConstantBuffer(context, length, value);

    return buffer.getChannelData(0);
  }

  function getStartEndFrames(startTime, endTime, sampleRate) {
    // Start frame is the ceiling of the start time because the ramp starts at
    // or after the sample frame.  End frame is the ceiling because it's the
    // exclusive ending frame of the automation.
    let startFrame = Math.ceil(startTime * sampleRate);
    let endFrame = Math.ceil(endTime * sampleRate);

    return {startFrame: startFrame, endFrame: endFrame};
  }

  // Create a linear ramp starting at |startValue| and ending at |endValue|. The
  // ramp starts at time |startTime| and ends at |endTime|.  (The start and end
  // times are only used to compute how many samples to return.)
  function createLinearRampArray(
      startTime, endTime, startValue, endValue, sampleRate) {
    let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
    let startFrame = frameInfo.startFrame;
    let endFrame = frameInfo.endFrame;
    let length = endFrame - startFrame;
    let array = new Array(length);

    let step = Math.fround(
        (endValue - startValue) / (endTime - startTime) / sampleRate);
    let start = Math.fround(
        startValue +
        (endValue - startValue) * (startFrame / sampleRate - startTime) /
            (endTime - startTime));

    let slope = (endValue - startValue) / (endTime - startTime);

    // v(t) = v0 + (v1 - v0)*(t-t0)/(t1-t0)
    for (k = 0; k < length; ++k) {
      // array[k] = Math.fround(start + k * step);
      let t = (startFrame + k) / sampleRate;
      array[k] = startValue + slope * (t - startTime);
    }

    return array;
  }

  // Create an exponential ramp starting at |startValue| and ending at
  // |endValue|. The ramp starts at time |startTime| and ends at |endTime|.
  // (The start and end times are only used to compute how many samples to
  // return.)
  function createExponentialRampArray(
      startTime, endTime, startValue, endValue, sampleRate) {
    let deltaTime = endTime - startTime;

    let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
    let startFrame = frameInfo.startFrame;
    let endFrame = frameInfo.endFrame;
    let length = endFrame - startFrame;
    let array = new Array(length);

    let ratio = endValue / startValue;

    // v(t) = v0*(v1/v0)^((t-t0)/(t1-t0))
    for (let k = 0; k < length; ++k) {
      let t = Math.fround((startFrame + k) / sampleRate);
      array[k] = Math.fround(
          startValue * Math.pow(ratio, (t - startTime) / deltaTime));
    }

    return array;
  }

  function discreteTimeConstantForSampleRate(timeConstant, sampleRate) {
    return 1 - Math.exp(-1 / (sampleRate * timeConstant));
  }

  // Create a signal that starts at |startValue| and exponentially approaches
  // the target value of |targetValue|, using a time constant of |timeConstant|.
  // The ramp starts at time |startTime| and ends at |endTime|.  (The start and
  // end times are only used to compute how many samples to return.)
  function createExponentialApproachArray(
      startTime, endTime, startValue, targetValue, sampleRate, timeConstant) {
    let startFrameFloat = startTime * sampleRate;
    let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
    let startFrame = frameInfo.startFrame;
    let endFrame = frameInfo.endFrame;
    let length = Math.floor(endFrame - startFrame);
    let array = new Array(length);
    let c = discreteTimeConstantForSampleRate(timeConstant, sampleRate);

    let delta = startValue - targetValue;

    // v(t) = v1 + (v0 - v1) * exp(-(t-t0)/tau)
    for (let k = 0; k < length; ++k) {
      let t = (startFrame + k) / sampleRate;
      let value =
          targetValue + delta * Math.exp(-(t - startTime) / timeConstant);
      array[k] = value;
    }

    return array;
  }

  // Create a sine wave of the specified duration.
  function createReferenceSineArray(
      startTime, endTime, startValue, endValue, sampleRate) {
    // Ignore |startValue| and |endValue| for the sine wave.
    let curve = createSineWaveArray(
        endTime - startTime, freqHz, sineAmplitude, sampleRate);
    // Sample the curve appropriately.
    let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
    let startFrame = frameInfo.startFrame;
    let endFrame = frameInfo.endFrame;
    let length = Math.floor(endFrame - startFrame);
    let array = new Array(length);

    // v(t) = linearly interpolate between V[k] and V[k + 1] where k =
    // floor((N-1)/duration*(t - t0))
    let f = (length - 1) / (endTime - startTime);

    for (let k = 0; k < length; ++k) {
      let t = (startFrame + k) / sampleRate;
      let indexFloat = f * (t - startTime);
      let index = Math.floor(indexFloat);
      if (index + 1 < length) {
        let v0 = curve[index];
        let v1 = curve[index + 1];
        array[k] = v0 + (v1 - v0) * (indexFloat - index);
      } else {
        array[k] = curve[length - 1];
      }
    }

    return array;
  }

  // Create a sine wave of the given frequency and amplitude.  The sine wave is
  // offset by half the amplitude so that result is always positive.
  function createSineWaveArray(durationSeconds, freqHz, amplitude, sampleRate) {
    let length = timeToSampleFrame(durationSeconds, sampleRate);
    let signal = new Float32Array(length);
    let omega = 2 * Math.PI * freqHz / sampleRate;
    let halfAmplitude = amplitude / 2;

    for (let k = 0; k < length; ++k) {
      signal[k] = halfAmplitude + halfAmplitude * Math.sin(omega * k);
    }

    return signal;
  }

  // Return the difference between the starting value and the ending value for
  // time interval |timeIntervalIndex|.  We alternate between an end value that
  // is above or below the starting value.
  function endValueDelta(timeIntervalIndex) {
    if (timeIntervalIndex & 1) {
      return -startEndValueChange;
    } else {
      return startEndValueChange;
    }
  }

  // Relative error metric
  function relativeErrorMetric(actual, expected) {
    return (actual - expected) / Math.abs(expected);
  }

  // Difference metric
  function differenceErrorMetric(actual, expected) {
    return actual - expected;
  }

  // Return the difference between the starting value at |timeIntervalIndex| and
  // the starting value at the next time interval.  Since we started at a large
  // initial value, we decrease the value at each time interval.
  function valueUpdate(timeIntervalIndex) {
    return -startingValueDelta;
  }

  // Compare a section of the rendered data against our expected signal.
  function comparePartialSignals(
      should, rendered, expectedFunction, startTime, endTime, valueInfo,
      sampleRate, errorMetric) {
    let startSample = timeToSampleFrame(startTime, sampleRate);
    let expected = expectedFunction(
        startTime, endTime, valueInfo.startValue, valueInfo.endValue,
        sampleRate, timeConstant);

    let n = expected.length;
    let maxError = -1;
    let maxErrorIndex = -1;

    for (let k = 0; k < n; ++k) {
      // Make sure we don't pass these tests because a NaN has been generated in
      // either the
      // rendered data or the reference data.
      if (!isValidNumber(rendered[startSample + k])) {
        maxError = Infinity;
        maxErrorIndex = startSample + k;
        should(
            isValidNumber(rendered[startSample + k]),
            'NaN or infinity for rendered data at ' + maxErrorIndex)
            .beTrue();
        break;
      }
      if (!isValidNumber(expected[k])) {
        maxError = Infinity;
        maxErrorIndex = startSample + k;
        should(
            isValidNumber(expected[k]),
            'NaN or infinity for rendered data at ' + maxErrorIndex)
            .beTrue();
        break;
      }
      let error = Math.abs(errorMetric(rendered[startSample + k], expected[k]));
      if (error > maxError) {
        maxError = error;
        maxErrorIndex = k;
      }
    }

    return {maxError: maxError, index: maxErrorIndex, expected: expected};
  }

  // Find the discontinuities in the data and compare the locations of the
  // discontinuities with the times that define the time intervals. There is a
  // discontinuity if the difference between successive samples exceeds the
  // threshold.
  function verifyDiscontinuities(should, values, times, threshold) {
    let n = values.length;
    let success = true;
    let badLocations = 0;
    let breaks = [];

    // Find discontinuities.
    for (let k = 1; k < n; ++k) {
      if (Math.abs(values[k] - values[k - 1]) > threshold) {
        breaks.push(k);
      }
    }

    let testCount;

    // If there are numberOfTests intervals, there are only numberOfTests - 1
    // internal interval boundaries. Hence the maximum number of discontinuties
    // we expect to find is numberOfTests - 1. If we find more than that, we
    // have no reference to compare against. We also assume that the actual
    // discontinuities are close to the expected ones.
    //
    // This is just a sanity check when something goes really wrong.  For
    // example, if the threshold is too low, every sample frame looks like a
    // discontinuity.
    if (breaks.length >= numberOfTests) {
      testCount = numberOfTests - 1;
      should(breaks.length, 'Number of discontinuities')
          .beLessThan(numberOfTests);
      success = false;
    } else {
      testCount = breaks.length;
    }

    // Compare the location of each discontinuity with the end time of each
    // interval. (There is no discontinuity at the start of the signal.)
    for (let k = 0; k < testCount; ++k) {
      let expectedSampleFrame = timeToSampleFrame(times[k + 1], sampleRate);
      if (breaks[k] != expectedSampleFrame) {
        success = false;
        ++badLocations;
        should(breaks[k], 'Discontinuity at index')
            .beEqualTo(expectedSampleFrame);
      }
    }

    if (badLocations) {
      should(badLocations, 'Number of discontinuites at incorrect locations')
          .beEqualTo(0);
      success = false;
    } else {
      should(
          breaks.length + 1,
          'Number of tests started and ended at the correct time')
          .beEqualTo(numberOfTests);
    }

    return success;
  }

  // Compare the rendered data with the expected data.
  //
  // testName - string describing the test
  //
  // maxError - maximum allowed difference between the rendered data and the
  // expected data
  //
  // rendererdData - array containing the rendered (actual) data
  //
  // expectedFunction - function to compute the expected data
  //
  // timeValueInfo - array containing information about the start and end times
  // and the start and end values of each interval.
  //
  // breakThreshold - threshold to use for determining discontinuities.
  function compareSignals(
      should, testName, maxError, renderedData, expectedFunction, timeValueInfo,
      breakThreshold, errorMetric) {
    let success = true;
    let failedTestCount = 0;
    let times = timeValueInfo.times;
    let values = timeValueInfo.values;
    let n = values.length;
    let expectedSignal = [];

    success =
        verifyDiscontinuities(should, renderedData, times, breakThreshold);

    for (let k = 0; k < n; ++k) {
      let result = comparePartialSignals(
          should, renderedData, expectedFunction, times[k], times[k + 1],
          values[k], sampleRate, errorMetric);

      expectedSignal =
          expectedSignal.concat(Array.prototype.slice.call(result.expected));

      should(
          result.maxError,
          'Max error for test ' + k + ' at offset ' +
              (result.index + timeToSampleFrame(times[k], sampleRate)))
          .beLessThanOrEqualTo(maxError);
    }

    should(
        failedTestCount,
        'Number of failed tests with an acceptable relative tolerance of ' +
            maxError)
        .beEqualTo(0);
  }

  // Create a function to test the rendered data with the reference data.
  //
  // testName - string describing the test
  //
  // error - max allowed error between rendered data and the reference data.
  //
  // referenceFunction - function that generates the reference data to be
  // compared with the rendered data.
  //
  // jumpThreshold - optional parameter that specifies the threshold to use for
  // detecting discontinuities.  If not specified, defaults to
  // discontinuityThreshold.
  //
  function checkResultFunction(
      task, should, testName, error, referenceFunction, jumpThreshold,
      errorMetric) {
    return function(event) {
      let buffer = event.renderedBuffer;
      renderedData = buffer.getChannelData(0);

      let threshold;

      if (!jumpThreshold) {
        threshold = discontinuityThreshold;
      } else {
        threshold = jumpThreshold;
      }

      compareSignals(
          should, testName, error, renderedData, referenceFunction,
          timeValueInfo, threshold, errorMetric);
      task.done();
    }
  }

  // Run all the automation tests.
  //
  // numberOfTests - number of tests (time intervals) to run.
  //
  // initialValue - The initial value of the first time interval.
  //
  // setValueFunction - function that sets the specified value at the start of a
  // time interval.
  //
  // automationFunction - function that sets the end value for the time
  // interval. It specifies how the value approaches the end value.
  //
  // An object is returned containing an array of start times for each time
  // interval, and an array giving the start and end values for the interval.
  function doAutomation(
      numberOfTests, initialValue, setValueFunction, automationFunction) {
    let timeInfo = [0];
    let valueInfo = [];
    let value = initialValue;

    for (let k = 0; k < numberOfTests; ++k) {
      let startTime = k * timeInterval;
      let endTime = (k + 1) * timeInterval;
      let endValue = value + endValueDelta(k);

      // Set the value at the start of the time interval.
      setValueFunction(value, startTime);

      // Specify the end or target value, and how we should approach it.
      automationFunction(endValue, startTime, endTime);

      // Keep track of the start times, and the start and end values for each
      // time interval.
      timeInfo.push(endTime);
      valueInfo.push({startValue: value, endValue: endValue});

      value += valueUpdate(k);
    }

    return {times: timeInfo, values: valueInfo};
  }

  // Create the audio graph for the test and then run the test.
  //
  // numberOfTests - number of time intervals (tests) to run.
  //
  // initialValue - the initial value of the gain at time 0.
  //
  // setValueFunction - function to set the value at the beginning of each time
  // interval.
  //
  // automationFunction - the AudioParamTimeline automation function
  //
  // testName - string indicating the test that is being run.
  //
  // maxError - maximum allowed error between the rendered data and the
  // reference data
  //
  // referenceFunction - function that generates the reference data to be
  // compared against the rendered data.
  //
  // jumpThreshold - optional parameter that specifies the threshold to use for
  // detecting discontinuities.  If not specified, defaults to
  // discontinuityThreshold.
  //
  function createAudioGraphAndTest(
      task, should, numberOfTests, initialValue, setValueFunction,
      automationFunction, testName, maxError, referenceFunction, jumpThreshold,
      errorMetric) {
    // Create offline audio context.
    context =
        new OfflineAudioContext(2, renderLength(numberOfTests), sampleRate);
    let constantBuffer =
        createConstantBuffer(context, renderLength(numberOfTests), 1);

    // We use an AudioGainNode here simply as a convenient way to test the
    // AudioParam automation, since it's easy to pass a constant value through
    // the node, automate the .gain attribute and observe the resulting values.

    gainNode = context.createGain();

    let bufferSource = context.createBufferSource();
    bufferSource.buffer = constantBuffer;
    bufferSource.connect(gainNode);
    gainNode.connect(context.destination);

    // Set up default values for the parameters that control how the automation
    // test values progress for each time interval.
    startingValueDelta = initialValue / numberOfTests;
    startEndValueChange = startingValueDelta / 2;
    discontinuityThreshold = startEndValueChange / 2;

    // Run the automation tests.
    timeValueInfo = doAutomation(
        numberOfTests, initialValue, setValueFunction, automationFunction);
    bufferSource.start(0);

    context.oncomplete = checkResultFunction(
        task, should, testName, maxError, referenceFunction, jumpThreshold,
        errorMetric || relativeErrorMetric);
    context.startRendering();
  }

  // Export local references to global scope. All the new objects in this file
  // must be exported through this if it is to be used in the actual test HTML
  // page.
  let exports = {
    'sampleRate': 44100,
    'gainNode': null,
    'timeInterval': timeIntervalInternal,

    // Some suitable time constant so that we can see a significant change over
    // a timeInterval.  This is only needed by setTargetAtTime() which needs a
    // time constant.
    'timeConstant': timeIntervalInternal / 3,

    'renderLength': renderLength,
    'createConstantArray': createConstantArray,
    'getStartEndFrames': getStartEndFrames,
    'createLinearRampArray': createLinearRampArray,
    'createExponentialRampArray': createExponentialRampArray,
    'discreteTimeConstantForSampleRate': discreteTimeConstantForSampleRate,
    'createExponentialApproachArray': createExponentialApproachArray,
    'createReferenceSineArray': createReferenceSineArray,
    'createSineWaveArray': createSineWaveArray,
    'endValueDelta': endValueDelta,
    'relativeErrorMetric': relativeErrorMetric,
    'differenceErrorMetric': differenceErrorMetric,
    'valueUpdate': valueUpdate,
    'comparePartialSignals': comparePartialSignals,
    'verifyDiscontinuities': verifyDiscontinuities,
    'compareSignals': compareSignals,
    'checkResultFunction': checkResultFunction,
    'doAutomation': doAutomation,
    'createAudioGraphAndTest': createAudioGraphAndTest
  };

  for (let reference in exports) {
    global[reference] = exports[reference];
  }

})(window);