* direct or via its collection views, result in an {@code UnsupportedOperationException}.
   *
   * <p>The returned table will be serializable if the specified table is serializable.
   *
   * @param table the row-sorted table for which an unmodifiable view is to be returned
   * @return an unmodifiable view of the specified table
   * @since 11.0
   */

   *
   * <p>The returned {@code Map} iterates over entries in ascending order of the bounds of the
   * {@code Range} entries.
   *
   * <p>It is guaranteed that no empty ranges will be in the returned {@code Map}.
   */
  Map<Range<K>, V> asMapOfRanges();

  /**
   * Returns a view of this range map as an unmodifiable {@code Map<Range<K>, V>}. Modifications to

import (
	"errors"
	"fmt"
)

var (
	// ErrUnknownHandler is returned when an unknown handler is requested.
	ErrUnknownHandler = errors.New("unknown mux handler")

	// ErrHandlerAlreadyExists is returned when a handler is already registered.
	ErrHandlerAlreadyExists = errors.New("mux handler already exists")

	// ErrIncorrectSequence is returned when an out-of-sequence item is received.

    arraycopy(src, offset, dst, 0, len);
    return dst;
  }

  /**
   * Returns an array containing all of the elements in the specified collection. This method
   * returns the elements in the order they are returned by the collection's iterator. The returned
   * array is "safe" in that no references to it are maintained by the collection. The caller is
   * thus free to modify the returned array.
   *

    return checkNotNull(iterable);
  }

  /**
   * Returns a fluent iterable that combines two iterables. The returned iterable has an iterator
   * that traverses the elements in {@code a}, followed by the elements in {@code b}. The source
   * iterators are not polled until necessary.
   *
   * <p>The returned iterable's iterator supports {@code remove()} when the corresponding input

            assertNull(renewed, "renew() may return null for failed renewal");
        }
    }

    @Test
    @DisplayName("Mockito: verify renew() interaction and return value")
    void mockitoInteraction(@Mock CredentialsInternal returned, @Mock SmbRenewableCredentials renewable) {
        // Arrange: stub renew() to return a mocked CredentialsInternal
        when(renewable.renew()).thenReturn(returned);

        // Act: invoke renew()

  private TestingExecutors() {}

  /**
   * Returns a {@link ScheduledExecutorService} that never executes anything.
   *
   * <p>The {@code shutdownNow} method of the returned executor always returns an empty list despite
   * the fact that everything is still technically awaiting execution. The {@code getDelay} method
   * of any {@link ScheduledFuture} returned by the executor will always return the max long value

   * required to be a {@link BufferedWriter} in order to allow implementations to simply delegate to
   * {@link #openStream()} when the stream returned by that method does not benefit from additional
   * buffering. This method returns a new, independent writer each time it is called.
   *
   * <p>The caller is responsible for ensuring that the returned writer is closed.
   *

type Error struct {
	Code    int    // The HTTP status code returned to the client
	APICode string // The API error code identifying the error
	Err     string // The error message returned to the client
	Cause   error  // Optional, lower level error cause.
}

func (e Error) Error() string {
	if e.Cause == nil {
		return e.Err
	}
	return fmt.Sprintf("%s: %v", e.Err, e.Cause)
}

// as a string. If the [Buffer] is a nil pointer, it returns "<nil>".
//
// To build strings more efficiently, see the [strings.Builder] type.
func (b *Buffer) String() string {
	if b == nil {
		// Special case, useful in debugging.
		return "<nil>"
	}
	return string(b.buf[b.off:])
}

// Peek returns the next n bytes without advancing the buffer.
// If Peek returns fewer than n bytes, it also returns [io.EOF].