auto casted =
            rewriter.create<CastOp>(loc, unconstrainted_type, new_res);
        tensor_list.push_back(casted.getOut());
      }
      auto list_op = rewriter.create<BuildListOp>(loc, res_type, tensor_list);
      new_results.push_back(list_op.getOut());
    }
  }

  // Copy all the allowed attributes to the new op.
  if (failed(CopyNonSymbolRefAttrs(call_op, new_op))) return failure();

                pomConfiguration = plugin.getDelegate().getConfiguration();
            }

            XmlNode mojoConfiguration = mojoExecution.getConfiguration() != null
                    ? mojoExecution.getConfiguration().getDom()
                    : null;

            XmlNode mergedConfiguration = XmlNodeImpl.merge(mojoConfiguration, pomConfiguration);

            mojoExecution.setConfiguration(mergedConfiguration);

    public String getGoal() {
        return delegate.getGoal();
    }

    @Override
    public Optional<XmlNode> getConfiguration() {
        return Optional.of(delegate.getConfiguration()).map(Xpp3Dom::getDom);
    }

    @Override
    public String toString() {
        return delegate.toString();
    }

        }
    }

    private void appendJvmStats(final StringBuilder buf) {
        buf.append("\"jvm\":{");
        final JvmStats jvmStats = JvmStats.jvmStats();
        final Mem mem = jvmStats.getMem();
        buf.append("\"memory\":{");
        buf.append("\"heap\":{");
        append(buf, "used", () -> mem.getHeapUsed().getBytes()).append(',');

	var err error
	if cfg != nil {
		certs := []string{}
		endpoints := []string{}
		for _, pemCert := range cfg.GetCaCertificates() {
			cert := pemCert.GetPem()
			if cert != "" {
				certs = append(certs, cert)
			} else if pemCert.GetSpiffeBundleUrl() != "" {
				endpoints = append(endpoints, pemCert.GetSpiffeBundleUrl())
			}
		}

            stream(parameter.getSuggestFields()).of(stream -> stream.forEach(builder::addField));
            roleQueryHelper.build(SearchRequestType.SUGGEST).stream().forEach(builder::addRole);
            builder.setSize(parameter.getNum());
            stream(langs).of(stream -> stream.forEach(builder::addLang));

            stream(parameter.getTags()).of(stream -> stream.forEach(builder::addTag));

            statement.setString(6, results.getVersionUnderTest());
            statement.setString(7, results.getOperatingSystem());
            statement.setString(8, results.getJvm());
            statement.setString(9, results.getVcsBranch());
            statement.setString(10, Joiner.on(",").join(results.getVcsCommits()));
            statement.setString(11, results.getTestGroup());

        Model out = interpolator.interpolateModel(model, new File("."), createModelBuildingRequest(context), collector);

        assertProblemFree(collector);
        assertEquals("${test}/somepath", out.getScm().getConnection());
    }

    @Test
    public void testShouldThrowExceptionOnRecursiveScmConnectionReference() throws Exception {
        Scm scm = Scm.newBuilder()

                textCell(results.getVersionUnderTest());
                textCell(results.getOperatingSystem());
                textCell(results.getHost());
                textCell(results.getJvm());
                textCell(results.getTestProject());
                textCell(results.getTasks());
                textCell(results.getCleanTasks());
                textCell(results.getArgs());

        copy.setGoals(original.getGoals());
        copy.setRecursive(original.isRecursive());
        copy.setPom(original.getPom());
        copy.setSystemProperties(original.getSystemProperties());
        copy.setUserProperties(original.getUserProperties());
        copy.setShowErrors(original.isShowErrors());