t.Run(scenario.name, func(t *testing.T) {
			// test data
			indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})
			if err := indexer.Add(scenario.cm); err != nil {
				t.Fatal(err.Error())
			}
			target := newDefaultTarget()
			target.configmapLister = corev1listers.NewConfigMapLister(indexer).ConfigMaps(defConfigMapNamespace)

			// act
			err := target.sync()

        return true;
    }

    @Override
    public boolean accept(ComponentMetadata candidate) {
        int selectorStatusIndex = candidate.getStatusScheme().indexOf(selectorStatus);
        int candidateStatusIndex = candidate.getStatusScheme().indexOf(candidate.getStatus());
        return selectorStatusIndex >=0 && selectorStatusIndex <= candidateStatusIndex;
    }

    @Override

        var currentFind = source.indexOf(" ", lastFind)
        while (currentFind != -1) {
            var token = source.substring(lastFind)
            if (currentFind != -1) {
                token = token.substring(0, currentFind - lastFind)
            }

            addIfValid(token, result)
            lastFind = currentFind + 1
            currentFind = source.indexOf(" ", lastFind)
        }

        if (buf.indexOf("dd") == -1) {
            final int pos = buf.indexOf("d");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "dd");
            }
        }
        if (buf.indexOf("HH") == -1) {
            final int pos = buf.indexOf("H");
            if (pos != -1) {
                buf.replace(pos, pos + 1, "HH");
            }
        }
        if (buf.indexOf("mm") == -1) {

        then:
        assertHasArguments(args, "/I", includes)
        assertHasArguments(args, "/I", systemIncludes)

        and:
        args.indexOf("/I" + includes.last().absoluteFile.toString()) < args.indexOf("/I" + systemIncludes.first().absoluteFile.toString())
    }

    def "does not include an empty string in compiler options"() {
        given:

        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        assertThat(list.indexOf(null), is(0));
        assertThat(list.indexOf("1"), is(1));
        assertThat(list.indexOf("2"), is(2));
        assertThat(list.indexOf("3"), is(3));
        assertThat(list.indexOf("4"), is(-1));
    }

            return null;
        }

        String expression = stripTokens(expr);
        if (expression.equals(expr)) {
            int index = expr.indexOf("${");
            if (index >= 0) {
                int lastIndex = expr.indexOf('}', index);
                if (lastIndex >= 0) {
                    String retVal = expr.substring(0, index);

	}

	// Validate Pod0 Results
	ps, found := indexPods[prf0]
	assert.True(t, found)
	assert.Len(t, ps.Containers, 2)
	indexCon := make(map[string]statsapi.ContainerStats, len(ps.Containers))
	for _, con := range ps.Containers {
		indexCon[con.Name] = con
	}
	con := indexCon[cName00]
	assert.EqualValues(t, testTime(creationTime, seedPod0Container0).Unix(), con.StartTime.Time.Unix())

    private static final char PACKAGE_SEPARATOR = '.';

    public static String abbreviateJavaPackage(@Nonnull String qualifiedClassName, int maxLength) {
        if (qualifiedClassName.length() <= maxLength || qualifiedClassName.indexOf(PACKAGE_SEPARATOR) == -1) {
            return qualifiedClassName;
        }

        final int maxLengthWithoutEllipsis = maxLength - 3;
        int beginIdx = 0;

        if (selectedTags.some(tag => currentTags.indexOf(tag) != -1)) {
            $(row).show()
        } else {
            $(row).hide()
        }
    })

    $("#filter-popover .form-check-input").toArray().forEach(function (checkbox) {
        if (selectedTags.indexOf(checkbox.value) != -1) {
            checkbox.setAttribute('checked', 'true');
        } else {