if (Files.exists(upgradedPropertiesJson)) {
                Files.copy(upgradedPropertiesJson, to.getAsFile().get().toPath(), StandardCopyOption.REPLACE_EXISTING);
            } else {
                to.getAsFile().get().delete();
            }
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

        webProtocols = split(fessConfig.getCrawlerWebProtocols(), ",")
                .get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> s.trim() + ":").toArray(n -> new String[n]));
        fileProtocols = split(fessConfig.getCrawlerFileProtocols(), ",")
                .get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> s.trim() + ":").toArray(n -> new String[n]));

        // Verify that multiple threads were processed
        assertTrue("Should process at least one thread", threadCount.get() >= 1);
        assertTrue("Should have stack trace elements", stackTraceCount.get() > 0);
        assertTrue("Should have more stack traces than threads", stackTraceCount.get() > threadCount.get());
    }

    @Test
    public void test_processThreadDump_withException() {

		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL)
		return
	}

	userProvider := mux.Vars(r)["userProvider"]

	user := r.Form.Get("user")
	tokenRevokeType := r.Form.Get("tokenRevokeType")
	fullRevoke := r.Form.Get("fullRevoke") == "true"
	isTokenSelfRevoke := user == ""
	if !isTokenSelfRevoke {
		var err error
		user, err = getUserWithProvider(ctx, userProvider, user, false)

async def lifespan(app: FastAPI):
    items["foo"] = {"name": "Fighters"}
    items["bar"] = {"name": "Tenders"}
    yield
    # clean up items
    items.clear()


app = FastAPI(lifespan=lifespan)


@app.get("/items/{item_id}")
async def read_items(item_id: str):
    return items[item_id]


def test_read_items():
    # Before the lifespan starts, "items" is still empty
    assert items == {}

              .replace("$OTHER", itemReporter.reportItem(other)));
    }
  }

  private Item<T> getItem(int groupNumber, int itemNumber) {
    return new Item<>(groups.get(groupNumber).get(itemNumber), groupNumber, itemNumber);
  }

  static final class Item<T> {
    final T value;
    final int groupNumber;
    final int itemNumber;

    task.cancel(true);
    assertTrue(task.isDone());
    assertTrue(task.isCancelled());
    assertTrue(task.wasInterrupted());
    assertThrows(CancellationException.class, () -> task.get());
    exitLatch.await();
    assertTrue(interruptedExceptionThrown.get());
  }

  @J2ktIncompatible
  @GwtIncompatible // blocking wait
  public void testRunIdempotency() throws Exception {
    int numThreads = 10;

                            final Map<String, String> indexObj = dataObj.get("index");
                            if (indexObj != null) {
                                if (indexObj.containsKey("_type")) {
                                    indexObj.remove("_type");
                                }
                                final String index = indexObj.get("_index");
                                if (index != null) {

     *
     * @return true if lasta.env is not set, false otherwise
     */
    private static boolean isNoneEnv() {
        return System.getProperty("lasta.env") == null;
    }

    /**
     * Gets the port number for the Tomcat server from system properties.
     *
     * @return the port number (default 8080 if not specified)
     */
    protected static int getPort() {

        TaskProvider<Task> buildBwcTaskProvider = project.getTasks().register("buildBwc");
        List<DistributionProject> distributionProjects = resolveArchiveProjects(checkoutDir.get(), bwcVersion.get());

        for (DistributionProject distributionProject : distributionProjects) {
            createBuildBwcTask(
                bwcSetupExtension,
                project,
                bwcVersion,