* from GC, as with {@link #awaitClear}. Because there are no guarantees for the order of GC
   * finalization processing, there may still be some unfinished work for the GC to do after this
   * method returns.
   *
   * <p>This method does not create any memory pressure as would be required to cause soft
   * references to be processed.
   *

    checkMessage(expected, "LockB -> LockA", "LockA -> LockB");
    // The causal chain should be cached.
    assertThat(expected.getCause()).isEqualTo(firstException.getCause());
    // lockA should work after lockB is released.
    lockB.unlock();
    lockA.lock();
  }

  // Tests transitive deadlock detection.
  public void testDeadlock_threeLocks() {
    // Establish an ordering from lockA -> lockB.

    checkMessage(expected, "LockB -> LockA", "LockA -> LockB");
    // The causal chain should be cached.
    assertThat(expected.getCause()).isEqualTo(firstException.getCause());
    // lockA should work after lockB is released.
    lockB.unlock();
    lockA.lock();
  }

  // Tests transitive deadlock detection.
  public void testDeadlock_threeLocks() {
    // Establish an ordering from lockA -> lockB.

  }

  /**
   * Adds each member of {@code elements} as a candidate for the top {@code k} elements. This
   * operation takes amortized linear time in the length of {@code elements}. The iterator is
   * consumed after this operation completes.
   *
   * <p>If all input data to this {@code TopKSelector} is in a single {@code Iterator}, prefer
   * {@link Ordering#leastOf(Iterator, int)}, which provides a simpler API for that use case.
   */

        assertEquals('W', asciiBytes[10]);
        assertEquals('z', asciiBytes[11]);
        assertEquals(0, asciiBytes[12]); // null character
    }

    @Test
    @DisplayName("Test field values after construction")
    void testFieldValuesAfterConstruction() {
        netShareEnum = new NetShareEnum(realConfig);

        // Test all important fields

        for (int i = 7; i < 35; i++) {
            buffer[bufferIndex + i] = 0x00;
        }
        buffer[bufferIndex + 35] = 0x00;
        buffer[bufferIndex + 36] = reservedValue; // Reserved byte after setupCount

        int bytesRead = response.readParameterWordsWireFormat(buffer, bufferIndex);

        // Should still read 37 bytes regardless of reserved byte values
        assertEquals(37, bytesRead);
    }

            }
            return null;
        }).when(cache).resolveSids0(any(), any(), any());

        cache.resolveSids(ctx, null, arr, 2, 1); // resolve only s3

        // Verify cache behavior - after reset, spying on the same cache won't work
        // Since we're working with internal state, we'll verify the side effects
        assertEquals("DOM", s1.getDomainName());
        assertEquals("user1", s1.getAccountName());

現在回頭理解剛剛那些是什麼。

在 OAuth2 中，`password` 是處理安全與身分驗證的其中一種「流程」（flow）。

OAuth2 的設計讓後端或 API 可以獨立於執行使用者驗證的伺服器。

但在這個例子中，同一個 FastAPI 應用會同時處理 API 與驗證。

簡化來看流程如下：

- 使用者在前端輸入 `username` 與 `password`，按下 `Enter`。
- 前端（在使用者的瀏覽器中執行）把 `username` 與 `password` 傳到我們 API 的特定 URL（在程式中宣告為 `tokenUrl="token"`）。
- API 檢查 `username` 與 `password`，並回傳一個「token（權杖）」（我們還沒實作這部分）。
    - 「token（權杖）」就是一段字串，之後可用來識別並驗證此使用者。
    - 通常 token 會設定一段時間後失效。

现在回过头来理解这些内容。

`password` “流”（flow）是 OAuth2 定义的处理安全与身份验证的一种方式。

OAuth2 的设计目标是让后端或 API 与负责用户认证的服务器解耦。

但在这个例子中，**FastAPI** 应用同时处理 API 和认证。

从这个简化的角度来看看流程：

* 用户在前端输入 `username` 和 `password`，然后按下 `Enter`。
* 前端（运行在用户浏览器中）把 `username` 和 `password` 发送到我们 API 中的特定 URL（使用 `tokenUrl="token"` 声明）。
* API 校验 `username` 和 `password`，并返回一个“令牌”（这些我们尚未实现）。
    * “令牌”只是一个字符串，包含一些内容，之后可用来验证该用户。
    * 通常，令牌会在一段时间后过期。

			minio.PutObjectOptions{DisableContentSha256: true},
		)
		return err
	}

	return NotImplemented{}
}

type listerAt []os.FileInfo

// Modeled after strings.Reader's ReadAt() implementation
func (f listerAt) ListAt(ls []os.FileInfo, offset int64) (int, error) {
	var n int
	if offset >= int64(len(f)) {
		return 0, io.EOF
	}
	n = copy(ls, f[offset:])