@VisibleForTesting transient int expectedValuesPerKey = DEFAULT_VALUES_PER_KEY;

  /**
   * Creates a new, empty {@code HashMultimap} with the default initial capacities.
   *
   * <p>This method will soon be deprecated in favor of {@code
   * MultimapBuilder.hashKeys().hashSetValues().build()}.
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      HashMultimap<K, V> create() {

     *
     * <p>Clients should assume that entries may be removed at any time, based on current memory pressure and the likelihood that the entry will be required again soon.
     * The current implementation does not remove an entry during a build session that the entry has been used in, but this is not part of the contract.
     *

import org.gradle.internal.declarativedsl.schemaBuilder.TypeDiscovery
import kotlin.reflect.KClass


/**
 * Utility [TypeDiscovery] implementation that allows introducing [discoverClasses] as soon as [keyClass] is encountered in type discovery.
 */
internal
class FixedTypeDiscovery(private val keyClass: KClass<*>, private val discoverClasses: List<KClass<*>>) : TypeDiscovery {

        given:
        // We need to put these files in subdirectories, since on Linux we'd stop watching a directory as soon as we
        // received file changes for all the files inside.
        def inputSubdirectories = (1..changesLimit).collect { inputDir.createDir("subdir${it}")}

      with 503 errors in the log. This happens when 1.7.5+ proxies send HTTP 1xx or 204 response 
      codes with headers that 1.7.x proxies reject. To fix this, upgrade all your 

 * annotations even on JUnit 3 tests.
 *
 * TODO(b/225350400): Remove @Ignore, which doesn't seem like it should be necessary and probably
 * soon won't be.
 */
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@Ignore
public final class MyTester extends AbstractTester<@Nullable Void> {
  static int timesTestClassWasRun = 0;

  public void testNothing() {

  @VisibleForTesting transient int expectedValuesPerKey;

  /**
   * Creates a new, empty {@code ArrayListMultimap} with the default initial capacities.
   *
   * <p>This method will soon be deprecated in favor of {@code
   * MultimapBuilder.hashKeys().arrayListValues().build()}.
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      ArrayListMultimap<K, V> create() {

		// This allocation pattern leaves the next object in the class
		// unallocated, which we need to reproduce the bug.
		objs = append(objs, make([]*byte, i))
	}
	sink = objs // force heap allocation

	// Bug will happen as soon as the write barrier turns on.
	for range 10000 {
		sink = make([]*byte, 1024)
		for _, s := range objs {
			s = append(s, make([]*byte, zero)...)
		}
	}

#include <CoreFoundation/CoreFoundation.h>
*/
import "C"
import (
	"runtime/debug"
	"testing"
	"unsafe"
)

func test21897(t *testing.T) {
	// Please write barrier, kick in soon.
	defer debug.SetGCPercent(debug.SetGCPercent(1))

	for i := 0; i < 10000; i++ {
		testCFNumberRef()
		testCFDateRef()
		testCFBooleanRef()
		// Allocate some memory, so eventually the write barrier is enabled

		log.Fatal(err)
	}

	select {
	case <-neverReady:
		fmt.Println("ready")
	case <-ctx.Done():
		fmt.Println(ctx.Err()) // prints "context canceled"
		stop()                 // stop receiving signal notifications as soon as possible.
	}

	// Output:
	// context canceled