@Test
    void testMultipleReads() throws SMBProtocolDecodingException {
        // First read
        byte[] firstData = { 1, 2, 3 };
        byte[] buffer1 = new byte[10];
        System.arraycopy(firstData, 0, buffer1, 0, firstData.length);
        response.readDataWireFormat(buffer1, 0, firstData.length);

        // Verify first data
        for (int i = 0; i < firstData.length; i++) {

// error returned by disks which are to be initialized are waiting for the
// first server to initialize them in distributed set to initialize them.
var errNotFirstDisk = errors.New("Not first drive")

// error returned by first disk waiting to initialize other servers.
var errFirstDiskWait = errors.New("Waiting on other drives")

// error returned for a negative actual size.

        // hasNext/next sequence over two elements
        assertTrue(it.hasNext(), "Expected first element available");
        SmbResource r1 = it.next();
        assertNotNull(r1);
        assertEquals("foo/", r1.getName(), "First child name should match with trailing slash");

        assertTrue(it.hasNext(), "Expected second element available");
        SmbResource r2 = it.next();

   * concurrent maps whose content may change while the method is running.
   *
   * <p>The serialized output consists of the number of entries, first key, first value, second key,
   * second value, and so on.
   */
  static <K extends @Nullable Object, V extends @Nullable Object> void writeMap(
      Map<K, V> map, ObjectOutputStream stream) throws IOException {

github_graphql_url = "https://api.github.com/graphql"


prs_query = """
query Q($after: String) {
  repository(name: "fastapi", owner: "fastapi") {
    pullRequests(first: 100, after: $after) {
      edges {
        cursor
        node {
          number
          labels(first: 100) {
            nodes {
              name
            }
          }
          author {
            login
            avatarUrl
            url

    PeekingIterator<?> peekingIterator = peekingIterator(iterator);

    assertEquals("Should be able to peek() at first element", "A", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() first element multiple times", "A", peekingIterator.peek());
    assertEquals(
        "next() should still return first element after peeking", "A", peekingIterator.next());

		}
	}

	// save embedded struct
	DB.Save(&HNPost{BasePost: BasePost{Title: "news"}})
	DB.Save(&HNPost{BasePost: BasePost{Title: "hn_news"}})
	var news HNPost
	if err := DB.First(&news, "title = ?", "hn_news").Error; err != nil {
		t.Errorf("no error should happen when query with embedded struct, but got %v", err)
	} else if news.Title != "hn_news" {

     */
    public void setPrefixMatchWeight(final float prefixMatchWeight) {
        this.prefixMatchWeight = prefixMatchWeight;
    }

    /**
     * Sets whether to match the first word.
     * @param matchWordFirst True to match the first word, false otherwise.
     */
    public void setMatchWordFirst(final boolean matchWordFirst) {
        this.matchWordFirst = matchWordFirst;
    }

    /**

  int sortedSet(int reps) {
    int dummy = 0;
    if (mutable) {
      for (int i = 0; i < reps; i++) {
        dummy += new TreeSet<Integer>(input).first();
      }
    } else {
      for (int i = 0; i < reps; i++) {
        dummy += ImmutableSortedSet.copyOf(input).first();
      }
    }
    return dummy;
  }

  private static final Ordering<Integer> ORDERING = Ordering.natural();

		t.Error(err)
	}

	var got5 Level2
	DB.Preload("Level1s").First(&got5, "value = ?", "bogus")

	var ruLevel1 Level1
	var zhLevel1 Level1
	DB.First(&ruLevel1, "value = ?", "ru")
	DB.First(&zhLevel1, "value = ?", "zh")

	got.Level1s = []*Level1{&ruLevel1}
	got2.Level1s = []*Level1{&zhLevel1}