}

  public void testForStringIPv4Input() throws UnknownHostException {
    String ipStr = "192.168.0.1";
    // Shouldn't hit DNS, because it's an IP string literal.
    InetAddress ipv4Addr = InetAddress.getByName(ipStr);
    assertEquals(ipv4Addr, InetAddresses.forString(ipStr));
    assertTrue(InetAddresses.isInetAddress(ipStr));
  }

  public void testForStringIPv4NonAsciiInput() throws UnknownHostException {

 *
 * @author Nishant Thakkar
 * @author Sven Mawson
 */
public class ExecutionListTest extends TestCase {

  private final ExecutionList list = new ExecutionList();

  public void testRunOnPopulatedList() throws Exception {
    Executor exec = Executors.newCachedThreadPool();
    CountDownLatch countDownLatch = new CountDownLatch(3);
    list.add(new MockRunnable(countDownLatch), exec);

    public Path getPath() {
        return path;
    }

    public void merge(File existing, File result) throws RepositoryException {
        merge(existing != null ? existing.toPath() : null, result != null ? result.toPath() : null);
    }

    @Override
    public void merge(Path existing, Path result) throws RepositoryException {
        Metadata recessive = read(existing);

        merge(recessive);

        this.resolutionErrorHandler = resolutionErrorHandler;
    }

    public Set<Artifact> resolve(MavenProject project, Collection<String> scopesToResolve, MavenSession session)
            throws ArtifactResolutionException, ArtifactNotFoundException {
        return resolve(Collections.singleton(project), scopesToResolve, session);
    }

    public Set<Artifact> resolve(
            MavenProject project,

        this.repositorySystem = repositorySystem;
    }

    @Override
    public MavenExecutionRequest populateFromToolchains(MavenExecutionRequest request, PersistedToolchains toolchains)
            throws MavenExecutionRequestPopulationException {
        if (toolchains != null) {
            Map<String, List<ToolchainModel>> groupedToolchains = new HashMap<>(2);

            throws InvalidRepositoryException {
        return buildArtifactRepository(repo, artifactRepositoryFactory, c);
    }

    public static ArtifactRepository buildArtifactRepository(
            Repository repo, ArtifactRepositoryFactory artifactRepositoryFactory, PlexusContainer c)
            throws InvalidRepositoryException {
        RepositorySystem repositorySystem = rs(c);

    }

    protected void createLocalArtifact(Artifact artifact) throws Exception {
        createArtifact(artifact, localRepository());
    }

    protected void createRemoteArtifact(Artifact artifact) throws Exception {
        createArtifact(artifact, remoteRepository());
    }

    protected void createArtifact(Artifact artifact, ArtifactRepository repository) throws Exception {
        String path = repository.pathOf(artifact);

/**
 * @author shinsuke
 *
 */
public class FileSystemClientTest extends PlainTestCase {
    public FileSystemClient fsClient;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("mimeTypeHelper", MimeTypeHelperImpl.class)//
                .singleton("fsClient", FileSystemClient.class);

        this.handle = handle;
        if (server == null)
            server = "\\\\";
        MsrpcLsarOpenPolicy2 rpc = new MsrpcLsarOpenPolicy2(server, access, this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0)
            throw new SmbException(rpc.retval, false);
    }

    public void close() throws IOException {

                SID[] sids) throws IOException {
        MsrpcLookupSids rpc = new MsrpcLookupSids(policyHandle, sids);
        handle.sendrecv(rpc);
        switch (rpc.retval) {
            case 0:
            case NtStatus.NT_STATUS_NONE_MAPPED:
            case 0x00000107: // NT_STATUS_SOME_NOT_MAPPED
                break;
            default:
                throw new SmbException(rpc.retval, false);
        }