argumentsSpec.setArgs(arguments);
        return this;
    }

    @Nullable
    @Override
    public List<String> getArgs() {
        return argumentsSpec.getArgs();
    }

    @Override
    public List<CommandLineArgumentProvider> getArgumentProviders() {
        return argumentsSpec.getArgumentProviders();
    }

    @Override

//===----------------------------------------------------------------------===//

mlir::LogicalResult PwStreamResultsOp::verify() {
  if (getArgs().size() != getNames().size()) {
    return emitOpError()
           << "has a mismatch between the number of arguments and their names ("
           << getArgs().size() << " vs. " << getNames().size() << ")";
  }
  return mlir::success();
}

    << ") cost(" << op->getAttrOfType<mlir::IntegerAttr>("_tfrt_cost").getInt()
    << ") device(" << op->getAttr("device") << ") " << op->getAttr("op_name")
    << '(' << op.getArgs() << ')';

  fallback_common::PrintExecuteOpCommon(p, op);
  fallback_common::PrintExecuteOpFuncAttribute(p, op);
  if (!op.getResults().empty()) p << " : " << op.getResults().size();
}

    }

    @Override
    default ExecSpec setArgs(Iterable<?> args) {
        getDelegate().setArgs(args);
        return this;
    }

    @Override
    default List<String> getArgs() {
        return getDelegate().getArgs();
    }

    @Override
    default List<CommandLineArgumentProvider> getArgumentProviders() {
        return getDelegate().getArgumentProviders();
    }

    @Override

    const std::unordered_set<std::string>& aggregator_ops_to_ignore,
    SmallVector<Value>& statistics_outputs, SmallVector<StringRef>& ids,
    SmallVector<int32_t>& calibration_methods) {
  for (auto op : region.getOps<TF::CustomAggregatorOp>()) {
    if (aggregator_ops_to_ignore.count(op.getId().str())) continue;

    ids.push_back(op.getId());
    calibration_methods.push_back(op.getCalibrationMethod());

            RequirementMatcher matcher = provides.get(key);

            if (matcher == null) {
                getLog().debug("Toolchain {} is missing required property: {}", this, key);
                return false;
            }
            if (!matcher.matches(requirement.getValue())) {
                getLog().debug("Toolchain {} doesn't match required property: {}", this, key);
                return false;
            }
        }

        assertEquals(
                p.getActivation().getOs().getArch(),
                clone.getActivation().getOs().getArch());
        assertEquals(
                p.getActivation().getOs().getFamily(),
                clone.getActivation().getOs().getFamily());
        assertEquals(
                p.getActivation().getOs().getName(),
                clone.getActivation().getOs().getName());
        assertEquals(

      component.Run(*module_op, quantization_config);

  EXPECT_THAT(pre_calibration_result, IsOk());

  SmallVector<func::FuncOp> func_ops;
  for (auto func_op : pre_calibration_result->getOps<func::FuncOp>()) {
    func_ops.push_back(func_op);
  }
  ASSERT_THAT(func_ops, SizeIs(2));
  EXPECT_THAT(func_ops, Contains(HasSymName("main")));

        platform.getOperatingSystem() >> new DefaultOperatingSystem(operatingSystem.name, operatingSystem)

        LinkerSpec spec = Mock(SharedLibraryLinkerSpec)
        spec.getSystemArgs() >> []
        spec.getArgs() >> []
        spec.getOutputFile() >> outputFile
        spec.getLibraries() >> []
        spec.getLibraryPath() >> []
        spec.getInstallName() >> "installName"
        spec.getTargetPlatform() >> platform

    }

    @Test
    @DisplayName("TEST 1")
    @Tag("my-tag")
    void test1(TestInfo testInfo) {
        assertEquals("TEST 1", testInfo.getDisplayName());
        assertTrue(testInfo.getTags().contains("my-tag"));
    }