}

    private ArtifactSpec createArtifactSpec(String id, String version, String scope)
            throws InvalidVersionSpecificationException {
        return createArtifactSpec(id, version, scope, null, false);
    }

    private ArtifactSpec createArtifactSpec(
            String id, String version, String scope, String inheritedScope, boolean optional)

    }

    protected Map<String, String[]> parseQueryString(final String queryString, final String enc) throws IOException {
        final Map<String, List<String>> paramListMap = new HashMap<>();
        final String[] pairs = queryString.split("&");
        try {
            for (final String pair : pairs) {
                final int pos = pair.indexOf('=');
                if (pos >= 0) {

    private void assertNotContains(VersionConstraint c, String... versions) {
        assertContains(String.format("%s: %%s should not be contained\n", c.toString()), c, false, versions);
    }

    private void assertContains(String msg, VersionConstraint c, boolean b, String... versions) {
        for (String v : versions) {
            assertEquals(b, c.contains(versionParser.parseVersion(v)), String.format(msg, v));
        }
    }

                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                                "type": "array",
                                "title": "Location",
                            },
                            "msg": {"type": "string", "title": "Message"},
                            "type": {"type": "string", "title": "Error Type"},
                        },

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
                "HTTPValidationError": {

      return new Chopper() {
        @Override
        Optional<String> chop(String str) {
          return i.chop(str).or(you.chop(str));
        }
      };
    }

    abstract Optional<String> chop(String str);

    static Chopper suffix(String suffix) {
      return new Chopper() {
        @Override
        Optional<String> chop(String str) {
          if (str.endsWith(suffix)) {

      System.out.println(response.body().string());
    }
  }

  public static void main(String... args) throws Exception {
    new PreemptiveAuth().run();
  }

  static final class BasicAuthInterceptor implements Interceptor {
    private final String credentials;
    private final String host;

    BasicAuthInterceptor(String host, String username, String password) {

        this.childUrlSet = childUrlSet;
    }

    public String getEncoding() {
        return encoding;
    }

    public void setEncoding(final String encoding) {
        this.encoding = encoding;
    }

    @Override
    public String toString() {

 * to call ({@link #methodWithoutAnnotation(String)}).
 *
 * @author Cliff Biffle
 */
public class StringCatcher {
  private List<String> events = Lists.newArrayList();

  @Subscribe
  public void hereHaveAString(@Nullable String string) {
    events.add(string);
  }

  public void methodWithoutAnnotation(@Nullable String string) {
    Assert.fail("Event bus must not call methods without @Subscribe!");

     * @return the path to the resource (below share)
     */
    String getPath ();


    /**
     * 
     * @return the server name
     */
    String getServer ();


    /**
     * 
     * @return the domain name
     */
    String getDomain ();


    /**
     * 
     * @return the full UNC path
     */
    String getFullUNCPath ();


    /**
     * @param path
     */