type KeycloakProvider struct {
	sync.Mutex

	oeConfig DiscoveryDoc
	client   http.Client
	adminURL string
	realm    string

	// internal value refreshed
	accessToken Token
}

// LoginWithUser authenticates username/password, not needed for Keycloak
func (k *KeycloakProvider) LoginWithUser(username, password string) error {
	return ErrNotImplemented
}

# ADR-0008 - Use NullAway for null checking

## Date

2025-08-06

## Context

Our codebase uses `null` extensively to represent an absence of value or optionality of the argument.
We utilize nullness annotations in Java code and somewhat rely on IDE warnings to guide us.
However, the Java code we have is not fully annotated, which causes several consequences:
* IDE warnings can be misleading

            "loc": [
                "path",
                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

以下のようなテキスト版を取得します:

```
1 validation error
path -> item_id
  value is not a valid integer (type=type_error.integer)
```

#### `RequestValidationError`と`ValidationError`

	{Multipart: true, Metadata: map[string]string{"X-Minio-Internal-Encrypted-Multipart": ""}}, // 1
	{Multipart: true, Metadata: map[string]string{MetaMultipart: "some-value"}},                // 2
	{Multipart: false, Metadata: map[string]string{"": ""}},                                    // 3
	{Multipart: false, Metadata: map[string]string{"X-Minio-Internal-EncryptedMultipart": ""}}, // 4
}

   * The HTTP <a
   * href="https://iabtechlab.com/wp-content/uploads/2019/06/VAST_4.2_final_june26.pdf">{@code
   * X-Device-Referer}</a> header field name. Header used for VAST requests to provide the {@link
   * #REFERER} header value that the on-behalf-of client would have used when making a request
   * itself.
   *
   * @since 31.0
   */
  public static final String X_DEVICE_REFERER = "X-Device-Referer";

  /**
   * The HTTP <a

   *
   * <p>Only runs of two or more hextets are considered. In case of a tie, the leftmost run wins. If
   * a qualifying run is found, its hextets are replaced by the sentinel value -1.
   *
   * @param hextets {@code int[]} mutable array of eight 16-bit hextets
   */
  private static void compressLongestRunOfZeroes(int[] hextets) {
    int bestRunStart = -1;
    int bestRunLength = -1;

    @SuppressWarnings("unused") // called by NullPointerTester
    @Keep
    public void checkGeneric(T value, String s) {
      calledWith(value, s);
    }
  }

  private static class GenericDefaultValueResolvedToStringChecker
      extends AbstractGenericDefaultValueChecker<String> {
    void check() {
      runTester();

                }
            } catch (final Exception e) {
                // Ignore errors - some servers don't properly return this field
                // Keep the default empty string value
            }
        }

        return bufferIndex - start;
    }

    @Override
    public String toString() {

     * The binary search implementation has a bug where it accesses array out of bounds.
     */
    @Test
    void testGetMessageByDcerpcError_largerThanAny() {
        int unknownCode = 0x7FFFFFFF; // Max int value

        // The current implementation has a bug in the binary search that causes ArrayIndexOutOfBoundsException
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {

    }

    @Test
    void testReadParameterWordsWireFormat_bufDataStartIsNotZero() {
        // Test case when bufDataStart is not 0.
        response.bufDataStart = 50; // Initial non-zero value
        byte[] buffer = new byte[37]; // 3 reserved + 8*4 bytes for int4 values + 2 bytes for setupCount
        int bufferIndex = 0;

        // Reserved bytes
        buffer[bufferIndex++] = 0x00;