func(builder *IptablesRuleBuilder) {
				builder.AppendRuleV6(iptableslog.UndefinedCommand, "chain", "table", "-f", "foo", "-b", "bar")
				builder.AppendRuleV6(iptableslog.UndefinedCommand, "chain", "table", "-f", "fu", "-b", "bar")
				builder.AppendRuleV6(iptableslog.UndefinedCommand, "chain", "table", "-f", "foo", "-b", "baz")
			},
			true,
		},
		{
			"insert-multi-v4",
			true,
			false,

      /*strides=*/Create1DConstValue<int32_t>(builder, loc, {1}),
      /*begin_mask=*/builder.getIntegerAttr(attribute_type, 0),
      /*end_mask=*/builder.getIntegerAttr(attribute_type, 0),
      /*ellipsis_mask=*/builder.getIntegerAttr(attribute_type, 0),
      /*new_axis_mask=*/builder.getIntegerAttr(attribute_type, 0),
      /*shrink_axis_mask=*/builder.getIntegerAttr(attribute_type, 1));
}

        builder.measuredBuildOperations.addAll(measuredBuildOperations)
        builder.measureGarbageCollection(measureGarbageCollection)
        builder.invocation.distribution(gradleDistribution)
    }

    protected void configureAndAddSpec(BuildExperimentSpec.Builder builder, Closure<?> configureAction) {
        defaultSpec(builder)
        builder.with(configureAction as Closure<Object>)

        builder.start(root)

        builder.visitNode(root)
        builder.visitNode(conf1)
        builder.visitNode(conf2)
        builder.visitNode(node(3, "org", "dep2", "1.0"))
        builder.visitNode(node(4, "org", "dep3", "1.0"))

        builder.visitSelector(selector1)
        builder.visitSelector(selector2)
        builder.visitSelector(selector3)

        spec.sourceCompatibility = "1.7"

        when:
        builder.includeMainOptions(true)

        then:
        builder.build() == ["-source", "1.7"] + defaultOptions

        when:
        builder.includeMainOptions(false)

        then:
        builder.build() == ["-classpath", ""]
    }

    def "includes main options by default"() {

        Model model = Model.newInstance();
        Model.Builder builder = Model.newBuilder(model);
        modelMerger.mergeModel_ModelVersion(builder, model, parent, false, null);
        assertNull(builder.build().getModelVersion());

        model = Model.newBuilder().modelVersion("5.0.0").build();
        builder = Model.newBuilder(model);
        modelMerger.mergeModel_ModelVersion(builder, model, parent, false, null);

    ImmutableListMultimap.Builder<K, V> builder = ImmutableListMultimap.builder();
    builder.put(k1, v1);
    builder.put(k2, v2);
    builder.put(k3, v3);
    builder.put(k4, v4);
    builder.put(k5, v5);
    return builder.build();
  }

  // looking for of() with > 5 entries? Use the builder instead.

  /**
   * Returns a new builder. The generated builder is equivalent to the builder created by the {@link

    const AttrValue& value, mlir::Builder* builder) {
  switch (value.value_case()) {
    case AttrValue::kI:
      return builder->getI64IntegerAttr(value.i());
    case AttrValue::kS:
      return builder->getStringAttr(value.s());
    case AttrValue::kF:
      return builder->getFloatAttr(builder->getF32Type(), value.f());
    case AttrValue::kB:
      return builder->getBoolAttr(value.b());
    case AttrValue::kType: {

                          GetIndicesForElement(index, buffer, builder, loc)})
      .getOutput();
}

TensorType GetSizeType(OpBuilder builder) {
  return tensorflow::GetTypeFromTFTensorShape({1}, builder.getIntegerType(32));
}

Value ReshapeScalarToSizeType(OpBuilder builder, Value scalar, Location loc) {
  auto size_type = GetSizeType(builder);
  return builder.create<TF::ReshapeOp>(
      loc, ArrayRef<Type>{size_type},

        expect:
        loadBuildEnvironment { builder -> builder.addJvmArguments() }
    }

    def "Adding null JVM argument throws NPE"() {
        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as String) }

        then:
        thrown(NullPointerException)

        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as List) }

        then: