String decrypted = cryptographer.decrypt(encrypted);
        assertEquals(plainText, decrypted);
    }

    @Test
    public void test_invertibleCryptography_withSpecialCharacters() {
        // Test with special characters
        InvertibleCryptographer cryptographer = securityResourceProvider.providePrimaryInvertibleCryptographer();
        assertNotNull(cryptographer);

        String plainText = "!@#$%^&*(){}[]|\\:;\"'<>,.?/~`";

      verifyHostname(hostname, it)
    }
  }

  /**
   * This is like [toLowerCase] except that it does nothing if this contains any non-ASCII
   * characters. We want to avoid lower casing special chars like U+212A (Kelvin symbol) because
   * they can return ASCII characters that match real hostnames.
   */
  private fun String.asciiToLowercase(): String =
    when {
      isAscii() -> lowercase(Locale.US)

     * In the case of Java tools, the map may also contain {@code --patch-module} options, which are
     * {@linkplain org.apache.maven.api.JavaPathType#patchModule(String) handled in a special way}.
     *
     * <h4>Design note</h4>
     * All types of path are determined together because they are sometime mutually exclusive.
     * For example, an artifact of type {@value org.apache.maven.api.Type#JAR} can be placed

    String ALT_USER_SETTINGS_XML_LOCATION = "org.apache.maven.user-settings";
    String ALT_GLOBAL_SETTINGS_XML_LOCATION = "org.apache.maven.global-settings";
    String ALT_LOCAL_REPOSITORY_LOCATION = "maven.repo.local";

    Settings buildSettings(MavenExecutionRequest request) throws IOException, XmlPullParserException;

    /**
     * @return a <code>Settings</code> object from the user settings file.
     * @throws IOException if any

     *
     * @param model The model to interpolate, must not be {@code null}.
     * @param projectDir The project directory, may be {@code null} if the model does not belong to a local project but
     *            to some artifact's metadata.
     * @param request The model building request that holds further settings, must not be {@code null}.

// Regular object test type.
type objTestType func(obj ObjectLayer, instanceType string, t TestErrHandler)

// Special test type for test with directories
type objTestTypeWithDirs func(obj ObjectLayer, instanceType string, dirs []string, t TestErrHandler)

// Special object test type for disk not found situations.
type objTestDiskNotFoundType func(obj ObjectLayer, instanceType string, dirs []string, t *testing.T)

        // Create original packet
        SessionRequestPacket originalPacket = new SessionRequestPacket(mockConfig, new TestNetbiosName("FILESERVER", 0x20, "CORP.LOCAL"),
                new TestNetbiosName("WORKSTATION1", 0x00, "CORP.LOCAL"));

        // Write to buffer
        byte[] buffer = new byte[512];
        int written = originalPacket.writeWireFormat(buffer, 0);

        // Read from buffer

      serverSocketChannel.configureBlocking(true);
      serverSocketChannel.socket().bind(address);
    }

    @Override public int getLocalPort() {
      return 1; // A white lie. There is no local port.
    }

    @Override public SocketAddress getLocalSocketAddress() {
      return endpoint;
    }

    @Override public Socket accept() throws IOException {
      try {

            assertFalse("Should return empty for locale: " + locale, result.isPresent());
        }
    }

    @Test
    public void test_provide_withSpecialCharacters() {
        // Test classification names with special characters
        assertProvideThrowsException("Test@Classification");
        assertProvideThrowsException("Test#Classification");
        assertProvideThrowsException("Test$Classification");

     * we can override it in our non-null-guaranteeing subtypes to present a better signature to
     * their users.
     *
     * However, the checker *we* use has this special knowledge about `Collection.toArray()` anyway,
     * so in our implementation code, we can rely on that. That's why the expression below
     * type-checks.
     */
    return super.toArray();
  }