static final int ARRAY_SIZE = 0x10000;
  static final int ARRAY_MASK = 0x0ffff;
  static final Random RANDOM_SOURCE = new Random(314159265358979L);
  static final int MAX_EXPONENT = 100;

  /*
   * Duplicated from LongMath.
   * binomial(biggestBinomials[k], k) fits in a long, but not
   * binomial(biggestBinomials[k] + 1, k).
   */
  static final int[] biggestBinomials = {
    Integer.MAX_VALUE,
    Integer.MAX_VALUE,

func mustMatchLength(t *testing.T, l int, items []string) {
	t.Helper()
	if len(items) != l {
		t.Fatalf("expected %v items, got %v: %v", l, len(items), items)
	}
}

func TestLogr(t *testing.T) {
	t.Run("newlines not duplicated", func(t *testing.T) {
		lines := runLogrTest(t, func(l logr.Logger) {
			l.Info("msg\n")
		})
		mustMatchLength(t, 1, lines)
		mustRegexMatchString(t, lines[0], "msg")
	})

      int n, @Nullable Entry<K, V>[] entryArray, boolean throwIfDuplicateKeys) {
    Map<K, V> delegateMap = Maps.newHashMapWithExpectedSize(n);
    // If duplicates are allowed, this map will track the last value for each duplicated key.
    // A second pass will retain only the first entry for that key, but with this last value. The
    // value will then be replaced by null, signaling that later entries with the same key should
    // be deleted.

            verified.add(artifact);
        }

        // Check that ivy.xml isn't duplicated
        checkNotDuplicate(publication, verified, "ivy", "xml", "xml", null);
    }

                }
            }
        """

        when:
        run("tasks", "--info")

        then:
        // InstrumentationAnalysisTransform is duplicated since InstrumentationAnalysisTransform result is also an input to MergeInstrumentationAnalysisTransform

            }
        }
        return command.toArray()
    }

    @ToBeFixedForConfigurationCache(bottomSpecs = "XCTestTestFrameworkIntegrationTest")
    def "can deduplicate test filters when #scenario"() {
        given:
        createPassingFailingTest()

        when:
        runAndFail(*command)

        then:
        testResult.assertTestClassesExecuted('SomeTest')

	return func(ctx context.Context, fireAt time.Time, args *WorkArgs) error {
		err := q.workFunc(ctx, fireAt, args)
		q.Lock()
		defer q.Unlock()
		if err == nil {
			// To avoid duplicated calls we keep the key in the queue, to prevent
			// subsequent additions.
			q.workers[key] = nil
		} else {
			delete(q.workers, key)
		}
		return err
	}
}

                } else if (logger.isWarnEnabled()) {
                    Lifecycle original = phaseToLifecycleMap.get(phase);
                    logger.warn(
                            "Duplicated lifecycle phase {}. Defined in {} but also in {}",
                            phase,
                            original.getId(),
                            lifecycle.getId());
                }
            }

	testenv.MustHaveExec(t)

	f, remove := mustTempFile(t)
	defer remove()

	lock(t, f)

	other := mustOpen(t, f.Name())
	defer other.Close()

	// Some kinds of file locks are dropped when a duplicated or forked file
	// descriptor is unlocked. Double-check that the approach used by os/exec does
	// not accidentally drop locks.
	cmd := testenv.Command(t, os.Args[0], "-test.run=^$")
	if err := cmd.Run(); err != nil {

            .replace("interface ", "")
    }

    companion object {
        private
        const val RESOURCE = "/default-imports.txt"

        /**
         * Logic duplicated from [org.gradle.configuration.DefaultImportsReader].
         * Please keep this code in sync.
         */
        internal
        fun generateImportPackages(): List<String> {
            /*