String locationHint = "testLocation";
        Throwable error = new RuntimeException("testError");
        when(mockDelegate.renewCredentials(locationHint, error)).thenReturn(true);
        assertTrue(cifsContextWrapper.renewCredentials(locationHint, error));
        verify(mockDelegate).renewCredentials(locationHint, error);
    }

    @Test

	return d.metaCh
}

// Pos returns the number of bytes consumed from the underlying reader
func (d *Decoder) Pos() int { return int(d.pos) }

// Err returns the most recent decoder error if any, or nil
func (d *Decoder) Err() error { return d.err }

// MaxDepth will set the maximum recursion depth.
// If the maximum depth is exceeded, ErrMaxDepth is returned.
// Less than or 0 means no limit (default).

        logging.error(
            f"Response was not 200, after: {after}, category_id: {category_id}"
        )
        logging.error(response.text)
        raise RuntimeError(response.text)
    data = response.json()
    if "errors" in data:
        logging.error(f"Errors in response, after: {after}, category_id: {category_id}")
        logging.error(data["errors"])
        logging.error(response.text)

			if testcase.expectedErr && err == nil {
				t.Error("expected failure, got success")
			}
			if !testcase.expectedErr && err != nil {
				t.Error("expected success, got failure", err)
			}
			if err == nil {
				if len(sctx.Layout.pools) != 2 {
					t.Error("expected parsed pools to be 2, not", len(sctx.Layout.pools))
				}
				if sctx.Layout.pools[0].cmdline != testcase.hash {

func (z *BatchJobSize) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 int64
		zb0001, err = dc.ReadInt64()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = BatchJobSize(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z BatchJobSize) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteInt64(int64(z))
	if err != nil {

        problemCollector.add(Problem.Severity.ERROR, "MESSAGE", 3, 5, new Exception());
        ToolchainsBuildingException e = new ToolchainsBuildingException(problemCollector.getProblems());
        assertEquals(
                "1 problem was encountered while building the effective toolchains" + LS
                        + "[ERROR] MESSAGE @ line 3, column 5" + LS,
                e.getMessage());
    }

)

var (
	errInvalidAccessKeyID = errors.New("The access key ID you provided does not exist in our records")
	errAccessKeyDisabled  = errors.New("The access key you provided is disabled")
	errAuthentication     = errors.New("Authentication failed, check your access credentials")
	errNoAuthToken        = errors.New("JWT token missing")
	errSkewedAuthTime     = errors.New("Skewed authentication date/time")

	if info.Free > info.Total {
		return info, fmt.Errorf("detected free space (%d) > total drive space (%d), fs corruption at (%s). please run 'fsck'", info.Free, info.Total, path)
	}
	info.Used = info.Total - info.Free
	return info, nil
}

// GetDriveStats returns IO stats of the drive by its major:minor
func GetDriveStats(major, minor uint32) (iostats IOStats, err error) {
	return IOStats{}, errors.New("operation unsupported")

}

func (S Tracer) LogMode(level logger.LogLevel) logger.Interface {
	return S.Logger.LogMode(level)
}

func (S Tracer) Info(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Info(ctx, s, i...)
}

func (S Tracer) Warn(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Warn(ctx, s, i...)
}

        };
    addCallback(f, callback, directExecutor());
    f.cancel(true);
  }

  public void testThrowErrorFromGet() {
    Error error = new AssertionError("ASSERT!");
    ListenableFuture<String> f = UncheckedThrowingFuture.throwingError(error);
    MockCallback callback = new MockCallback(error);
    addCallback(f, callback, directExecutor());
  }

  public void testRuntimeExceptionFromGet() {