return null;
        });
        try (InputStream inputStream = form.synonymFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
        }

        if (address == null) {
            return false;
        }
        try {
            final InetAddress inetAddress = InetAddress.getByName(address);
            return inetAddress instanceof Inet6Address;
        } catch (final Exception e) {
            return false;
        }
    }

    /**
     * Formats an IP address string for use in a URL.
     * IPv6 addresses are wrapped in brackets, IPv4 addresses are returned as-is.

    public void test_touch() {
        final ChatSession session = new ChatSession();
        final LocalDateTime initialTime = session.getLastAccessedAt();

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // ignore
        }

        session.touch();

        assertTrue(session.getLastAccessedAt().isAfter(initialTime) || session.getLastAccessedAt().isEqual(initialTime));

        scheduledJob.setId("nonexistent-job");

        try {
            scheduledJob.start(Map.of(Constants.JOB_LOG_ID, "some-id"));
            fail("Expected JobNotFoundException");
        } catch (final JobNotFoundException e) {
            // expected
        }
    }

    @Test
    public void test_startNoArg_callsLaunchNowWithoutParams() {

    try {
      presentFeatures = (Feature<?>[]) annotationClass.getMethod("value").invoke(testerAnnotation);
      absentFeatures = (Feature<?>[]) annotationClass.getMethod("absent").invoke(testerAnnotation);
    } catch (Exception e) {
      throw new IllegalArgumentException("Error extracting features from tester annotation.", e);
    }
    Set<Feature<?>> allPresentFeatures = addImpliedFeatures(copyToSet(presentFeatures));

      extends UnsupportedOperationException {
    // Package-private because this should only be thrown by loadAll() when it is not overridden.
    // Cache implementors may want to catch it but should not need to be able to throw it.
    UnsupportedLoadingOperationException() {}
  }

  /**
   * Thrown to indicate that an invalid response was returned from a call to {@link CacheLoader}.
   *

        synchronized (this) {
            try {
                state = 1;
                final DcerpcMessage bind = new DcerpcBind(binding, this);
                sendrecv(bind);
            } catch (final IOException ioe) {
                state = 0;
                throw ioe;
            }
        }
    }

    /**
     * Sends a DCERPC message and receives the response

                java.lang.reflect.Field lengthField = ServerMessageBlock2.class.getDeclaredField("length");
                lengthField.setAccessible(true);
                lengthField.setInt(this, length);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        protected int readBytesWireFormat(byte[] buffer, int bufferIndex) {
            return 0;

            return result.getArtifactResults().stream()
                    .filter(ArtifactResult::isResolved)
                    .map(ArtifactResult::getArtifact)
                    .collect(Collectors.toList());
        } catch (PluginResolutionException | InterpolatorException e) {
            throw new ExtensionResolutionException(extension, e);
        }
    }

            try {
                Map<Path, Document> pomMap = Map.of(); // Empty for this test
                return doUpgrade(context, targetModel, pomMap);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        // Helper method from AbstractUpgradeStrategy