setField(cmd, "largeFile", false);
        byte[] buf = new byte[12]; // Buffer needs to be at least 12 bytes for the parameter words
        cmd.writeParameterWordsWireFormat(buf, 0);
        // The flag must be present so the command recognises largeFile
        SmbComLockingAndX copy = new SmbComLockingAndX(cfg);
        copy.readParameterWordsWireFormat(buf, 0);
        assertTrue((boolean) getField(copy, "largeFile"));
    }

        super.render(htmlReportFile, enrichReport(data))
    }

    /**
     * This is super-hacky: this report is instantiated via {@code newInstance()}, within a different
     * classloader by {@link JApiCmpWorkerAction}, so there is no way to use a
     * normal property on the renderer instance and just set the location of the API file in it.
     *
     * Instead, we'll encode the path to the file in the description data field, as a link.  This is

    for prod and one for tests. However, unlike our other packages, as of this
    writing it has test supersource but no prod supersource.

    GWT happens to use the prod .gwt.xml, so it looks for no supersource for
    tests, either. This causes it to fail to find AtomicLongMapTest.

    Our workaround is to tell GWT that util.concurrent and all other packages

     * href="../../../nbtcodes.html">Here</a> is
     * a fairly complete list of NetBIOS hex codes. Scope is not used but is
     * still functional in other NetBIOS products and so for completeness it has been
     * implemented. A <code>scope</code> of <code>null</code> or <code>""</code>
     * signifies no scope.
     *
     * The additional <code>svr</code> parameter specifies the address to

    private JAASAuthenticator buildAuthenticator(SubjectVariant variant) {
        switch (variant) {
        case DEFAULT_WITH_PS: {
            JAASAuthenticator a = new JAASAuthenticator();
            // Provide a preset Subject so the getSubject() path uses the (serviceName, ps, this) constructor
            a.setSubject(new Subject());
            return a;
        }
        case WITH_CONFIG: {

                        do {
                            if (path == null) {
                                /* Store references to the map and key so that
                                 * SmbFile.resolveDfs can re-insert the dr list with
                                 * the dr that was successful so that subsequent
                                 * attempts to resolve DFS use the last successful
                                 * referral first.

* Enforce security, authentication, role requirements, etc.
* And many other things...

All these, while minimizing code repetition.

## First Steps { #first-steps }

Let's see a very simple example. It will be so simple that it is not very useful, for now.

But this way we can focus on how the **Dependency Injection** system works.

### Create a dependency, or "dependable" { #create-a-dependency-or-dependable }

Before that, it only supported the keyword `example` with a single example. That is still supported by OpenAPI 3.1.0, but is deprecated and is not part of the JSON Schema standard. So you are encouraged to migrate `example` to `examples`. 🤓

You can read more at the end of this page.

///

## `Field` additional arguments { #field-additional-arguments }

   * at the end of the test, so there is no object state put at risk by stopping the threads
   * abruptly. In other cases, a test may put a thread into an uninterruptible operation
   * intentionally, so there is no other way to clean up these threads. (The better solution,
   * though, would be to run the tests that use TestThread in separate VMs so that their threads
   * don't hang around during other tests.)
   */

# Precompiling results in some action conflicts. Disable it for now until
# the problematic targets are fixed.
common --@rules_python//python/config_settings:precompile=force_disabled

# TF now has `cc_shared_library` targets, so it needs the experimental flag
# TODO(rostam): Remove when `cc_shared_library` is enabled by default
common --experimental_cc_shared_library

# cc_shared_library ensures no library is linked statically more than once.