while existing projects are gradually being opted-in. The formatting check
can be run explicitly with:

    ./gradlew spotlessJavaCheck

The code can be formatted with:

    ./gradlew spotlessApply

These tasks can also be run for specific subprojects, e.g.

    ./gradlew server:spotlessJavaCheck

Please follow these formatting guidelines:

	}
}

func TestVersioningZero(t *testing.T) {
	var v Versioning
	if v.Enabled() {
		t.Fatalf("Expected to be disabled but got enabled")
	}
	if v.Suspended() {
		t.Fatalf("Expected to be disabled but got suspended")
	}
}

func TestExcludeFolders(t *testing.T) {
	v := Versioning{
		Status:         Enabled,
		ExcludeFolders: true,
	}

 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 */

        assertTrue(session.isInUse(), "Session should be in use initially");
        try (SmbSessionImpl autoSession = session) {
            // Session is already in use due to transport acquisition
            assertTrue(autoSession.isInUse(), "Session should be in use");
        }

        // Session should be automatically released
        assertFalse(session.isInUse(), "Session should be released after try-with-resources");
    }

     *
     * @param dir the directory to locate the pom for, never {@code null}
     * @param options possible parsing options, may be {@code null}
     * @return an optional parsed {@link Model} or {@code null} if none could be found
     * @throws ModelParserException if the located model cannot be parsed
     */
    @Nonnull
    default Optional<Model> locateAndParse(@Nonnull Path dir, @Nullable Map<String, ?> options)

   * any exceptions thrown when attempting to close a closeable will be suppressed. Otherwise, the
   * <i>first</i> exception to be thrown from an attempt to close a closeable will be thrown and any
   * additional exceptions that are thrown after that will be suppressed.
   */
  @Override
  public void close() throws IOException {
    Throwable throwable = thrown;

## What is a Stream? { #what-is-a-stream }

"**Streaming**" data means that your app will start sending data items to the client without waiting for the entire sequence of items to be ready.

So, it will send the first item, the client will receive and start processing it, and you might still be producing the next item.

```mermaid
sequenceDiagram
    participant App
    participant Client

    App->>App: Produce Item 1

        assertEquals(expectedNt, actual.get(), String.format("NTSTATUS for %08x should be %08x", dosErr, expectedNt));
    }

    @Test
    @DisplayName("Unknown DOS error code yields empty Optional")
    void testUnknownCode() {
        Optional<Integer> noMatch = findNtStatus(0xdeadbeef);
        assertFalse(noMatch.isPresent(), "Mapping for unknown code should be absent");
    }

    @Test

## Containers and Processes { #containers-and-processes }

A **container image** normally includes in its metadata the default program or command that should be run when the **container** is started and the parameters to be passed to that program. Very similar to what would be if it was in the command line.

When a **container** is started, it will run that command/program (although you can override it and make it run a different command/program).

        Objects.requireNonNull(model, "model cannot be null");

        try (Writer out = output) {
            new MavenXpp3Writer().write(out, model);
        }
    }

    @Override
    public void write(OutputStream output, Map<String, Object> options, Model model) throws IOException {
        Objects.requireNonNull(output, "output cannot be null");