}

// SMA struct for calculating simple moving average
type SMA struct {
	buf       []float64
	window    int     // len of buf
	idx       int     // current index in buf
	CAvg      float64 // cumulative average
	prevSMA   float64
	filledBuf bool
}

func newSMA(ln int) *SMA {
	if ln <= 0 {
		ln = defaultWindowSize
	}
	return &SMA{
		buf:    make([]float64, ln),
		window: ln,

import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import org.junit.Ignore;

/**
 * A generic JUnit test which tests {@code remove(int)} operations on a list. Can't be invoked
 * directly; please see {@link com.google.common.collect.testing.ListTestSuiteBuilder}.
 *
 * @author Chris Povirk
 */
@GwtCompatible

    protected final long tookMs;

    /**
     * The list of popular words.
     */
    protected final List<String> words;

    /**
     * The number of popular words.
     */
    protected final int num;

    /**
     * The total number of words.
     */
    protected final long total;

    /**
     * The list of suggested items.
     */
    protected final List<SuggestItem> items;

    /**

        public String getSort() {
            return null;
        }

        @Override
        public int getStartPosition() {
            return 0;
        }

        @Override
        public int getPageSize() {
            return 10;
        }

        @Override
        public int getOffset() {
            return 0;
        }

        @Override
        public String[] getExtraQueries() {

  static final Iterable<LegacyComparable> VALUES_BACKWARD = asList(Z, Y, X);

  private final String value;

  LegacyComparable(String value) {
    this.value = value;
  }

  @Override
  public int compareTo(Object object) {
    // This method is spec'd to throw CCE if object is of the wrong type
    LegacyComparable that = (LegacyComparable) object;
    return this.value.compareTo(that.value);
  }

  @Override

        this.buf = out;
        this.consumer = consumer;
    }

    public PrintStream printStream() {
        return new LoggingPrintStream(this);
    }

    @Override
    public void write(int b) throws IOException {
        super.write(b);
        if (buf.isEol()) {
            String line = new String(buf.toByteArray(), 0, buf.size() - LINE_SEP.length);
            ProjectBuildLogAppender.updateMdc();

    }

    fun addProjectToEnableNullawayIn(projectPath: String) {
        ensureProjectNotSeen(projectPath)

        projectsToEnableNullaway.add(projectPath)
    }

    private val seenProjectsCount: Int
        get() = projectsWithNullAwayEnabled.size + projectsWithUncheckedDeps.size + projectsToEnableNullaway.size

    override fun close() {
        require(seenProjectsCount > 0) {

 * </p>
 */
public class AccessTimeoutTarget implements TimeoutTarget {

    private static final Logger logger = LogManager.getLogger(AccessTimeoutTarget.class);

    private static final int MAX_LOOP_COUNT = 10;

    /** The thread being monitored. */
    protected Thread runningThread;

    /** Flag indicating if the thread is still running. */
    protected AtomicBoolean running = new AtomicBoolean();

 *
 * @author Nishant Thakkar
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public abstract class AbstractChainedListenableFutureTest<T> extends TestCase {
  protected static final int EXCEPTION_DATA = -1;
  protected static final int VALID_INPUT_DATA = 1;
  protected static final Exception EXCEPTION = new Exception("Test exception");

  protected SettableFuture<Integer> inputFuture;
  protected ListenableFuture<T> resultFuture;

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)
  public void testPutAllNullValueNullLast_unsupported() {
    int size = getNumElements();

    assertThrows(
        NullPointerException.class, () -> multimap().putAll(k3(), newArrayList(v3(), null)));

    Collection<V> values = multimap().get(k3());
    if (values.size() == 0) {