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

        expect:
        PosixFilePermissionConverter.convertToInt(perms) == intValue

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

 * 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 =

        }

        /**
         * Returns the set of active {@linkplain Feature features}.
         */
        private static EnumSet<Feature> activeFeatures() {
            EnumSet<Feature> activeFeatures = EnumSet.noneOf(Feature.class);
            for (Feature feature : Feature.values()) {
                if (feature.isActive()) {
                    activeFeatures.add(feature);
                }
            }

		}
		for i := range s.ValueValidation.AnyOf {
			m.visitNestedValueValidation(&s.ValueValidation.AnyOf[i])
		}
		for i := range s.ValueValidation.OneOf {
			m.visitNestedValueValidation(&s.ValueValidation.OneOf[i])
		}
		if s.ValueValidation.Not != nil {
			m.visitNestedValueValidation(s.ValueValidation.Not)
		}
	}

	return ret
}

		if s, err = z.readString(); err != nil {
			return hdr, noEOF(err)
		}
		hdr.Name = s
	}

	if flg&flagComment != 0 {
		if s, err = z.readString(); err != nil {
			return hdr, noEOF(err)
		}
		hdr.Comment = s
	}

	if flg&flagHdrCrc != 0 {
		if _, err = io.ReadFull(z.r, z.buf[:2]); err != nil {
			return hdr, noEOF(err)
		}
		digest := le.Uint16(z.buf[:2])

		ret.AllOf = append(ret.AllOf, *v.AllOf[i].toKubeOpenAPI())
	}
	for i := range v.AnyOf {
		ret.AnyOf = append(ret.AnyOf, *v.AnyOf[i].toKubeOpenAPI())
	}
	for i := range v.OneOf {
		ret.OneOf = append(ret.OneOf, *v.OneOf[i].toKubeOpenAPI())
	}
	ret.Not = v.Not.toKubeOpenAPI()
}

func (vv *NestedValueValidation) toKubeOpenAPI() *spec.Schema {
	if vv == nil {
		return nil
	}