// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"bytes"
	"fmt"
	"io"
	"net/http"

// The buffer is only valid until the next write operation on b.
func (b *Writer) AvailableBuffer() []byte {
	return b.buf[b.n:][:0]
}

// Buffered returns the number of bytes that have been written into the current buffer.
func (b *Writer) Buffered() int { return b.n }

// Write writes the contents of p into the buffer.
// It returns the number of bytes written.

 *
 * <pre>
 * LockA -&gt; LockB -&gt; LockC
 * LockA -&gt; LockC -&gt; LockB
 * </pre>
 *
 * <p><strong>ReadWriteLocks</strong>
 *
 * <p>While {@code ReadWriteLock} instances have different properties and can form cycles without
 * potential deadlock, this class treats {@code ReadWriteLock} instances as equivalent to
 * traditional exclusive locks. Although this increases the false positives that the locks detect

      Spliterator<T> spliterator = splits.removeLast();

      if (spliterator.getExactSizeIfKnown() == 0) {
        continue; // drop this split
      }

      // Many spliterators will have trySplits that are SUBSIZED even if they are not themselves
      // SUBSIZED.
      if (spliterator.hasCharacteristics(Spliterator.SUBSIZED)) {
        // we can drill down to exactly the smallest nonempty spliterator

    for (int j = 0; j < 1000; j++) {
      builder.add(9);
    }
    ImmutableSortedSet<Integer> unused = builder.build();
    assertThat(compares[0]).isAtMost(10000);
    // hopefully something quadratic would have more digits
  }

    /*
     * TODO(cpovirk): use Object[] instead of E[] in the mainline? (The backport is different and
     * doesn't need this suppression, but we keep it to minimize diffs.) Generally be more clear
     * about when we have an Object[] vs. a Comparable[] or other array type in internalArray? If we
     * used Object[], we might be able to optimize toArray() to use clone() sometimes. (See
     * cl/592273615 and cl/592273683.)
     */

    Comparator<TestDatum> comparator = Comparator.comparing(d -> d.letter);

    // When elements compare as equal (both C's have same letter), our merge should always return C1
    // before C2, since C1 is from the first iterator.

    Iterator<TestDatum> merged =

  /**
   * This is the actual implementation of {@link #precomputed}, but we bounce calls through a method
   * on {@link Platform} so that we can have different behavior in GWT.
   *
   * <p>This implementation tries to be smart in a number of ways. It recognizes cases where the
   * negation is cheaper to precompute than the matcher itself; it tries to build small hash tables

     * Updates the user's group and role membership information with lazy loading for parent groups.
     * Direct groups are retrieved synchronously, while parent groups are fetched asynchronously
     * to avoid login delays when users have many nested group memberships.
     * @param user The Entra ID user to update.
     */
    public void updateMemberOf(final EntraIdUser user) {
        if (logger.isDebugEnabled()) {

    Comparator<TestDatum> comparator = Comparator.comparing(d -> d.letter);

    // When elements compare as equal (both C's have same letter), our merge should always return C1
    // before C2, since C1 is from the first iterator.

    Iterator<TestDatum> merged =