TestEncodeDecode(__LINE__, {"hello"});
  TestEncodeDecode(__LINE__,
                   {"the", "quick", "brown", "fox", "jumped", "over"});

  std::string big(1000, 'a');
  TestEncodeDecode(__LINE__, {"small", big, "small2"});
}

TEST(CAPI, SessionOptions) {
  TF_SessionOptions* opt = TF_NewSessionOptions();
  TF_DeleteSessionOptions(opt);
}

TEST(CAPI, DeprecatedSession) {
  TF_Status* s = TF_NewStatus();

            // Before handling call1's CONNECT we do all of call2. This part re-entrant!
            try {
              val call2 =
                client.newCall(
                  Request
                    .Builder()
                    .url("https://android.com/call2")
                    .build(),
                )
              val response2 = call2.execute()

   * {@link TreeSet} or the {@link Map#keySet} of an {@code IdentityHashMap}.
   *
   * <p><b>Note:</b> The returned view performs slightly better when {@code set1} is the smaller of
   * the two sets. If you have reason to believe one of your sets will generally be smaller than the
   * other, pass it first. Unfortunately, since this method sets the generic type of the returned

common:windows --cxxopt=/std:c++17
common:windows --host_cxxopt=/std:c++17

# On windows, we still link everything into a single DLL.
common:windows --config=monolithic

# On linux, we dynamically link small amount of kernels
common:linux --config=dynamic_kernels

# Make sure to include as little of windows.h as possible
common:windows --copt=-DWIN32_LEAN_AND_MEAN
common:windows --host_copt=-DWIN32_LEAN_AND_MEAN

   * {@link TreeSet} or the {@link Map#keySet} of an {@code IdentityHashMap}.
   *
   * <p><b>Note:</b> The returned view performs slightly better when {@code set1} is the smaller of
   * the two sets. If you have reason to believe one of your sets will generally be smaller than the
   * other, pass it first. Unfortunately, since this method sets the generic type of the returned

}

// DeleteObjects deletes objects/versions in bulk, this function will still automatically split objects list
// into smaller bulks if some object names are found to be duplicated in the delete list, splitting
// into smaller bulks will avoid holding twice the write lock of the duplicated object names.

    }

    @Test
    public void test_addIntentHistory_contiguousBlock() {
        client.setTestIntentHistoryMaxChars(10);
        // Messages: [big(20), small(2), small(2)]
        // From newest: small(2) fits (remaining=8), small(2) fits (remaining=6), big(20) doesn't => break
        final List<LlmMessage> history = new ArrayList<>();
        history.add(LlmMessage.user("A".repeat(20))); // 20 chars

    assertThat(response1.code).isEqualTo(200)
    response1.body.close()
    eventRecorder.clearAllEvents()
    val call2 =
      client.newCallWithListener(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response2 = call2.execute()
    assertThat(response2.code).isEqualTo(200)
    response2.body.close()

				if len(p) < 5 {
					panic("unexpected small read")
				}
				return 5, errors.New("5-then-error")
			}),
			n:            4,
			want:         4,
			wantErr:      nil,
			wantBuffered: 1,
		},
		{
			name: "fill error, discard equal",
			r: newScriptedReader(func(p []byte) (n int, err error) {
				if len(p) < 5 {
					panic("unexpected small read")
				}

		t.Fatalf("Failed to query smaller user, got error %v", err)
	}

	AssertObjEqual(t, user, simpleUser, "Name", "ID", "UpdatedAt", "CreatedAt")

	var simpleUser2 SimpleUser
	if err := DB.Model(&User{}).Select("id").First(&simpleUser2, user.ID).Error; err != nil {
		t.Fatalf("Failed to query smaller user, got error %v", err)
	}

	AssertObjEqual(t, user, simpleUser2, "ID")