List<ArtifactResult> results = system.resolveArtifacts(session, requests);

        assertEquals(3, results.size());
        checkArtifactResult(results.get(0), "artifact-1.0.jar");
        checkArtifactResult(results.get(1), "artifact-1.0.zip");
        checkArtifactResult(results.get(2), "artifact-1.0-classifier.zip");
    }

    @Test
    void testResolveMetadata() throws Exception {

		clientIP = ipv6fix(clientIP)
		if req.Header.Get(xRealIP) == "" {
			req.Header.Set(xRealIP, clientIP)
		}
	}

	xfProto := req.Header.Get(xForwardedProto)
	if xfProto == "" {
		if req.TLS != nil {
			req.Header.Set(xForwardedProto, "https")
		} else {
			req.Header.Set(xForwardedProto, "http")
		}
	}

	if xfPort := req.Header.Get(xForwardedPort); xfPort == "" {

    private int numReferrals;
    private int tflags;
    private Referral[] referrals;

    /**
     * Get the number of characters consumed from the path
     *
     * @return the pathConsumed
     */
    public final int getPathConsumed() {
        return this.pathConsumed;
    }

    /**
     * Get the number of referrals in the response
     *
     * @return the numReferrals
     */

     *
     * @param id the base64-encoded filename of the log file to download
     * @return stream response containing the log file content
     */
    // GET /api/admin/log/file/{id}
    @Execute
    public StreamResponse get$file(final String id) {
        final String filename = new String(Base64.getDecoder().decode(id), StandardCharsets.UTF_8).replace("..", "").replaceAll("\\s", "");

    }

    /**
     * Get request ID
     *
     * @return unique request identifier
     */
    public long getRequestId() {
        return requestId;
    }

    /**
     * Get request type
     *
     * @return type of request
     */
    public RequestType getType() {
        return type;
    }

    /**
     * Get associated memory region
     *

    assertMapsEqual(expected, map);
    assertEquals(expected.get("a"), map.get("a"));
    assertEquals(expected.containsKey("a"), map.containsKey("a"));
    assertEquals(expected.get("b"), map.get("b"));
    assertEquals(expected.containsKey("b"), map.containsKey("b"));
    assertEquals(expected.get("c"), map.get("c"));
    assertEquals(expected.containsKey("c"), map.containsKey("c"));
  }

        configField.setAccessible(true);
        assertSame(mockConfig, configField.get(response));

        // Verify queryAddress is set
        Field queryAddressField = NodeStatusResponse.class.getDeclaredField("queryAddress");
        queryAddressField.setAccessible(true);
        assertSame(mockQueryAddress, queryAddressField.get(response));

        // Verify recordName is initialized

        Map<String, Integer> failCounts = (Map<String, Integer>) failCountsField.get(pool);

        // When: Add fail counts
        failCounts.put("192.168.1.1", 3);
        failCounts.put("192.168.1.2", 1);

        // Then: Should be accessible
        assertEquals(3, failCounts.get("192.168.1.1"));
        assertEquals(1, failCounts.get("192.168.1.2"));
    }

from fastapi import FastAPI

app = FastAPI()


@app.get("/items/", tags=["items"])
async def read_items():
    return [{"name": "Foo", "price": 42}]


@app.get("/users/", tags=["users"])
async def read_users():
    return [{"username": "johndoe"}]


@app.get("/elements/", tags=["items"], deprecated=True)
async def read_elements():

def test_events(app: FastAPI):
    with TestClient(app) as client:
        response = client.get("/items/foo")
        assert response.status_code == 200, response.text
        assert response.json() == {"name": "Fighters"}


def test_openapi_schema(app: FastAPI):
    with TestClient(app) as client:
        response = client.get("/openapi.json")
        assert response.status_code == 200, response.text