CollectingConditionEvents events = new CollectingConditionEvents();
        archCondition.check(javaClass, events);
        assertThat(events.getAllEvents()).hasSize(1);
        return events.getAllEvents().iterator().next();
    }

    @Nonnull
    private ConditionEvent checkThatHasOnlyAllowedTypes(String methodName) {

	}
}

// fakeTerminalSizeQueue implements TerminalSizeQueue, returning a random set of
// "maxSizes" number of TerminalSizes, storing the TerminalSizes in "sizes" slice.
type fakeTerminalSizeQueue struct {
	maxSizes      int
	terminalSizes []remotecommand.TerminalSize
}

// newTerminalSizeQueue returns a pointer to a fakeTerminalSizeQueue passing

		if tt.RegionID == 0 {
			return Script{scr}, High
		}
		sc, c = scr, High
	}
	if tag, err := tt.Maximize(); err == nil {
		if tag.ScriptID != sc {
			sc, c = tag.ScriptID, Low
		}
	} else {
		tt, _ = canonicalize(Deprecated|Macro, tt)
		if tag, err := tt.Maximize(); err == nil && tag.ScriptID != sc {
			sc, c = tag.ScriptID, Low
		}
	}
	return Script{sc}, c
}

        return this
    }

    fun assertNumberOfCompileAvoidanceWarnings(n: Int): BuildOperationsAssertions {
        MatcherAssert.assertThat(compileAvoidanceWarnings, org.hamcrest.Matchers.hasSize(n))
        return this
    }

                    assertCacheHits(run)
                }
            }
        }
        val daemonFixture = DaemonLogsAnalyzer.newAnalyzer(executer.daemonBaseDir)
        assertThat(daemonFixture.daemons).hasSize(1)
    }

    @Test
    fun `writes build cache entries`() {
        expectCacheEntriesWritten(2, false)
    }

    @Test
    fun `writes no build cache entries when script caching disabled`() {

    Preconditions.checkArgument(expectedSize >= 0, "Expected size must be >= 0");

    // Save expectedSize for use in allocArrays()
    this.metadata = Ints.constrainToRange(expectedSize, 1, CompactHashing.MAX_SIZE);
  }

  /** Returns whether arrays need to be allocated. */
  boolean needsAllocArrays() {
    return table == null;
  }

  /** Handle lazy allocation of arrays. */
  @CanIgnoreReturnValue

    private final Set<ExcludeSpec> cached = new HashSet<>()
    private final List<ExcludeSpec> cachedLinear = new ArrayList<>(MAX_CACHED)
    private int depth

    /**
     * This test has been baked to maximize code coverage of {@link DefaultCompositeExclude}
     */
    def "compares specs"() {
        expect:
        (500_000).times {
            ExcludeSpec a = next()
            ExcludeSpec b = next()

   * contains(). Verify that these sets are consistent with the elements of their iterator.
   */
  @CanIgnoreReturnValue
  static <T> Set<T> sanityCheckSet(Set<T> set) {
    assertThat(set).hasSize(Iterators.size(set.iterator()));
    for (Object element : set) {
      assertThat(set).contains(element);
    }
    assertThat(set).doesNotContain(new Object());
    assertThat(set).isEqualTo(ImmutableSet.copyOf(set));

extensions and documentation located in this repository.
For other extensions and components, see the 
[Gradle Community Resources](https://gradle.org/resources/).

This guide will help you to...

* maximize the chance of your changes being accepted
* work on the Gradle code base
* get help if you encounter trouble

## Before you start

    Set<Callable<String>> tasks = Collections.singleton(() -> "invokeAll");

    List<Future<String>> result = executorService.invokeAll(tasks, Duration.ofDays(365));

    assertThat(result).hasSize(1);
    assertThat(Futures.getDone(result.get(0))).isEqualTo("invokeAll");
    assertThat(recordedTasks).isSameInstanceAs(tasks);
    assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);