"type": "string"
          },
          "version": {
            "default": "",
            "description": "version specifies the version in the form of \"version\". This is to save the clients the trouble of splitting the GroupVersion.",
            "type": "string"
          }
        },
        "required": [
          "groupVersion",
          "version"
        ],
        "type": "object"
      },

            "type": "string"
          },
          "version": {
            "default": "",
            "description": "version specifies the version in the form of \"version\". This is to save the clients the trouble of splitting the GroupVersion.",
            "type": "string"
          }
        },
        "required": [
          "groupVersion",
          "version"
        ],
        "type": "object"
      },

		}

		// Retrieve the pod object from pod informer with the namespace key
		namespace, name, err := kcache.SplitMetaNamespaceKey(dswPodKey)
		if err != nil {
			utilruntime.HandleError(fmt.Errorf("error splitting dswPodKey %q: %v", dswPodKey, err))
			continue
		}
		informerPod, err := dswp.podLister.Pods(namespace).Get(name)
		switch {
		case errors.IsNotFound(err):

    // Splits into lines.
    SmallVector<StringRef, 8> lines;
    file->getBuffer().split(lines, "\n", -1, false);
    // The resize method is used since split operator puts tail value in the end
    // without splitting the leftovers.
    if (op.getVocabSize() != -1) lines.resize(op.getVocabSize());

    // Map each line to line number, starting from zero.
    SmallVector<int64_t, 8> line_nums;
    line_nums.resize(lines.size());

		} else if strings.HasPrefix(arg, "-vettool=") ||
			strings.HasPrefix(arg, "--vettool=") {
			vetTool = arg[strings.IndexByte(arg, '=')+1:]
			return
		}
	}
}

// vetFlags processes the command line, splitting it at the first non-flag
// into the list of flags and list of packages.
func vetFlags(args []string) (passToVet, packageNames []string) {
	parseVettoolFlag(args)

	// Query the vet command for its flags.

  exit(0)

# For test cases, only show the ones that failed that have text (a log)
seen = collections.Counter()
runfiles_matcher = re.compile(r"(/.*\.runfiles/)")


for f in files.strip().splitlines():
  # Just ignore any failures, they're probably not important
  try:
    r = JUnitXml.fromfile(f)
  except Exception as e:  # pylint: disable=broad-except

                // After splitting at the JAR separator, it is regarded as a root directory "/java.base".
                // To work with LibraryPathFilter, a hacky workaround here is to remove "modules/" from actual file path.
                // e.g. "/path/to/jdk/home!/java.base/java/lang/Object.class", which, from Path viewpoint, belongs to "/java.base",
                // after splitting at the JAR separator, in a similar way.

        ) {
          ranges.removeAt(j)
        } else {
          break@mergeAdjacent
        }
      }
    }
    i++
  }
  return ranges
}

/**
 * Returns a copy of [mappings], splitting to ensure that each mapping is entirely contained within
 * a single section.
 */
internal fun withoutSectionSpans(mappings: List<Mapping>): List<Mapping> {
  val result = mutableListOf<Mapping>()

	ConsumeViewerFrame func(key string, f format.Frame)
	Flush              func()
}

// ViewerDataTraceConsumer returns a TraceConsumer that writes to w. The
// startIdx and endIdx are used for splitting large traces. They refer to
// indexes in the traceEvents output array, not the events in the trace input.
func ViewerDataTraceConsumer(w io.Writer, startIdx, endIdx int64) TraceConsumer {
	allFrames := make(map[string]format.Frame)

	if err != nil {
		return false, "", errors.Wrapf(err, "failed to marshal Pod manifest for %q to YAML", path2)
	}

	diff := difflib.UnifiedDiff{
		A: difflib.SplitLines(string(manifest1)),
		B: difflib.SplitLines(string(manifest2)),
	}

	diffStr, err := difflib.GetUnifiedDiffString(diff)
	if err != nil {