if err != nil {
		t.Fatal(err)
	}

	lkClient := newlockRESTClient(endpoint)
	if lkClient.IsOnline() {
		t.Fatalf("unexpected result. connection was online")
	}

	// Attempt all calls.
	_, err = lkClient.RLock(t.Context(), dsync.LockArgs{})
	if err == nil {
		t.Fatal("Expected for Rlock to fail")
	}

                    name = "The Gradle team"
                    organization = "Gradle Inc."
                    organizationUrl = "https://gradle.org"
                }
            }
            scm {
                connection = "scm:git:git://github.com/gradle/gradle.git"
                developerConnection = "scm:git:ssh://github.com:gradle/gradle.git"
                url = "https://github.com/gradle/gradle"
            }
        }
    }

import logging
import secrets
import subprocess
from collections import defaultdict
from pathlib import Path
from typing import Any

import httpx
import yaml
from github import Github
from pydantic import BaseModel, SecretStr
from pydantic_settings import BaseSettings

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


sponsors_query = """
query Q($after: String) {
  user(login: "tiangolo") {

	case strings.Contains(err.Error(), http.ErrServerClosed.Error()):
		return true
	// Corner case, the server closed the connection with a keep-alive timeout
	// some requests are not retried internally, such as POST request with written body
	case strings.Contains(err.Error(), "server closed idle connection"):
		return true
	}

	return false
}

// Converts network error to storageErr. This function is

 * under the License.
 */
package org.apache.maven.model.building;

import java.util.ArrayList;
import java.util.List;

import org.apache.maven.model.Model;

/**
 * A simple model problem collector for testing the model building components.
 *
 */
@Deprecated
public class SimpleProblemCollector implements ModelProblemCollector {
    private Model model;

    private List<String> warnings = new ArrayList<>();

import org.apache.maven.project.MavenProject;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,

import inspect
import sys
from collections.abc import AsyncGenerator, Generator
from functools import wraps

import pytest
from fastapi import Depends, FastAPI
from fastapi.concurrency import iterate_in_threadpool, run_in_threadpool
from fastapi.testclient import TestClient

if sys.version_info >= (3, 13):  # pragma: no cover
    from inspect import iscoroutinefunction
else:  # pragma: no cover
    from asyncio import iscoroutinefunction

import org.apache.maven.artifact.resolver.ResolutionListener;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.repository.legacy.resolver.conflict.ConflictResolver;

/**
 * Artifact collector - takes a set of original artifacts and resolves the best versions to use
 * along with their metadata. No artifacts are downloaded.
 */
@Deprecated
@SuppressWarnings("checkstyle:parameternumber")

    @Test
    public void testToStringNotNonsense() {
        Scm scm = new Scm();
        scm.setConnection("scm:git:git://git.localdomain/model");

        String s = scm.toString();

        assertEquals("Scm {connection=scm:git:git://git.localdomain/model}", s);
    }