if c != test.a {
				t.Errorf("%v: overflow addition mutated source: %d", test, c)
			}
		}

		// addition is commutative
		c = test.b
		if ok := c.Add(test.a); ok != test.ok {
			t.Errorf("%v: unexpected ok: %t", test, ok)
		}
		if ok {
			if c != test.c {
				t.Errorf("%v: unexpected result: %d", test, c)
			}
		} else {
			if c != test.b {
				t.Errorf("%v: overflow addition mutated source: %d", test, c)
			}
		}

const a = 1e+500000000
const b = a * a // ERROR "constant multiplication overflow|not representable"
const c = b * b

const MaxInt512 = (1<<256 - 1) * (1<<256 + 1)
const _ = MaxInt512 + 1  // ERROR "constant addition overflow"
const _ = MaxInt512 ^ -1 // ERROR "constant bitwise XOR overflow"

import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestServiceRegistrar
import org.jetbrains.kotlin.test.services.TestServices

/**
 * Registers services specific to Standalone mode *tests*, in addition to the Standalone production services registered by
 * [FirStandaloneServiceRegistrar][org.jetbrains.kotlin.analysis.api.standalone.base.project.structure.FirStandaloneServiceRegistrar].
 */
@OptIn(KaAnalysisApiInternals::class)

    }

    interface Custom : ConfigureAccessor {
        val customAccessorIdentifier: String
    }

    interface ConfiguringLambdaArgument : ConfigureAccessor

    // TODO: configure all elements by addition key?
    // TODO: Do we want to support configuring external objects?

    }

    def "non-trivial addition (NormalizedPathFingerprintCompareStrategy)"() {
        expect:
        changes(NORMALIZED,
            ["new/one": fingerprint("one"), "new/two": fingerprint("two")],
            ["old/one": fingerprint("one")]
        ) == [added("new/two": "two")]
    }

    def "non-trivial addition with absolute paths (AbsolutePathFingerprintCompareStrategy)"() {

[short] skip
[compiler:gccgo] skip # gccgo has no cover tool
[!GOEXPERIMENT:coverageredesign] skip

go test -short -cover -covermode=atomic -coverpkg=coverdep/p1 coverdep

# In addition to the above, test to make sure there is no funny
# business if we try "go test -cover" in atomic mode targeting
# sync/atomic itself (see #57445). Just a short test run is needed
# since we're mainly interested in making sure the test builds and can

        regularFile("one", 0x1234)      | regularFile("two", 0x1234)
        missing("one")                  | missing("two")
        directoryWithTwoChildren("one") | directoryWithTwoChildren("two")
    }

    def "trivial addition of #current.type"() {
        expect:
        changes(
            FileSystemSnapshot.EMPTY,
            current
        ) == expectedChanges

        where:

	
	// also associated with s2
	s2() // line comment for s2
}
// associated with f1
// also associated with f1

// associated with f2

// f2
func f2() {
}

func f3() {
	i := 1 /* 1 */ + 2 // addition
	_ = i
}

// the very last comment
`

// res maps a key of the form "line number: node type"
// to the associated comments' text.
var res = map[string]string{

 */

package org.gradle.api.artifacts.dsl;

/**
 * The supported lock modes:
 * <ul>
 *     <li>{@code DEFAULT} will load the lock state and verify resolution matches it</li>
 *     <li>{@code STRICT} in addition to the {@code DEFAULT} behaviour, will fail resolution if a locked configuration does not have lock state defined</li>

	// Decorators is a list of admission decorator to wrap around the admission plugins
	Decorators admission.Decorators
}

// NewAdmissionOptions creates a new instance of AdmissionOptions
// Note:
//
//	In addition it calls RegisterAllAdmissionPlugins to register
//	all generic admission plugins.
//
//	Provides the list of RecommendedPluginOrder that holds sane values
//	that can be used by servers that don't care about admission chain.