// Add a timeout similar to what we expect upstream.
	ctx, cancel := context.WithTimeout(context.Background(), dsync.DefaultTimeouts.RefreshCall)
	defer cancel()

	resp := lockRPCRefresh.NewResponse()
	refreshed, err := l.ll.Refresh(ctx, *args)
	if err != nil {
		return l.makeResp(resp, err)
	}
	if !refreshed {
		return l.makeResp(resp, errLockNotFound)
	}

}

func prepareErasureSets32(ctx context.Context) (ObjectLayer, []string, error) {
	return prepareErasure(ctx, 32)
}

func prepareErasure(ctx context.Context, nDisks int) (ObjectLayer, []string, error) {
	fsDirs, err := getRandomDisks(nDisks)
	if err != nil {
		return nil, nil, err
	}
	obj, _, err := initObjectLayer(ctx, mustGetPoolEndpoints(0, fsDirs...))
	if err != nil {
		removeRoots(fsDirs)

     *             Thrown if the initial context cannot be created.
     */
    public static Object lookup(final InitialContext ctx, final String jndiName) throws NamingRuntimeException {
        assertArgumentNotNull("ctx", ctx);
        assertArgumentNotEmpty("jndiName", jndiName);

        try {
            return ctx.lookup(jndiName);
        } catch (final NamingException ex) {
            throw new NamingRuntimeException(ex);
        }

 */
package jcifs.smb;

import jcifs.CIFSContext;

/**
 * @author mbechler
 *
 */
class SmbTreeConnectionTrace extends SmbTreeConnection {

    SmbTreeConnectionTrace(final CIFSContext ctx) {
        super(ctx);
    }

    SmbTreeConnectionTrace(final SmbTreeConnection conn) {
        super(conn);
    }

    @Override
    protected void finalize() throws Throwable {
        checkRelease();
    }

		return listener, listenErrs
	}
	listeners = slices.Clip(listeners)

	ctx, cancel := context.WithCancel(ctx)
	listener = &httpListener{
		listeners:   listeners,
		acceptCh:    make(chan acceptResult, len(listeners)),
		opts:        opts,
		ctxDoneCh:   ctx.Done(),
		ctxCanceler: cancel,
	}
	opts.Trace(fmt.Sprintf("opening %d listeners", len(listener.listeners)))

    private Address[] addresses;
    private int addressIndex;
    private int type;

    private final CIFSContext ctx;

    /**
     *
     * @param ctx
     * @param u
     */
    public SmbResourceLocatorImpl(final CIFSContext ctx, final URL u) {
        this.ctx = ctx;
        this.url = u;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.Object#clone()
     */

#define C_OPKERNELCONTEXT_REQUIRES_OK(CTX, C_STATUS, __VA_ARGS__) \
  do {                                                            \
    ::tensorflow::Status _s(__VA_ARGS__);                         \
    if (!TF_PREDICT_TRUE(_s.ok())) {                              \
      ::tensorflow::Set_TF_Status_from_Status(C_STATUS, _s);      \
      TF_OpKernelContext_Failure(CTX, C_STATUS);                  \

		logger.Info("WARNING: maximum virtual memory limit (%s) is too small for 'go runtime', please consider setting `ulimit -v` to unlimited",
			humanize.IBytes(vssLimit))
	}

	if ctx.MemLimit > 0 {
		debug.SetMemoryLimit(int64(ctx.MemLimit))
	}

	// Do not use RLIMIT_AS as that is not useful and at times on systems < 4Gi
	// this can crash the Go runtime if the value is smaller refer

	}
	m.handlers.init()
	if ctx == nil {
		ctx = context.Background()
	}

	for _, host := range o.Hosts {
		if host == o.Local {
			if found {
				return nil, fmt.Errorf("grid: local host found multiple times")
			}
			found = true
			// No connection to local.
			continue
		}
		m.targets[host] = newConnection(connectionParams{
			ctx:           ctx,
			id:            m.ID,

		}
	})
}

func TestCancelTransaction(t *testing.T) {
	ctx := context.Background()
	ctx, cancelFunc := context.WithCancel(ctx)
	cancelFunc()

	user := *GetUser("cancel_transaction", Config{})
	DB.Create(&user)

	err := DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		var result User
		tx.First(&result, user.ID)
		return nil
	})