private Smb2LeaseKey leaseKey;
    private int leaseState;
    private long leaseDuration;

    /**
     * Constructs an SMB2 lease break response with the given configuration.
     *
     * @param config the configuration for this response
     */
    public Smb2LeaseBreakResponse(Configuration config) {
        super(config);
    }

    /**
     * Gets the lease key from the break response

                ? Optional.empty()
                : Optional.of(getVersions().get(getVersions().size() - 1));
    }

    /**
     * Gets the repository from which the specified version was resolved.
     *
     * @param version The version whose source repository should be retrieved, must not be {@code null}
     * @return An Optional containing the repository from which the version was resolved,

        targetMap.put("existing", "value");
        String configParam = "new.param=value\nconfig.setting=true";
        ParameterUtil.loadConfigParams(targetMap, configParam);
        assertEquals(3, targetMap.size());
        assertEquals("value", targetMap.get("existing"));
        assertEquals("value", targetMap.get("new.param"));
        assertEquals("true", targetMap.get("config.setting"));
    }

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Most of the logic for {@link IteratorTester} and {@link ListIteratorTester}.
 *
 * @param <E> the type of element returned by the iterator
 * @param <I> the type of the iterator ({@link Iterator} or {@link ListIterator})
 * @author Kevin Bourrillion
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked

/**
 * This abstract base class for testers allows the framework to inject needed information after
 * JUnit constructs the instances.
 *
 * <p>This class is emulated in GWT.
 *
 * @param <G> the type of the test generator required by this tester. An instance of G should
 *     somehow provide an instance of the class under test, plus any other information required to
 *     parameterize the test.

            jobHelper.setJobRuntime(runtime);
            process(runtime);
        } finally {
            jobHelper.setJobRuntime(null);
        }
    }

    /**
     * Processes the job.
     * @param runtime The job runtime.
     */
    protected void process(final LaJobRuntime runtime) {
        if (!runtime.getParameterMap().containsKey(Constants.SCHEDULED_JOB)) {

  class Builder {
    val pins = mutableListOf<Pin>()

    /**
     * Pins certificates for `pattern`.
     *
     * @param pattern lower-case host name or wildcard pattern such as `*.example.com`.
     * @param pins SHA-256 or SHA-1 hashes. Each pin is a hash of a certificate's Subject Public Key
     *     Info, base64-encoded and prefixed with either `sha256/` or `sha1/`.
     */

		FuncName:  s.Cmd,
		Duration:  time.Since(startTime),
		Path:      objPath,
		Error:     errStr,
		Bytes:     sz,
		Custom: map[string]string{
			"user":   s.Sess.LoginUser(),
			"cmd":    s.Cmd,
			"param":  s.Param,
			"login":  fmt.Sprintf("%t", s.Sess.IsLogin()),
			"source": source,
		},
	}
}

func (m *ftpMetrics) log(s *ftp.Context, paths ...string) func(sz int64, err error) {
	startTime := time.Now()

                resource -> accessContextLogic.create(resource, OptionalThing::empty, OptionalThing::empty, () -> APP_TYPE));
    }

    /**
     * Sets the job class to be executed by this scheduler.
     *
     * @param jobClass the job class to set
     */
    public void setJobClass(final Class<? extends LaJob> jobClass) {
        this.jobClass = jobClass;
    }

 *
 * <p>Like any other {@code Map<Class, Object>}, this map may contain entries for primitive types,
 * and a primitive type and its corresponding wrapper type may map to different values.
 *
 * @param <B> the common supertype that all entries must share; often this is simply {@link Object}
 * @author Ben Yu
 * @since 13.0
 */
@DoNotMock("Use ImmutableTypeToInstanceMap or MutableTypeToInstanceMap")