}

    def "can get by name before element is present and query after realized"() {
        def binary1 = Stub(SwiftBinary)
        binary1.name >> "test1"

        expect:
        def p = container.getByName("test1")
        !p.present

        container.add(binary1)

        !p.present

        container.realizeNow()

        p.present
        p.get() == binary1
    }

        instant.invalidated < instant.snapshottingFinished
        !vfs.findSnapshot(location).present
        !vfs.findSnapshot("${location}/some/child").present
        !vfs.findSnapshot("${location}/some/child2").present
        vfs.findSnapshot("${location}/other/child").present
        vfs.findSnapshot("${location}/other/child2").present
    }

    def "does not store snapshot when invalidate all happened in between"() {

    }

    def "can map to provider that uses value if present or a default value"() {
        expect:
        def present = providerWithValue(someValue())
        def usesValue = present.orElse(someOtherValue())
        usesValue.present
        usesValue.get() == someValue()

        def notPresent = providerWithNoValue()

        given:
        if (applied) {
            applyPlugin()
        }

        settingsFile << """
            println "present: " + services.get($GradleEnterprisePluginManager.name).present
        """

        when:
        succeeds "t"

        then:
        output.contains("present: ${applied}")

        where:
        applied << [true, false]
    }

};

// Extracts `_tpu_embedding_layer` attribute from TPU embedding ops and
// clear the attribute from the operation. This ensures that future optimization
// passes does not trigger additional logic due to presence of this attribute.
LogicalResult ExtractEmbeddingAttribute(
    Operation* op, llvm::StringMap<Operation*>* embedding_op_map) {
  auto embedding_attr = op->getAttrOfType<StringAttr>(kTPUEmbeddingAttr);

        expect:
        def mapped = provider.map(transformer)
        !mapped.present
        mapped.getOrNull() == null
        mapped.getOrElse("s2") == "s2"

        provider.value("abc")
        mapped.present
        mapped.get() == "[abc]"

        provider.value(null)
        !mapped.present

        provider.value("123")
        mapped.present
        mapped.get() == "[123]"
    }

  /**
   * Adds {@code node} if it is not already present.
   *
   * <p><b>Nodes must be unique</b>, just as {@code Map} keys must be. They must also be non-null.
   *
   * @return {@code true} if the graph was modified as a result of this call
   */
  @CanIgnoreReturnValue
  boolean addNode(N node);

  /**
   * Adds an edge connecting {@code nodeU} to {@code nodeV} if one is not already present.
   *

        dirVar.get().getAsFile() == otherDir
        fileProvider.present
        fileProvider.get() == otherDir

        dirVar.set((File) null)
        !dirVar.present
        dirVar.getOrNull() == null
        !fileProvider.present
        fileProvider.getOrNull() == null
    }

    def "can create regular file property"() {
        def pathProvider = Stub(ProviderInternal)
        _ * pathProvider.get() >> { "../some-file" }

            "description": "path is matched against the path of an incoming request. Currently it can contain characters disallowed from the conventional \"path\" part of a URL as defined by RFC 3986. Paths must begin with a '/' and must be present when using PathType with value \"Exact\" or \"Prefix\".",
            "type": "string"
          },
          "pathType": {

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_occurrences_present() {
    assertEquals(
        "multiset.remove(present, 2) didn't return the old count",
        1,
        getMultiset().remove(e0(), 2));
    assertFalse(
        "multiset contains present after multiset.remove(present, 2)",
        getMultiset().contains(e0()));
    assertEquals(0, getMultiset().count(e0()));
  }

  @CollectionSize.Require(SEVERAL)