TransferResource resource = event.getResource();
        out.warn(
                "{} from {} for {}{}",
                event.getException().getMessage(),
                resource.getRepositoryId(),
                resource.getRepositoryUrl(),
                resource.getResourceName());
    }

    @Override
    public void transferSucceeded(TransferEvent event) {

    @Override
    public void artifactDescriptorInvalid(RepositoryEvent event) {
        println(
                "artifactDescriptorInvalid",
                "for " + event.getArtifact() + ": " + event.getException().getMessage());
    }

    @Override
    public void artifactDescriptorMissing(RepositoryEvent event) {
        println("artifactDescriptorMissing", "for " + event.getArtifact());
    }

    @Override

    ExampleClassUnderTest.foo();
    LogRecord record = handler.getStoredLogRecords().get(0);
    assertEquals(Level.INFO, record.getLevel());
    assertEquals("message", record.getMessage());
    assertSame(EXCEPTION, record.getThrown());
  }

  public void testConcurrentModification() throws Exception {
    // Tests for the absence of a bug where logging while iterating over the

                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

    @Override
    public void transformForInstall(Artifact artifact, ArtifactRepository localRepository) {
        // metadata is added via addPluginArtifactMetadata

        // Execute and verify
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            watchHandle.watch();
        });

        assertEquals("Watch operation failed", thrown.getMessage());
        verify(watchHandle, times(1)).watch();
    }

    /**
     * Test call() method delegates to watch()
     */
    @Test
    void testCall() throws CIFSException {

                    "1 problem was encountered while building the effective toolchains" + LS
                            + "[FATAL] Non-parseable toolchains (memory): MESSAGE @ line 4, column 2" + LS,
                    e.getMessage());
        }
    }

    @Test
    void testIOException() throws Exception {
        Source src = mock(Source.class);
        IOException ioException = new IOException("MESSAGE");

            if (logger.isDebugEnabled()) {
                logger.debug(e.getMessage(), e);
            }
            saveError(e.getMessageCode());
            return redirectToRoot();
        } catch (final ResultOffsetExceededException e) {
            if (logger.isDebugEnabled()) {
                logger.debug(e.getMessage(), e);
            }
            saveError(messages -> {

    void testGetNTHash_null() {
        NullPointerException ex = assertThrows(NullPointerException.class, () -> NtlmUtil.getNTHash((String) null));
        assertEquals("Password parameter is required", ex.getMessage());
    }

    @ParameterizedTest
    @ValueSource(strings = { "", "password", "pässwörd", "1234567890abcdef" })
    @DisplayName("nTOWFv1 equals getNTHash across inputs")

                } catch (Exception e) {
                    logger.error(
                            delegate.getClass().getName() + " failed to setup class realm " + classRealm + ": "
                                    + e.getMessage(),
                            e);
                }
            }
        }
    }

    private void populateRealm(ClassRealm classRealm, List<ClassRealmConstituent> constituents) {

                        content = new String(InputStreamUtil.getBytes(entity.getContent()), Constants.UTF_8_CHARSET);
                    } catch (final IOException e) {
                        content = e.getMessage();
                    }
                    logger.warn("Failed to access to {}. The http status is {}.\n{}", tokenUrl, httpStatusCode, content);
                }
            });
        }