ctx.setMechs(updated);
        assertArrayEquals(updated, ctx.getMechs());
    }

    @Test
    @DisplayName("toString includes wrapped mechanism context")
    void testToString() {
        SpnegoContext ctx = newContext();
        when(this.mechContext.toString()).thenReturn("MECHCTX");
        assertEquals("SPNEGO[MECHCTX]", ctx.toString());
    }

 *       divided into segments, each of which does LRU internally)
 *   <li>time-based expiration of entries, measured since last access or last write
 *   <li>keys automatically wrapped in {@linkplain WeakReference weak} references
 *   <li>values automatically wrapped in {@linkplain WeakReference weak} or {@linkplain
 *       SoftReference soft} references
 *   <li>notification of evicted (or otherwise removed) entries

                fos = new FileOutputStream(newFile);
                writer = new BufferedWriter(new OutputStreamWriter(fos, Constants.UTF_8));
                fos = null; // Successfully wrapped, no need to close explicitly
            } catch (final Exception e) {
                if (fos != null) {
                    try {
                        fos.close();

     */
    public QueryStringBuilder() {
        // Default constructor
    }

    /**
     * Quotes a string value if it contains spaces.
     * Multi-word values are wrapped in double quotes with internal quotes replaced by spaces.
     *
     * @param value the string value to quote
     * @return the quoted string if it contains spaces, otherwise the original value
     */

                fos = new FileOutputStream(newFile);
                writer = new BufferedWriter(new OutputStreamWriter(fos, Constants.UTF_8));
                fos = null; // Successfully wrapped, no need to close explicitly
            } catch (final Exception e) {
                if (fos != null) {
                    try {
                        fos.close();

                fos = new FileOutputStream(newFile);
                writer = new BufferedWriter(new OutputStreamWriter(fos, Constants.UTF_8));
                fos = null; // Successfully wrapped, no need to close explicitly
            } catch (final Exception e) {
                if (fos != null) {
                    try {
                        fos.close();

    Writer result = CharStreams.asWriter(plainAppendable);
    assertNotSame(plainAppendable, result);
    assertThat(result).isNotNull();

    // A Writer should not be wrapped
    Appendable secretlyAWriter = new StringWriter();
    result = CharStreams.asWriter(secretlyAWriter);
    assertSame(secretlyAWriter, result);
  }

    Writer result = CharStreams.asWriter(plainAppendable);
    assertNotSame(plainAppendable, result);
    assertThat(result).isNotNull();

    // A Writer should not be wrapped
    Appendable secretlyAWriter = new StringWriter();
    result = CharStreams.asWriter(secretlyAWriter);
    assertSame(secretlyAWriter, result);
  }

	errorCounts := make(map[error]int)
	for _, err := range errs {
		if IsErrIgnored(err, ignoredErrs...) {
			continue
		}
		// Errors due to context cancellation may be wrapped - group them by context.Canceled.
		if errors.Is(err, context.Canceled) {
			errorCounts[context.Canceled]++
			continue
		}
		errorCounts[err]++
	}

	maxCnt := 0

type NetworkError struct {
	Err error
}

func (n *NetworkError) Error() string {
	return n.Err.Error()
}

// Unwrap returns the error wrapped in NetworkError.
func (n *NetworkError) Unwrap() error {
	return n.Err
}

// Client - http based RPC client.
type Client struct {
	connected int32 // ref: https://golang.org/pkg/sync/atomic/#pkg-note-BUG