})

	assignments := []clause.Assignment(set)

	sort.Slice(assignments, func(i, j int) bool {
		return strings.Compare(assignments[i].Column.Name, assignments[j].Column.Name) > 0
	})

	if len(assignments) != 2 || assignments[0].Column.Name != "name" || assignments[0].Value.(string) != "jinzhu" || assignments[1].Column.Name != "age" || assignments[1].Value.(int) != 18 {
		t.Errorf("invalid assignments, got %v", assignments)
	}

                .thenAnswer(inv -> inv.getArgument(1));

        int n = handle.sendrecv(new byte[10], 0, 0, new byte[20], 100);
        assertEquals(0, n, "Default response length is 0 unless protocol fills it");
    }

    @Test
    @DisplayName("sendrecv uses CallNamedPipe when PIPE_TYPE_CALL is set")
    void sendrecv_call_branch() throws Exception {
        int type = SmbPipeResource.PIPE_TYPE_CALL | SmbPipeResource.PIPE_TYPE_RDWR;

 */
internal data class BitString(
  val byteString: ByteString,
  /** 0-7 unused bits in the last byte. */
  val unusedBitsCount: Int,
) {
  // Avoid Long.hashCode(long) which isn't available on Android 5.
  override fun hashCode(): Int {
    var result = 0
    result = 31 * result + byteString.hashCode()
    result = 31 * result + unusedBitsCount
    return result
  }

    return String.format(Locale.ROOT, template, args);
  }

  /** See {@link ListListIteratorTester} */
  static int listListIteratorTesterNumIterations() {
    return 4;
  }

  /** See {@link CollectionIteratorTester} */
  static int collectionIteratorTesterNumIterations() {
    return 5;
  }

  private Platform() {}

        cipher.init(Cipher.DECRYPT_MODE, dataKey);

        int plainDataLength = data.length - KerberosConstants.CHECKSUM_SIZE;
        byte[] plainData = cipher.doFinal(data, KerberosConstants.CHECKSUM_SIZE, plainDataLength);

        byte[] plainDataChecksum = getHmac(plainData, codeHmac);
        if (plainDataChecksum.length >= KerberosConstants.CHECKSUM_SIZE) {
            for (int i = 0; i < KerberosConstants.CHECKSUM_SIZE; i++) {

   * escaper from ~760ns to ~400ns as measured by {@link CharEscapersBenchmark}.
   */
  @Override
  protected int nextEscapeIndex(CharSequence csq, int index, int end) {
    checkNotNull(csq);
    for (; index < end; index++) {
      char c = csq.charAt(index);
      if (c >= safeOctets.length || !safeOctets[c]) {
        break;
      }
    }

  private GraphConstants() {}

  static final int EXPECTED_DEGREE = 2;

  static final int DEFAULT_NODE_COUNT = 10;
  static final int DEFAULT_EDGE_COUNT = DEFAULT_NODE_COUNT * EXPECTED_DEGREE;

  // Load factor and capacity for "inner" (i.e. per node/edge element) hash sets or maps
  static final float INNER_LOAD_FACTOR = 1.0f;
  static final int INNER_CAPACITY = 2; // ceiling(EXPECTED_DEGREE / INNER_LOAD_FACTOR)

  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddMeansAddOne() {
    int originalCount = getMultiset().count(e0());
    assertTrue(getMultiset().add(e0()));
    assertEquals(originalCount + 1, getMultiset().count(e0()));
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddOccurrencesZero() {
    int originalCount = getMultiset().count(e0());

     */
    Class<?> getElementClassOfCollection(int index);

    /**
     * Returns the key type if the parameter type of the method is a parameterized {@link Map}.
     *
     * @param index
     *            The index of the parameter
     * @return The key type if the parameter type is a parameterized {@link Map}, otherwise {@literal null}
     */
    Class<?> getKeyClassOfMap(int index);

    /**

    for (List<E> subList : asList(copy, head, tail)) {
      for (int index : asList(-1, subList.size())) {
        assertThrows(IndexOutOfBoundsException.class, () -> subList.get(index));
      }
    }
  }

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testSubList_contains() {
    List<E> list = getList();
    int size = getNumElements();
    List<E> copy = list.subList(0, size);