import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;

/**
 * This class will allow a Java program to read and write data to Named
 * Pipes and Transact NamedPipes.
 *
 * <p>There are three Win32 function calls provided by the Windows SDK
 * that are important in the context of using jCIFS. They are:
 *
 * <ul>
 * <li> <code>CallNamedPipe</code> A message-type pipe call that opens,

		l.lockMap[args.Resources[0]] = ReadLock // No locks held on the given name, so claim (first) read lock
		reply = true
	} else if reply = locksHeld != WriteLock; reply { // Unless there is a write lock
		l.lockMap[args.Resources[0]] = locksHeld + ReadLock // Grant another read lock
	}
	return reply, nil
}

func (l *lockServer) RUnlock(args *LockArgs) (reply bool, err error) {

  }

  public void testNewDataInput_readUTF() {
    byte[] data = new byte[17];
    data[1] = 15;
    System.arraycopy("Kilroy was here".getBytes(UTF_8), 0, data, 2, 15);
    ByteArrayDataInput in = ByteStreams.newDataInput(data);
    assertThat(in.readUTF()).isEqualTo("Kilroy was here");
  }

  public void testNewDataInput_readChar() {
    byte[] data = "qed".getBytes(UTF_16BE);

        "Content-Type".equals(fieldName, ignoreCase = true)
  }
}

private fun Request.requestForCache(): Request {
  val cacheUrlOverride = cacheUrlOverride

  // Allow POST and QUERY caching only when there is a cacheUrlOverride
  return if (cacheUrlOverride != null && (HttpMethod.isCacheable(method) || method == "POST")) {
    newBuilder()
      .get()
      .url(cacheUrlOverride)
      .cacheUrlOverride(null)

 * the execute method.<br>
 * The implementation should have a <code>Mojo</code> annotation with the name of the goal:
 * <pre>
 *   &#64;Mojo( name = "&lt;goal-name&gt;" )
 * </pre>
 * <p>
 * There are also a number of attributes which can be used to control how and when the
 * <code>Mojo</code> is executed:
 * </p>
 * <table border="1">
 *  <caption>mojo annotation attributes</caption>
 *  <tr>

	for _, envK := range envs {
		// skip certain environment variables as part
		// of the whitelist and could be configured
		// differently on each nodes, update skipEnvs()
		// map if there are such environment values
		if _, ok := skipEnvs[envK]; ok {
			continue
		}
		envValues[envK] = logger.HashString(env.Get(envK, ""))
	}

    Files.copy(
      Paths.get(file(checkstyleConfig).getPath()),
      Paths.get(file(checkstyleIdeConfig).getPath()),
      StandardCopyOption.REPLACE_EXISTING
    )

    // There are some rules that we only want to enable in an IDE. These
    // are extracted to a separate file, and merged into the IDE-specific
    // Checkstyle config.
    Node xmlFragment = parseXml(checkstyleIdeFragment)

     * This means that trees/sessions/connections won't be idle-disconnected even if there are no other active
     * references (currently executing code, file descriptors).
     *
     * Depending on the usage scenario, this may have some benefit as there won't be any delays for restablishing these

		}
		return 0, cr.err
	}
	defer func() {
		if err != nil && err != io.EOF {
			if cr.debug {
				fmt.Println("Read err:", err)
			}
		}
	}()
	// First, if there is any unread data, copy it to the client
	// provided buffer.
	if cr.offset > 0 {
		n = copy(buf, cr.buffer[cr.offset:])
		if n == len(buf) {
			cr.offset += n
			return n, nil
		}
		cr.offset = 0

  }

  /**
   * Tests that the method {@code putEdge} will silently add the missing nodes to the graph, then
   * add the edge connecting them. We are not using the proxy methods here as we want to test {@code
   * putEdge} when the end-points are not elements of the graph.
   */
  @Test
  public void putEdge_nodesNotInGraph() {
    assume().that(graphIsMutable()).isTrue();