assertThat(dataset).asList().isEqualTo(SIXTEEN_SQUARES_LONGS);
  }

  public void testScale_index_compute_intVarargs() {
    int[] dataset = Ints.toArray(SIXTEEN_SQUARES_INTEGERS);
    assertThat(Quantiles.scale(10).index(1).compute(dataset))
        .isWithin(ALLOWED_ERROR)
        .of(SIXTEEN_SQUARES_DECILE_1);
    assertThat(dataset).asList().isEqualTo(SIXTEEN_SQUARES_INTEGERS);
  }

import static com.google.common.collect.Lists.transform;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.lang.Math.max;
import static java.util.Arrays.asList;
import static java.util.Collections.nCopies;

import com.google.common.annotations.GwtIncompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.ArrayList;
import java.util.List;

        // Default behavior when disallowCompound is null
        assertTrue(config.isAllowCompound("AnyCommand"));

        // Set disallowCompound
        config.disallowCompound = new HashSet<>(Arrays.asList("Command1", "Command2"));

        assertFalse(config.isAllowCompound("Command1"));
        assertFalse(config.isAllowCompound("Command2"));
        assertTrue(config.isAllowCompound("Command3"));
    }

            // sge.setLkey(disniRegion.getLocalKey());
            // sgeList.add(sge);
            //
            // sendWR.setSg_list(sgeList);
            // endpoint.postSend(Arrays.asList(sendWR)).execute().free();

            log.debug("DiSNI RDMA send completed, {} bytes", data.remaining());

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;

public class StandardMutableUndirectedGraphTest extends AbstractStandardUndirectedGraphTest {

  @Parameters(name = "allowsSelfLoops={0}, incidentEdgeOrder={1}")
  public static Collection<Object[]> parameters() {
    return Arrays.asList(
        new Object[][] {
          {false, ElementOrder.unordered()},
          {true, ElementOrder.unordered()},
          {false, ElementOrder.stable()},
          {true, ElementOrder.stable()},
        });
  }

        return artifact -> false;
    }

    @Test
    void testEquals() {
        OrArtifactFilter filter1 = new OrArtifactFilter();

        OrArtifactFilter filter2 = new OrArtifactFilter(Arrays.asList(newSubFilter()));

        assertFalse(filter1.equals(null), "Expected " + filter1 + " to not equal " + null);
        assertTrue(filter1.equals(filter1), "Expected " + filter1 + " to equal " + filter1);

package com.google.common.collect.testing.google;

import static com.google.common.collect.testing.Helpers.assertEqualIgnoringOrder;
import static com.google.common.collect.testing.Helpers.mapEntry;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.Multimap;
import com.google.common.collect.testing.AbstractContainerTester;
import com.google.common.collect.testing.SampleElements;

        when(mockConfig.getNetbiosSndBufSize()).thenReturn(576);
        when(mockConfig.getNetbiosRcvBufSize()).thenReturn(576);
        when(mockConfig.getResolveOrder()).thenReturn(Arrays.asList(ResolverType.RESOLVER_DNS)); // Only DNS, no broadcast
        when(mockConfig.getNetbiosHostname()).thenReturn("TESTHOST");
        when(mockConfig.getNetbiosScope()).thenReturn(null);

    return map.keyIterator();
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return map.containsKey(object);
  }

  @Override
  K get(int index) {
    return map.entrySet().asList().get(index).getKey();
  }

  @Override
  boolean isPartialView() {
    return true;
  }

  @Override
  @J2ktIncompatible
  @GwtIncompatible
    Object writeReplace() {

/**
 */
public class ExclusionSetFilter implements ArtifactFilter {
    private Set<String> excludes;

    public ExclusionSetFilter(String[] excludes) {
        this.excludes = new LinkedHashSet<>(Arrays.asList(excludes));
    }

    public ExclusionSetFilter(Set<String> excludes) {
        this.excludes = excludes;
    }

    @Override
    public boolean include(Artifact artifact) {