orderedNodeConnections = null;
        break;
      case STABLE:
        orderedNodeConnections = new ArrayList<>();
        break;
      default:
        throw new AssertionError(incidentEdgeOrder.type());
    }

    return new DirectedGraphConnections<>(
        /* adjacentNodeValues= */ new HashMap<N, Object>(initialCapacity, INNER_LOAD_FACTOR),
        orderedNodeConnections,
        /* predecessorCount= */ 0,

        if (isWindows()) {
            return new String[]{"powershell", "-Command", "\"Get-CimInstance Win32_Process | ForEach-Object { \\\"$($_.CommandLine) $($_.ProcessId)\\\" }\""};
        } else if (isMacOS()) {
            return new String[]{"ps", "x", "-o", "pid,command"};
        } else if (isAlpine()) {
            return new String[]{"ps", "x", "-o", "pid,args"};
        } else {

        // SMB1 negotiation with server data
        SmbComNegotiateResponse smb1 = new SmbComNegotiateResponse(ctx);
        ServerData sd = smb1.getServerData();
        sd.encryptionKey = new byte[] { 1, 2, 3 };
        setField(transport, "negotiated", smb1);
        assertArrayEquals(new byte[] { 1, 2, 3 }, transport.getServerEncryptionKey());

        // SMB2 negotiation never exposes key via this API

          sumOfSquaresOfDeltas = t;
        }
        return new MeanAndVariance(mean, sumOfSquaresOfDeltas / values.length);
      }
    },
    KNUTH {
      @Override
      MeanAndVariance variance(double[] values, MeanAlgorithm meanAlgorithm) {
        if (meanAlgorithm != MeanAlgorithm.KNUTH) {
          throw new SkipThisScenarioException();
        }
        double mean = values[0];

          sumOfSquaresOfDeltas = t;
        }
        return new MeanAndVariance(mean, sumOfSquaresOfDeltas / values.length);
      }
    },
    KNUTH {
      @Override
      MeanAndVariance variance(double[] values, MeanAlgorithm meanAlgorithm) {
        if (meanAlgorithm != MeanAlgorithm.KNUTH) {
          throw new SkipThisScenarioException();
        }
        double mean = values[0];

  private final ForwardingWrapperTester tester = new ForwardingWrapperTester();

  public void testGoodForwarder() {
    tester.testForwarding(Arithmetic.class, ForwardingArithmetic::new);
    tester.testForwarding(ParameterTypesDifferent.class, ParameterTypesDifferentForwarder::new);
  }

  public void testVoidMethodForwarding() {
    tester.testForwarding(Runnable.class, ForwardingRunnable::new);
  }

        .isEqualTo(21);
  }

  public void testRemovalListener_expireAfterWrite() {
    FakeTicker ticker = new FakeTicker();
    AtomicInteger evictionCount = new AtomicInteger();
    AtomicInteger applyCount = new AtomicInteger();
    AtomicInteger totalSum = new AtomicInteger();

    RemovalListener<Integer, AtomicInteger> removalListener =
        notification -> {

      return (Multiset.Entry<E>[]) new Multiset.Entry<?>[length];
    }

    @Override
    public Iterable<Entry<E>> order(List<Entry<E>> insertionOrder) {
      // We mimic the order from gen.
      Map<E, Entry<E>> map = new LinkedHashMap<>();
      for (Entry<E> entry : insertionOrder) {
        map.put(entry.getElement(), entry);
      }

      Set<E> seen = new HashSet<>();

        if (tc.getConfig().isUseRawNTLM()) {
            return setupTargetName(tc, host, new NtlmContext(tc, this, doSigning));
        }

        try {
            if (initialToken != null && initialToken.length > 0) {
                NegTokenInit tok = new NegTokenInit(initialToken);
                if (log.isDebugEnabled()) {
                    log.debug("Have initial token " + tok);

    return new StringSourceFactory();
  }

  public static ByteSourceFactory byteArraySourceFactory() {
    return new ByteArraySourceFactory();
  }

  public static ByteSourceFactory emptyByteSourceFactory() {
    return new EmptyByteSourceFactory();
  }

  public static CharSourceFactory emptyCharSourceFactory() {
    return new EmptyCharSourceFactory();
  }