isVersionLockFile(testFileLock, false)

        where:
        mode << [Shared, Exclusive]
    }

    @Requires(UnitTestPreconditions.NoMandatoryFileLockOnOpen)
    def "writes lock file with info region while exclusive lock is open"() {
        expect:
        def lock = createLock(Exclusive)
        isVersionLockFileWithInfoRegion(testFileLock, true)
        lock.writeFile {}

	}
	if err != nil {
		apiErr.Description = fmt.Sprintf("%s (%s)", apiErr.Description, err)
	}
	if region := globalSite.Region(); region != "" {
		if errCode == ErrAuthorizationHeaderMalformed {
			apiErr.Description = fmt.Sprintf("The authorization header is malformed; the region is wrong; expecting '%s'.", region)
			return apiErr
		}
	}
	return apiErr
}

  // IfRegion condition should always be a scalar. Select the region to fold to.
  bool cond = cond_attr.getSplatValue<BoolAttr>().getValue();
  Region& region = cond ? op.getThenBranch() : op.getElseBranch();

  // If the IfRegion is stateless but the region being inlined itself is not
  // stateless, then inlining the region could cause a loss of information.

// Sinks `tf.Const` operations in the ClusterOp region using them. This is
// performed in order to limit the number of values implicitly captured in this
// region before outlining.
std::unique_ptr<OperationPass<func::FuncOp>> CreateClusterConstantSinkingPass(
    llvm::function_ref<bool(tf_device::ClusterOp, ElementsAttr)> filter = {});

// Creates a pass that outlines regions of tf_device.cluster operations.

	// There are two implementations of move algorithm.
	// The first one for non-overlapped memory regions. It uses forward copying.
	// The second one for overlapped regions. It uses backward copying
	MOVQ	DI, CX
	SUBQ	SI, CX
	// Now CX contains distance between SRC and DEST
	CMPQ	CX, BX
	// If the distance lesser than region length it means that regions are overlapped
	JC	copy_backward

	// Non-temporal copy would be better for big sizes.

namespace mlir {
namespace mhlo {

// Builds body for reduce op by using the template binary op as the
// reducer op.
template <typename Op>
void BuildReduceBody(Type element_type, Region* body, OpBuilder* builder) {
  OpBuilder::InsertionGuard guard(*builder);
  Block* block = builder->createBlock(body);

  // Block arguments are scalars of the given element type.

		md[e.prefixName("vmId")] = aid
	}
	for k, v := range e.azureTags() {
		md[k] = v
	}
	return md
}

// Locality returns the region and zone
func (e *azureEnv) Locality() *core.Locality {
	var l core.Locality
	l.Region = e.azureLocation()
	l.Zone = e.azureZone()
	return &l
}

func (e *azureEnv) Labels() map[string]string {
	return map[string]string{}
}

class DeviceTarget {
 public:
  explicit DeviceTarget(MLIRContext* ctx);

  // Retrieves the kernel spec for the quant region op.
  std::optional<KernelSpec> GetKernelSpec(
      llvm::StringRef kernel, const KernelSpecs::Signature& signature) const;

  // Retrieves the scale decomposition function for the quant region op.
  ScaleDecomposeFn GetDecomposeFn(quantfork::QuantizeRegionOp op) const;

  // converts specification to signature:

	// AIX does not allow mapping a range that is already mapped.
	// So, call mprotect to change permissions.
	// Note that sysMap is always called with a non-nil pointer
	// since it transitions a Reserved memory region to Prepared,
	// so mprotect is always possible.
	_, err := mprotect(v, n, _PROT_READ|_PROT_WRITE)
	if err == _ENOMEM {
		throw("runtime: out of memory")
	}
	if err != 0 {

 * different types of failures.
 */
class ResolutionFailureHandlerIntegrationTest extends AbstractIntegrationSpec {
    // region resolution failures
    // region Graph Variant failures
    def "demonstrate ambiguous graph variant selection failure with single disambiguating value for project"() {
        ambiguousGraphVariantForProjectWithSingleDisambiguatingAttribute.prepare()