* reference has been cleared and one {@code finalize} method has been run before this method
   * returns. This method may be useful when testing the garbage collection mechanism itself, or
   * inhibiting a spontaneous GC initiation in subsequent code.
   *
   * <p>In contrast, a plain call to {@link java.lang.System#gc()} does not ensure finalization

   * in a {@code RuntimeException}. <b>Note:</b> Be sure to declare all of the checked exception
   * types your try block can throw when calling an overload of this method so as to avoid losing
   * the original exception type.
   *
   * <p>This method always throws, and as such should be called as {@code throw closer.rethrow(e);}
   * to ensure the compiler knows that it will throw.
   *

apiVersion: release-notes/v2
kind: bug-fix
area: istioctl
releaseNotes:
- |

        when:
        source.realizePending()

        then:
        0 * sideEffect1.execute("v1")

        then: // ensure ordering
        0 * sideEffect3.execute("v3")

        then: // ensure ordering
        0 * sideEffect5.execute("v5")

        // side effects of removed providers do not execute
        0 * sideEffect2.execute(_)
        0 * sideEffect4.execute(_)

apiVersion: release-notes/v2
kind: bug-fix
area: installation
issue:
  - 50958
releaseNotes:
- |

 * limitations under the License.
 */

package org.gradle.integtests.resolve.attributes


import org.gradle.integtests.fixtures.AbstractIntegrationSpec

/**
 * Tests for ArtifactView that ensure it uses the "live" attributes of the configuration that created it to select files and artifacts.
 *
 * As the necessary attributes are not present on the consumer's compileClasspath configuration until the

apiVersion: release-notes/v2
kind: feature
area: installation
issue:
  - 47867

releaseNotes:
  - |

apiVersion: release-notes/v2
kind: feature
area: istioctl
releaseNotes:
- |

        1 * sideEffect2.execute(46)

        then: // ensure invocation order
        1 * sideEffect1.execute(23)
        0 * _

        when:
        unpackedValue = provider.get()

        then:
        unpackedValue == 48
        1 * sideEffect2.execute(48)

        then: // ensure invocation order
        1 * sideEffect1.execute(24)
        0 * _
    }

		v1 = x
		if out := f(&v1, &v1, &v1); out != &v1 || v1 != v {
			return false
		}

		// Ensure the arguments were not modified.
		return x == x1 && y == y1
	}
}

// TestAliasing checks that receivers and arguments can alias each other without
// leading to incorrect results. That is, it ensures that it's safe to write
//
//	v.Invert(v)
//
// or
//
//	v.Add(v, v)
//