return success();
}

void TPUReorderReplicateAndPartitionedInputsPass::runOnOperation() {
  auto result =
      getOperation()->walk([](TF::TPUReplicatedInputOp replicated_input) {
        if (llvm::none_of(replicated_input.getInputs(), [](Value input) {
              return llvm::isa_and_nonnull<TF::TPUPartitionedInputV2Op>(
                  input.getDefiningOp());
            }))
          return WalkResult::advance();

  // dependency from the oprands of the op to the current cluster.
  llvm::SetVector<Operation*> ops_depend_on_cluster =
      GetAllOpsDependOnCluster(c, op_to_cluster_map);
  return llvm::none_of(to_merge->getOperands(), [&](Value value) {
    Operation* defining_op = value.getDefiningOp();
    return defining_op && ops_depend_on_cluster.contains(defining_op);
  });
}
}  // namespace

  // don't need to consider ".source"/".Source" because the nodes with this
  // suffix are skipped by the caller and will not be added to the graph.
  auto prefixes = GlobalOpPrefixes();
  if (std::none_of(prefixes->begin(), prefixes->end(), [&](std::string prefix) {
        return op_name.consume_front(prefix);
      })) {
    return errors::FailedPrecondition("op node '", op_name.str(),

      return changed;
    }
  }
  return changed;
}

bool ShapeInference::RefineWithInferTypeOpInterface(
    InferTypeOpInterface infer_ti) {
  Operation* op = infer_ti.getOperation();
  if (none_of(op->getResultTypes(), CanBeRefined)) {
    LLVM_DEBUG(llvm::dbgs() << "Skipping inference for statically shaped op '"
                            << op->getName() << "'.\n");
    return false;
  }

      }
    }

    int buffer_index = buffers_.size();
    // If a constant is returned as subgraph's output, this constant cannot be
    // deduplicated.
    const bool not_returned_by_subgraph = llvm::none_of(
        value.getUsers(),
        [](Operation* user) { return llvm::isa<mlir::func::ReturnOp>(user); });
    // TODO(ashwinm): Check if for stateful tensors, if it is also needed to

        expect:
        PosixFilePermissionConverter.convertToInt(perms) == intValue

        where:
        perms                                                                |       intValue
        EnumSet.noneOf(PosixFilePermission)                                  |       0
        EnumSet.allOf(PosixFilePermission)                                   |       0777

        Caused by:
        java.lang.RuntimeException: oops
"""
    }

    def "optionally shows stack traces"() {
        testLogging.getShowStackTraces() >> true
        testLogging.getStackTraceFilters() >> EnumSet.noneOf(TestStackTraceFilter)
        def exception = new Exception("ouch")
        exception.stackTrace = createStackTrace()

        expect:
        formatter.format(testDescriptor, [exception]) == """\

 * limitations under the License.
 */

package org.gradle.api.internal

class FeaturePreviewsActivationFixture {

    static def activeFeatures() {
        EnumSet<FeaturePreviews.Feature> active = EnumSet.noneOf(FeaturePreviews.Feature)
        for (FeaturePreviews.Feature feature : FeaturePreviews.Feature.values()) {
            if (feature.isActive()) {
                active.add(feature)
            }
        }
        active

import static org.gradle.util.internal.GUtil.toEnum;
import static org.gradle.util.internal.GUtil.toEnumSet;

public class DefaultTestLogging implements TestLogging {
    private Set<TestLogEvent> events = EnumSet.noneOf(TestLogEvent.class);
    private int minGranularity = -1;
    private int maxGranularity = -1;
    private int displayGranularity = 2;
    private boolean showExceptions = true;
    private boolean showCauses = true;

import java.util.*


enum class EvalOption {
    IgnoreErrors,
    SkipBody
}


typealias EvalOptions = EnumSet<EvalOption>


internal
val defaultEvalOptions: EvalOptions =