ThreadDumpUtil.printThreadDump();
                            } else {
                                logger.warn("Unknown process command: command={}", command);
                            }
                            if (Thread.interrupted()) {
                                return;
                            }

 *
 * <p>Some uses of this class include
 *
 * <ul>
 *   <li>As a method return type, as an alternative to returning {@code null} to indicate that no
 *       value was available
 *   <li>To distinguish between "unknown" (for example, not present in a map) and "known to have no
 *       value" (present in the map, with value {@code Optional.absent()})
 *   <li>To wrap nullable references for storage in a collection that does not support {@code null}

     * The Java tools location is {@link StandardLocation#PATCH_MODULE_PATH}.
     *
     * Note that this option is incomplete, because it must be followed by a module name.
     * Use this type only when the module to patch is unknown.
     *
     * @see #patchModule(String)
     */
    PATCH_MODULE(StandardLocation.PATCH_MODULE_PATH, "--patch-module"),

    /**
     * The path identified by the Java {@code --processor-path} option.

	tests := []struct {
		value       DefaultRetention
		expectedErr error
		expectErr   bool
	}{
		{
			value:       DefaultRetention{Mode: "retain"},
			expectedErr: fmt.Errorf("unknown retention mode retain"),
			expectErr:   true,
		},
		{
			value:       DefaultRetention{Mode: RetGovernance},
			expectedErr: fmt.Errorf("either Days or Years must be specified"),
			expectErr:   true,
		},

    }

    /**
     * Creates and returns a {@link Traverser} for handling the specified URL.
     * <p>
     * Returns <code>null</code> if the protocol of the URL is unknown.
     * </p>
     *
     * @param url
     *            The URL of the resource.
     * @param rootPackage
     *            The root package.
     * @param rootDir
     *            The root directory.

            }
        };

        assertArrays(new String[] {}, fessConfig.normalizeQueryLanguages(new String[] {}));
        assertArrays(new String[] {}, fessConfig.normalizeQueryLanguages(new String[] { "unknown" }));
        assertArrays(new String[] { "ja" }, fessConfig.normalizeQueryLanguages(new String[] { "ja" }));
        assertArrays(new String[] { "ja" }, fessConfig.normalizeQueryLanguages(new String[] { "ja", "ja" }));

        // strictXmlAttributes = true for model: if strict == true, not only elements are checked but attributes too
        if (strict) {
            throw new XmlPullParserException(
                    "Unknown attribute '" + attribute + "' for tag '" + tagName + "'", parser, null);
        }
    } // -- void checkUnknownAttribute( XmlPullParser, String, String, boolean )

    /**
     * Method checkUnknownElement.
     *

    assertThat(CertificateAdapters.extension.toDer(extension))
      .isEqualTo(bytes)
    assertThat(CertificateAdapters.extension.fromDer(bytes))
      .isEqualTo(extension)
  }

  @Test fun `extension with unknown type hint`() {
    val extension =
      Extension(
        // common name is not an extension.
        COMMON_NAME,
        false,
        "3006800109810109".decodeHex(),
      )

            sessionId = null;

            auditLogger.logEvent(EventType.SESSION_DESTROYED, Severity.INFO, "Authenticator closed and credentials wiped",
                    Map.of("username", username != null ? username : "unknown"));
        } finally {
            // Wipe client challenge - guaranteed by try-finally
            if (clientChallenge != null) {
                SecureKeyManager.secureWipe(clientChallenge);

            // Then: Should have correct values
            assertEquals(0x3e, message.getOpnum());
            assertEquals("system", message.system_name);
            assertEquals(456, message.unknown);
            assertEquals(123, message.access_mask);
            assertEquals(mockPolicyHandle, message.handle);
        }

        @Test
        @DisplayName("Should encode input with non-null system name")