}

  void set_constant_value(Tensor constant_value) {
    DCHECK(IsEmpty());
    constant_value_ = std::move(constant_value);
    op_ = "Const";
  }

  void set_inputs(InputSeqMatcher inputs) {
    DCHECK(IsEmpty());
    input_matchers_ = std::move(inputs);
  }

  void set_control_deps(NodeSeqMatcher control_deps) {
    DCHECK(IsEmpty());

  std::vector<::testing::Matcher<OutEdge>> inputs_vector;
  absl::c_copy(inputs, std::back_inserter(inputs_vector));

  impl::NodeMatcherProperties props;
  props.set_inputs(std::move(inputs_vector));
  return props;
}

impl::NodeMatcherProperties impl::CtrlDeps(
    absl::Span<const ::testing::Matcher<const Node*>> control_deps) {

        @Managed
        interface BuildType {
            //Readonly
            CustomSourceSet getSources()

            //Read/write
            CustomSourceSet getInputs()
            void setInputs(CustomSourceSet sources)
        }

        class Rules extends RuleSource {
            @Model
            void buildType(BuildType buildType) { }
        }

        apply plugin: Rules

class ImmediateExecutionOperation : public AbstractOperation {
 public:
  virtual void Clear() = 0;

  // Returns the inputs of this op.
  virtual absl::Span<ImmediateExecutionTensorHandle* const> GetInputs()
      const = 0;
  virtual Status SetInput(size_t index,
                          ImmediateExecutionTensorHandle* input) = 0;

  virtual ImmediateExecutionContext* GetContext() const = 0;

        }

        public void setBuild_time(List<Long> build_time) {
            this.build_time = build_time;
        }

        public Map<String, List> getInputs() {
            return inputs;
        }

        public void setInputs(Map<String, List> inputs) {
            this.inputs = inputs;
        }

        @Override
        public String toString() {
            return "SwiftDeps{" +

        assertEquals("b2", itemList.get(1).getInputs()[1]);
        assertEquals("B1", itemList.get(1).getOutputs()[0]);
        assertFalse(itemList.get(1).isUpdated());

        assertEquals(1, itemList.get(2).getInputs().length);
        assertEquals(2, itemList.get(2).getOutputs().length);
        assertEquals("c1", itemList.get(2).getInputs()[0]);

                    ${previousVersionLeaksInternal ? "((TaskInputs)getInputs())" : "getInputs()"}.file("someFile");
                    ${previousVersionLeaksInternal ? "((TaskInputs)getInputs())" : "getInputs()"}.files("anotherFile", "yetAnotherFile");
                    ${previousVersionLeaksInternal ? "((TaskInputs)getInputs())" : "getInputs()"}.dir("someDir");
                    ${targetVersion >= GradleVersion.version("4.3")

        assertEquals(1, synonymItem.getId());
        assertEquals(2, synonymItem.getInputs().length);
        assertEquals("a", synonymItem.getInputs()[0]);
        assertEquals("A", synonymItem.getInputs()[1]);
        assertEquals(2, synonymItem.getOutputs().length);
        assertEquals("b", synonymItem.getOutputs()[0]);

    }

    @Override
    public NativeLibrarySpec getLibrary() {
        return getComponentAs(NativeLibrarySpec.class);
    }

    protected boolean hasSources() {
        for (LanguageSourceSet sourceSet : getInputs()) {
            if (!sourceSet.getSource().isEmpty()) {
                return true;
            }
            if (sourceSet.hasBuildDependencies()) {
                return true;
            }
        }

            public class MyTask extends DefaultTask {
                public MyTask() {
                    getInputs().file("somefile");
                    getInputs().files("afile", "anotherfile");
                    getInputs().dir("someDir");
                    getInputs();
                    getOutputs();
                }
            }
        """
        builder.buildJar(pluginJar)