index_select.getOnFalse() != body.getArgument(3))
    return failure();

  mhlo::OrOp index_or = llvm::dyn_cast_or_null<mhlo::OrOp>(
      index_select.getPred().getDefiningOp());

  if (!index_or || index_or.getLhs() != value_select.getPred())
    return failure();

  mhlo::AndOp index_and =
      llvm::dyn_cast_or_null<mhlo::AndOp>(index_or.getRhs().getDefiningOp());
  if (!index_and) return failure();

        return getTree().first(displayName)
    }

    @Override
    List<BuildOperationRecord> all() {
        return getTree().all()
    }

    @Override
    List<BuildOperationRecord> all(Pattern displayName) {
        return getTree().all(displayName)
    }

    @Override
    BuildOperationRecord only(Pattern displayName) {
        return getTree().only(displayName)
    }

    @Override

        contentFile.write("content");
        archiveFileToRoot(getArchiveFile());

        assertVisits(getTree(), toList("file1.txt"), new ArrayList<>());
        contentFile.makeOlder();
        TestFile.Snapshot snapshot = contentFile.snapshot();
        assertVisits(getTree(), toList("file1.txt"), new ArrayList<>());
        contentFile.assertHasNotChangedSince(snapshot);
    }

    @Test

    @Override
    protected TestFile getArchiveFile() {
        return archiveFile;
    }

    @Override
    protected ZipFileTree getTree() {
        return tree;
    }

    @Test
    public void failsWhenArchiveFileDoesNotExist() {
        try {
            getTree().visit(new EmptyFileVisitor());
            fail();
        } catch (InvalidUserDataException e) {

        snapshot.getPhysicalMemory().getFree() == MemoryAmount.ofGigaBytes(16).bytes
        snapshot.getVirtualMemory() instanceof OsMemoryStatusAspect.Available
        snapshot.getVirtualMemory().getTotal() == MemoryAmount.ofGigaBytes(64).bytes
        snapshot.getVirtualMemory().getFree() == MemoryAmount.ofGigaBytes(16).bytes
    }

        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.versionedGraph)) {
            return new MetadataGraph(getTree(), true, false);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.scopedGraph)) {
            return new MetadataGraph(getTree(), true, true);
        }
        return null;
    }
    // ----------------------------------------------------------------------------

     * where backwards compatibility is required and instead prefer {@link #inject(ServiceLookup)} for any new non DSL-types.
     * This method will be retired in the future.
     */
    InstanceGenerator injectLenient(ServiceLookup services);

    /**

        } catch (UnsupportedOperationException e) {
            return cGroupDelegate;
        }

        long cGroupFreeMemory = cGroupSnapshot.getPhysicalMemory().getFree();
        long memInfoFreeMemory = memInfoSnapshot.getPhysicalMemory().getFree();

        return cGroupFreeMemory > memInfoFreeMemory ? memInfoDelegate : cGroupDelegate;
    }

    @Override
    public OsMemoryStatus getOsSnapshot() {

        def free = osMemoryInfo.getOsSnapshot().getPhysicalMemory().getFree()

        then:
        free == TEST_FREE_MEMORY
    }

    def "getFreePhysicalMemory fails when memory MBeans are #availability"() {
        given:
        def osMemoryInfo = createMemoryInfo(availability)

        when:
        osMemoryInfo.getOsSnapshot().getPhysicalMemory().getFree()

        then:
        thrown UnsupportedOperationException

			// work on a copy of the watchedFiles map, so that we don't interfere
			// with the caller's use of the map
			for path, ft := range wk.getTrackers() {
				if ft.events == nil {
					// tracker has been retired, skip it
					continue
				}

				sum := getHashSum(path)
				if !bytes.Equal(sum, ft.hash) {
					ft.hash = sum

					select {
					case ft.events <- event:
						// nothing to do