public boolean hasNext() {
        return valueItr.hasNext() || valueCollectionItr.hasNext();
      }

      @Override
      public V next() {
        if (!valueItr.hasNext()) {
          valueItr = valueCollectionItr.next().iterator();
        }
        return valueItr.next();
      }
    };
  }

  private static final class Values<K, V> extends ImmutableCollection<V> {

            if (locations.size() == 1 && locations.values().iterator().next() == this) {
                return org.apache.maven.api.model.InputLocation.of(
                        lineNumber,
                        columnNumber,
                        source != null ? source.toApiSource() : null,
                        locations.keySet().iterator().next());
            } else {

        @Override
        protected @Nullable String computeNext() {
          if (lines.hasNext()) {
            String next = lines.next();
            // skip last line if it's empty
            if (lines.hasNext() || !next.isEmpty()) {
              return next;
            }
          }
          return endOfData();
        }
      };
    }

    @Override

	}
	return &SMA{
		buf:    make([]float64, ln),
		window: ln,
		idx:    0,
	}
}

func (s *SMA) addSample(next float64) {
	prev := s.buf[s.idx]
	s.buf[s.idx] = next

	if s.filledBuf {
		s.prevSMA += (next - prev) / float64(s.window)
		s.CAvg += (next - s.CAvg) / float64(s.window)
	} else {
		s.CAvg = s.simpleMovingAvg()
		s.prevSMA = s.CAvg
	}
	if s.idx == s.window-1 {

                ArrayNode featuresArray = (ArrayNode) features;
                Iterator<JsonNode> it = featuresArray.elements();
                while (it.hasNext()) {
                    if (getSkipFeatureName().equals(it.next().asText())) {
                        return true;
                    }
                }
            } else {
                if (getSkipFeatureName().equals(features.asText())) {
                    return true;

    FluentIterable<Integer> cycle = fluent(1, 2).cycle();
    Iterator<Integer> iterator = cycle.iterator();
    iterator.next();
    iterator.remove();
    iterator.next();
    iterator.remove();
    assertFalse(iterator.hasNext());
    assertFalse(cycle.iterator().hasNext());
  }

  public void testAppend() {
    FluentIterable<Integer> result =

                final CommonServerMessageBlockRequest next = chain.getNext();
                if (log.isTraceEnabled()) {
                    log.trace(String.format("%s costs %d avail %d (%s)", chain.getClass().getName(), cost, this.credits.availablePermits(),
                            this.name));
                }
                if ((next == null || chain.allowChain(next)) && totalSize + size < maxSize && this.credits.tryAcquire(cost)) {

        byte[] src = "Test".getBytes();

        // Test with non-null source array
        int nextOffset = NtlmMessage.writeSecurityBuffer(dest, 0, src);
        assertEquals(4, nextOffset, "Should return correct next offset.");
        assertEquals(src.length, NtlmMessage.readUShort(dest, 0), "Length should be written correctly.");
        assertEquals(src.length, NtlmMessage.readUShort(dest, 2), "Max length should be written correctly.");

		{
			name: "contexts reconverging after api/next/* update",
			features: []string{
				"A",
				"pkg syscall, type RawSockaddrInet6 struct",
			},
			required: []string{
				"A",
				"pkg syscall (darwin-amd64), type RawSockaddrInet6 struct", // api/go1.n.txt
				"pkg syscall, type RawSockaddrInet6 struct",                // api/next/n.txt
			},
			ok:  true,
			out: "",
		},
		{

    return new UnmodifiableIterator<K>() {
      @Override
      public boolean hasNext() {
        return entryIterator.hasNext();
      }

      @Override
      public K next() {
        return entryIterator.next().getKey();
      }
    };
  }

  private transient @Nullable ImmutableCollection<V> cachedValues = null;

  @Override
  public ImmutableCollection<V> values() {