p.errorf("%s: expected integer constant; found %s", op, obj.Dconv(prog, addr))
	}
	return addr.Offset
}

// getRegister checks that addr represents a register and returns its value.
func (p *Parser) getRegister(prog *obj.Prog, op obj.As, addr *obj.Addr) int16 {
	if addr.Type != obj.TYPE_REG || addr.Offset != 0 || addr.Name != 0 || addr.Index != 0 {
		p.errorf("%s: expected register; found %s", op, obj.Dconv(prog, addr))
	}

				if GlobalKMS == nil {
					t.Errorf("Test %d: %s:  Expected the response status to be `%d`, but instead found `%d`", i, instanceType, testCase.expectedRespStatus, rec.Code)
					continue
				}
			} else {
				t.Errorf("Test %d: %s:  Expected the response status to be `%d`, but instead found `%d`", i, instanceType, testCase.expectedRespStatus, rec.Code)
				continue
			}
		}
		if rec.Code == http.StatusOK {

     *
     * @param responseData the response data containing the file to extract
     * @return the extractor instance for processing the file
     * @throws FessSystemException if no suitable extractor factory can be found
     */
    @Override
    protected Extractor getExtractor(final ResponseData responseData) {
        final ExtractorFactory extractorFactory = ComponentUtil.getExtractorFactory();
        if (extractorFactory == null) {

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file encapsulates some of the odd characteristics of the RISCV64
// instruction set, to minimize its interaction with the core of the
// assembler.

package arch

import (
	"cmd/internal/obj"
	"cmd/internal/obj/riscv"
	"fmt"
)

        sourceRoots.asSequence()
            .map { it.resolve(sourceFilePath) to it }
            .firstOrNull { it.first.isFile }
            ?: error("Source file '$sourceFilePath' not found, searched in source roots:\n  - ${sourceRoots.joinToString("\n  - ")}")

    private
    val KtFile.normalizedPath: String?
        get() = virtualFile.canonicalPath?.let { normaliseFileSeparators(it) }

    private

		return l, err
	}

	getCfgVal := func(cfgParam string) string {
		// As parameters are already validated, we skip checking
		// if the config param was found.
		val, _, _ := s.ResolveConfigParam(config.IdentityLDAPSubSys, config.Default, cfgParam, false)
		return val
	}

	ldapServer := getCfgVal(ServerAddr)
	if ldapServer == "" {
		return l, nil
	}

 * </ul>
 *
 * Produces the following:
 * <ul>
 * <li>A docbook book XML file containing the reference.</li>
 * <li>A meta-data file containing information about where the canonical documentation for each class can be found:
 * as dsl doc, javadoc or groovydoc.</li>
 * </ul>
 */
@CacheableTask
abstract class AssembleDslDocTask extends DefaultTask {
    @PathSensitive(PathSensitivity.NONE)
    @InputFile

                        log.trace("Found at " + link);
                    }
                    break;
                }

                // walk up trying to find a match, do not go up to the root
                final int nextSep = link.lastIndexOf('\\');
                if (nextSep <= 0) {
                    if (log.isTraceEnabled()) {
                        log.trace("Not found " + link);
                    }

    }

    /**
     * Gets the appropriate web API manager for the given request.
     *
     * @param request The HTTP servlet request
     * @return The matching web API manager, or null if no match found
     */
    public WebApiManager get(final HttpServletRequest request) {
        for (final WebApiManager webApiManager : webApiManagers) {
            if (webApiManager.matches(request)) {

                val latest = fetchVersionsFromMavenMetadata(metadataUrl)
                    .maxByOrNull { VersionNumber.parse(it) }
                    ?: error("No version found for plugin $pluginId")

                TestedVersion(pluginId, latest)
            }

    private
    fun updateProperties(fetchedVersions: List<TestedVersion>) = updateProperties {