"""

        when:
        succeeds("help")

        then:
        outputContains("NOT FOUND [settings] $localClassName")
        outputContains("NOT FOUND [settings] $dependencyClassName")
        outputContains("FOUND [project] $localClassName")
        outputContains("FOUND [project] $dependencyClassName")
    }

    conditions:
    - lastTransitionTime: fake
      message: No errors found
      reason: Accepted
      status: "True"
      type: Accepted
    - lastTransitionTime: fake
      message: No errors found
      reason: NoConflicts
      status: "False"
      type: Conflicted
    - lastTransitionTime: fake
      message: No errors found
      reason: Programmed
      status: "True"
      type: Programmed

            Set<T> found = findIn(windowsKitDir, DiscoveryType.REGISTRY);
            if (found.isEmpty()) {
                brokenComponents.add(windowsKitDir);
            }
            for (T t : found) {
                foundComponents.put(t.getBaseDir(), t);
            }
        } catch (MissingRegistryEntryException e) {

      exit 1
    else
      continue
    fi
  fi
  found=$(echo -n "${node}" | wc -l)
  # Use grep || true so that empty result doesn't return nonzero exit code.
  ready=$(echo -n "${node}" | grep -c -v "NotReady" || true)

  if (( "${found}" == "${EXPECTED_NUM_NODES}" )) && (( "${ready}" == "${EXPECTED_NUM_NODES}")); then
    break
  elif (( "${found}" > "${EXPECTED_NUM_NODES}" )); then

            val symbol = getClassOrObjectSymbolByClassId(classId) ?: error("Class $classId is not found")
            return listOf(symbol)
        }
    }

    object ScriptData : SymbolData() {
        override fun KaSession.toSymbols(ktFile: KtFile): List<KaSymbol> {
            val script = ktFile.script ?: error("Script is not found")
            return listOf(script.getScriptSymbol())
        }
    }

// license that can be found in the LICENSE file.

package genflags

import (
	"flag"
	"strings"
	"testing"
)

// ShortTestFlags returns the set of "-test." flag shorthand names that end
// users may pass to 'go test'.
func ShortTestFlags() []string {
	testing.Init()

	var names []string
	flag.VisitAll(func(f *flag.Flag) {
		var name string
		var found bool

	}

	provider := providers[0]
	ret, found := resolved[provider]
	if !found {
		var li []string
		for p := range resolved {
			li = append(li, p)
		}
		return nil, fmt.Errorf("available providers are %v but found %q", li, provider)
	} else if ret.err != nil {
		return nil, fmt.Errorf("found errors in provider %s: %v", provider, ret.err)

        private final AttributeValue<T> found;
        private final boolean match;

        public MatchingDescription(Attribute<T> requestedAttribute, AttributeValue<T> requestedValue, AttributeValue<T> found, boolean match) {
            this.requestedAttribute = requestedAttribute;
            this.requestedValue = requestedValue;
            this.found = found;
            this.match = match;
        }

	if stats.ExecTime < 0 {
		t.Error("found negative ExecTime")
	}
	if stats.SchedWaitTime < 0 {
		t.Error("found negative SchedWaitTime")
	}
	if stats.SyscallTime < 0 {
		t.Error("found negative SyscallTime")
	}
	if stats.SyscallBlockTime < 0 {
		t.Error("found negative SyscallBlockTime")
	}
	if stats.TotalTime < 0 {
		t.Error("found negative TotalTime")
	}

	volumePaths, err := kl.getMountedVolumePathListFromDisk(podUID)
	if err != nil {
		klog.ErrorS(err, "Pod found, but error occurred during checking mounted volumes from disk", "podUID", podUID)
		return true
	}
	if len(volumePaths) > 0 {
		klog.V(4).InfoS("Pod found, but volumes are still mounted on disk", "podUID", podUID, "paths", volumePaths)
		return true
	}

	return false
}