for (int j = 0; j < max; j++) {
                final int i = dcListCounter++ % max;
                if (this.dcList[i] != null) {
                    try {
                        return interrogate(getTransportContext(), this.dcList[i]);
                    } catch (final SmbException se) {
                        log.warn("Failed validate DC: " + this.dcList[i], se);
                    }

    static NbtAddress[] dc_list = null;
    static long dc_list_expiration;
    static int dc_list_counter;

    private static NtlmChallenge interrogate(final NbtAddress addr) throws SmbException {
        final UniAddress dc = new UniAddress(addr);
        final SmbTransport trans = SmbTransport.getSmbTransport(dc, 0);
        if (USERNAME == null) {

                    fileString = interpolator.interpolate(fileString, "").replace("\\", "/");
                    File file = new File(fileString);
                    return !file.exists();
                }
            } catch (InterpolationException e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to interpolate missing file location for profile activator: " + fileString, e);

    public StringSearchModelInterpolator() {}

    public StringSearchModelInterpolator(PathTranslator pathTranslator) {
        super(pathTranslator);
    }

    @Override
    public Model interpolate(Model model, File projectDir, ProjectBuilderConfiguration config, boolean debugEnabled)
            throws ModelInterpolationException {
        interpolateObject(model, model, projectDir, config, debugEnabled);

    }

    @Override
    public MavenOptions interpolate(UnaryOperator<String> callback) {
        ArrayList<MavenOptions> interpolatedOptions = new ArrayList<>(options.size());
        for (MavenOptions o : options) {
            interpolatedOptions.add((MavenOptions) o.interpolate(callback));
        }
        return layerMavenOptions(interpolatedOptions);
    }

import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
import org.junit.jupiter.api.Test;

class StringSearchModelInterpolatorTest {

    @Test
    void interpolate() throws ModelInterpolationException, InitializationException {
        Model model = Model.newBuilder()
                .groupId("group")
                .location("groupId", InputLocation.of(InputSource.of("model", null)))

        assertViolations(result, 0, 0, 2);

        assertEquals(
                "'profiles.profile[exists-project-version].activation.file.exists' "
                        + "Failed to interpolate profile activation property ${project.version}/test.txt: "
                        + "${project.version} expressions are not supported during profile activation.",
                result.getWarnings().get(0));

                    Path tmpPom = Files.createTempFile("pom-inliner-", ".xml");
                    String originalPom = Files.readString(artifact.getPath());
                    String interpolatedPom = interpolator.interpolate(
                            originalPom,
                            property -> {
                                if (needsInlining.contains(property)) {
                                    return (String)

        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    public interface ContentTransformer {
        /**
         * Interpolate the value read from the xpp3 document
         * @param source The source value
         * @param fieldName A description of the field being interpolated. The implementation may use this to

      // index * (dataset.length - 1) / scale. If there is no remainder, we can just find the value
      // whose index in the sorted dataset equals the quotient; if there is a remainder, we
      // interpolate between that and the next value.

      // Since index and (dataset.length - 1) are non-negative ints, their product can be expressed
      // as a long, without risk of overflow: