return a.duration(), true
	}
	return 0, false
}

func (a Value) AsAny() (any, bool) {
	if a.Kind() == KindAny {
		return a.any, true
	}
	return nil, false
}

// Problem: adding a type means adding a method, which is a breaking change.
// Using an unexported method to force embedding will make programs compile,
// But they will panic at runtime when we call the new method.
type Visitor interface {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.declarativedsl.analysis

import org.gradle.declarative.dsl.model.annotations.Adding
import org.gradle.declarative.dsl.model.annotations.Restricted
import org.gradle.internal.declarativedsl.demo.resolve
import org.gradle.internal.declarativedsl.language.Assignment

It's quite common that issues with dependency management are about _transitive dependencies_.
Often developers incorrectly fix transitive dependency issues by adding _direct dependencies_.
To avoid this, Gradle provides the concept of _dependency constraints_.

[[sec:adding-constraints-transitive-deps]]
== Adding constraints on transitive dependencies

	return bto
}

// BootstrapTokenOptions is a wrapper struct for adding bootstrap token-related flags to a FlagSet
// and applying the parsed flags to a InitConfiguration object later at runtime
// TODO: In the future, we might want to group the flags in a better way than adding them all individually like this
type BootstrapTokenOptions struct {
	*bootstraptokenv1.BootstrapToken

         */
        @Nullable
        public Throwable getClientFailure() {
            return clientFailure;
        }

        /**
         * Returns a copy of this result adding the given failures.
         */
        public Result addFailures(List<Throwable> failures) {
            if (failures.isEmpty()) {
                return this;
            }

                    // Ensure parameters.outputFile is set before adding ourselves as a listener
                    if (!parameters.outputFile.present) {
                        throw new IllegalStateException("parameters.outputFile is not set")
                    }
                    loggingOutput = objects.newInstance(InternalServices).loggingOutput
                    println("ADDING " + this + " TO " + loggingOutput)

@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
public abstract class AbstractMultisetSetCountTester<E> extends AbstractMultisetTester<E> {
  /*
   * TODO: consider adding MultisetFeatures.SUPPORTS_SET_COUNT. Currently we
   * assume that using setCount() to increase the count is permitted iff add()
   * is permitted and similarly for decrease/remove(). We assume that a

 * (or {@link FluentFuture#transform(com.google.common.base.Function, Executor)
 * FluentFuture.transform}), but you will often find it easier to use a framework. Frameworks
 * automate the process, often adding features like monitoring, debugging, and cancellation.
 * Examples of frameworks include:
 *
 * <ul>
 *   <li><a href="https://dagger.dev/producers.html">Dagger Producers</a>
 * </ul>
 *

repositories {
    mavenCentral()
}

// tag::configure-suite-dependencies[]
testing {
    suites {
        test { // <1>
            dependencies {
                // Note that this is equivalent to adding dependencies to testImplementation in the top-level dependencies block
                implementation 'org.assertj:assertj-core:3.21.0' // <2>
                annotationProcessor 'com.google.auto.value:auto-value:1.9' // <3>

		},
	}

	c := newTypedXdsCache[uint64]()

	cache := c.(*lruCache[uint64])

	assert.Equal(t, cache.store.Len(), 0)
	assert.Equal(t, cache.indexLength(), 0)

	// adding the entry populates the indexes
	c.Add(firstEntry.Key(), firstEntry, req, res)

	assert.Equal(t, cache.store.Len(), 1)
	assert.Equal(t, cache.indexLength(), 2)