// 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]) == """\

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;

                        oneOf:
                          stringMatch:
                            exact: iss
                - metadata:
                    filter: istio_authn
                    path:
                    - key: request.auth.claims
                    - key: iss
                    value:
                      listMatch:
                        oneOf:
                          stringMatch:

		}
		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
	}