Instead, you want to provide a different dependency that will be used only during tests (possibly only some specific tests), and will provide a value that can be used where the value of the original dependency was used.

### Use cases: external service

An example could be that you have an external authentication provider that you need to call.

		config.KV{
			Key:   config.Enable,
			Value: "",
		},
		config.KV{
			Key:   DisplayName,
			Value: "",
		},
		config.KV{
			Key:   ConfigURL,
			Value: "",
		},
		config.KV{
			Key:   ClientID,
			Value: "",
		},
		config.KV{
			Key:   ClientSecret,
			Value: "",
		},
		config.KV{
			Key:   ClaimName,
			Value: policy.PolicyName,
		},
		config.KV{

    @Nonnull
    default MessageBuilder a(CharSequence value, int start, int end) {
        return append(value, start, end);
    }

    /**
     * Append content to the message buffer.
     *
     * @param value the content to append
     * @return the current builder
     */
    @Nonnull
    default MessageBuilder a(CharSequence value) {
        return append(value);
    }

    /**

                          "client_sampling": {
                            "value": 100
                          },
                          "random_sampling": {
                            "value": 1
                          },
                          "overall_sampling": {
                            "value": 100
                          },
                          "custom_tags": [

    public String configParameter;

    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer depth;

    @Min(value = 0)
    @Max(value = 9223372036854775807L)
    @ValidateTypeFailure
    public Long maxAccessCount;

    @Required
    @Size(max = 200)
    public String userAgent;

    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure

func NewURLValuesWith(values map[string][]string) *URLValues {
	u := URLValues(values)
	return &u
}

// Values returns the url.Values.
// If u is nil, an empty url.Values is returned.
// The values are a shallow copy of the underlying map.
func (u *URLValues) Values() url.Values {
	if u == nil {
		return url.Values{}
	}
	return url.Values(*u)
}

// Recycle the underlying map.

app = FastAPI()
app.state.value = 42


async def extract_value_from_http_connection(conn: HTTPConnection):
    return conn.app.state.value


@app.get("/http")
async def get_value_by_http(value: int = Depends(extract_value_from_http_connection)):
    return value


@app.websocket("/ws")
async def get_value_by_ws(
    websocket: WebSocket, value: int = Depends(extract_value_from_http_connection)
):

    network.addEdge(4, 3, "p");
  }

  private static class NonComparableSuperClass {
    final Integer value;

    NonComparableSuperClass(Integer value) {
      this.value = checkNotNull(value);
    }

    @Override
    public String toString() {
      return "value=" + value;
    }
  }

  @SuppressWarnings("ComparableType")

Indicates STS API version information, the only supported value is '2011-06-15'.  This value is borrowed from AWS STS API documentation for compatibility reasons.

| Params     | Value    |
| :--        | :--      |
| *Type*     | *String* |
| *Required* | *Yes*    |

### DurationSeconds

    It's used internally to recognize when a default value has been overwritten, even
    if the overridden default value was truthy.
    """

    def __init__(self, value: Any):
        self.value = value

    def __bool__(self) -> bool:
        return bool(self.value)

    def __eq__(self, o: object) -> bool:
        return isinstance(o, DefaultPlaceholder) and o.value == self.value


DefaultType = TypeVar("DefaultType")