assertEquals("MatchAllDocsQuery", className);
        assertEquals(MatchAllDocsQuery.class.getSimpleName(), className);
    }

    @Test
    public void test_execute() {
        // Test execute method with normal parameters
        QueryContext context = new QueryContext("*:*", false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();
        float boost = 1.0f;

     * This method will attempt
     * to resolve SIDs using a cache and cache the results of any SIDs that
     * required resolving with the authority. SID cache entries are currently not
     * expired because under normal circumstances SID information never changes.
     *
     * @param authorityServerName
     *            The hostname of the server that should be queried. For maximum efficiency this should be the hostname

    whole or in part contains or is derived from the Program or any part
    thereof, to be licensed as a whole at no charge to all third parties
    under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an

		if err != nil {
			return nil, err
		}
		res[userDistName] = set.CreateStringSet(groups...)
	}

	return res, nil
}

// QuickNormalizeDN - normalizes the given DN without checking if it is valid or
// exists in the LDAP directory. Returns input if error
func (l Config) QuickNormalizeDN(dn string) string {
	if normDN, err := xldap.NormalizeDN(dn); err == nil {

      /*
       * TODO(cpovirk): Do we really want to log this if we called setException(throwable) and it
       * returned true? This was intentional (CL 46470009), but it seems odd compared to how we
       * normally handle Error.
       *
       * Similarly, do we really want to log the same Error more than once?
       */
      log(throwable);
    }
  }

  private static void log(Throwable throwable) {

    assertThat(simplifyPath("/a/b/c/g;x=1/./y")).isEqualTo("/a/b/c/g;x=1/y");
    assertThat(simplifyPath("/a/b/c/g;x=1/../y")).isEqualTo("/a/b/c/y");
  }

  /** http://gbiv.com/protocols/uri/rfc/rfc3986.html#relative-normal */
  public void testRfc3986Normal() {
    assertThat(simplifyPath("/a/b/c/g")).isEqualTo("/a/b/c/g");
    assertThat(simplifyPath("/a/b/c/./g")).isEqualTo("/a/b/c/g");

    assertThat(simplifyPath("/a/b/c/g;x=1/./y")).isEqualTo("/a/b/c/g;x=1/y");
    assertThat(simplifyPath("/a/b/c/g;x=1/../y")).isEqualTo("/a/b/c/y");
  }

  /** http://gbiv.com/protocols/uri/rfc/rfc3986.html#relative-normal */
  public void testRfc3986Normal() {
    assertThat(simplifyPath("/a/b/c/g")).isEqualTo("/a/b/c/g");
    assertThat(simplifyPath("/a/b/c/./g")).isEqualTo("/a/b/c/g");

        String api = "foo.json"
        String test = "10_basic.yml"
        //add the compatible test and api files, these are the prior version's normal yaml rest tests
        file("distribution/bwc/minor/checkoutDir/rest-api-spec/src/main/resources/rest-api-spec/api/" + api) << ""

		"policy":    encodedPolicy,
		"signature": signature,
	}

	maps.Copy(formData, formInputData)

	// Create the multipart form.
	var buf bytes.Buffer
	w := multipart.NewWriter(&buf)

	// Set the normal formData
	for k, v := range formData {
		w.WriteField(k, v)
	}
	// Set the File formData
	writer, err := w.CreateFormFile("file", "upload.txt")
	if err != nil {
		// return nil, err
		return nil, err

          <version>1.0.0+</version>
          <type>String</type>
          <description>
            The configurator type to use when injecting parameter values into this Mojo. The value is normally deduced
            from the Mojo's implementation language, but can be specified to allow a custom ComponentConfigurator
            implementation to be used.
          </description>
        </field>
        <field>