return null;
        }

        List<MetadataGraphEdge> res = new ArrayList<>(edges.size());

        for (MetadataGraphEdge e : edges) {
            if (e.getSource().equals(vFrom)) {
                res.add(e);
            }
        }

        return res;
    }
    // ------------------------------------------------------------------------

        TransferResource resource = event.getResource();
        StringBuilder message = new StringBuilder();
        message.append(action).append(' ').append(direction).append(' ').append(resource.getRepositoryId());
        message.append(": ");
        message.append(resource.getRepositoryUrl()).append(resource.getResourceName());

        out.info(message.toString());
    }

        TransferResource resource = event.getResource();
        MessageBuilder message = messageBuilderFactory.builder();
        message.style(STYLE).append(action).append(' ').append(direction).append(' ');
        message.resetStyle().append(resource.getRepositoryId());
        message.style(STYLE).append(": ").append(resource.getRepositoryUrl());
        message.resetStyle().append(resource.getResourceName());

            TransferEvent transferInitiatedEvent = event(session, resource, TransferEvent.EventType.INITIATED);
            TransferEvent transferStartedEvent = event(session, resource, TransferEvent.EventType.STARTED);
            TransferEvent transferProgressedEvent = event(session, resource, TransferEvent.EventType.PROGRESSED);
            TransferEvent transferSucceededEvent = event(session, resource, TransferEvent.EventType.SUCCEEDED);

            // Given
            SmbResource resource = createMockResource();
            when(resource.exists()).thenReturn(true);
            when(resource.isFile()).thenReturn(true);
            when(resource.canWrite()).thenReturn(true);

            // When/Then
            assertTrue(resource.exists(), "Resource should exist");
            assertTrue(resource.isFile(), "Should be a file");

    private ArtifactTransferResource wrap(Repository repository, Resource resource) {
        if (resource == null) {
            return null;
        } else {
            synchronized (artifacts) {
                ArtifactTransferResource artifact = artifacts.get(resource);

                if (artifact == null) {
                    artifact = new MavenArtifact(repository.getUrl(), resource);
                    artifacts.put(resource, artifact);

	}

	defer l.getMutex()()

	for _, resource := range args.Resources {
		lri, ok := l.lockMap[resource]
		if ok && !isWriteLock(lri) {
			// Unless it is a write lock reject it.
			err = fmt.Errorf("unlock attempted on a read locked entity: %s", resource)
			continue
		}
		if ok {
			reply = l.removeEntry(resource, args, &lri) || reply
		}
	}
	return reply, err
}

    public void setSource(String source) {
        getDelegate().setSource(source);
    }

    public String getSource() {
        return getDelegate().getSource();
    }

    /**
     * @see java.lang.Object#toString()
     */
    public String toString() {
        return "Profile {id: " + getId() + ", source: " + getSource() + "}";
    }
            ]]>

        } catch (final MissingResourceException ignore) {
            return null;
        }
    }

    /**
     * Returns the string for the specified key from the resource bundle.
     *
     * @param bundle the resource bundle (must not be {@literal null} or empty)
     * @param key the key
     * @return the string for the specified key (must not be {@literal null} or empty)

		locksHeld[resource] = []lockRequesterInfo{lri}
	}

	// Add a few concurrent read locks to the mix
	for i := range 50 {
		resource := fmt.Sprintf("bucket/get-object-%d", i)
		lri := lockRequesterInfo{
			Name:   resource,
			UID:    mustGetUUID(),
			Owner:  owners[i%len(owners)],
			Quorum: 2,
		}
		lris = append(lris, lri)
		locksHeld[resource] = append(locksHeld[resource], lri)