files = append(files, string(line))
		}
	}
	return files
}

func parseMobileProvision(fname string) *exec.Cmd {
	return exec.Command("security", "cms", "-D", "-i", string(fname))
}

func plistExtract(fname string, path string) ([]byte, error) {
	out, err := exec.Command("/usr/libexec/PlistBuddy", "-c", "Print "+path, fname).CombinedOutput()
	if err != nil {
		return nil, err
	}
	return bytes.TrimSpace(out), nil
}

	// Load specified file.
	loadFile := func(fname string) string {
		data, err := embeddedFiles.ReadFile(fname)
		if err != nil {
			fmt.Fprintf(os.Stderr, "internal/driver: embedded file %q not found\n",
				fname)
			os.Exit(1)
		}
		return string(data)
	}
	loadCSS := func(fname string) string {
		return `<style type="text/css">` + "\n" + loadFile(fname) + `</style>` + "\n"
	}
	loadJS := func(fname string) string {

	i32 := types.Types[types.TINT32]
	fname := typecheck.Lookup
	nxp := src.NoXPos
	nfield := types.NewField
	asanGlobal := types.NewStruct([]*types.Field{
		nfield(nxp, fname("beg"), up),
		nfield(nxp, fname("size"), up),
		nfield(nxp, fname("sizeWithRedzone"), up),
		nfield(nxp, fname("name"), up),
		nfield(nxp, fname("moduleName"), up),
		nfield(nxp, fname("hasDynamicInit"), up),

    static final Logger log = LoggerFactory.getLogger(ConcurrencyTest.class);
    private ExecutorService executor;


    public ConcurrencyTest ( String name, Map<String, String> properties ) {
        super(name, properties);
    }


    @Parameters ( name = "{0}" )
    public static Collection<Object> configs () {
        return getConfigs("smb1", "noNTStatus", "noNTSmbs", "smb2", "smb30", "smb31");
    }

func exportError(ctx context.Context, err error, fname, entity string) APIError {
	if entity == "" {
		return toAPIError(ctx, fmt.Errorf("error exporting %s with: %w", fname, err))
	}
	return toAPIError(ctx, fmt.Errorf("error exporting %s from %s with: %w", entity, fname, err))
}

// wraps import error for more context
func importError(ctx context.Context, err error, fname, entity string) APIError {
	if entity == "" {

// Counter values will be accumulated where appropriate.
func (fm *Formatter) AddUnit(file string, fname string, isfnlit bool, unit coverage.CoverableUnit, count uint32) {
	if fm.p == nil {
		panic("AddUnit invoked before SetPackage")
	}
	fkey := fnfile{file: file, fname: fname, lit: isfnlit}
	idx, ok := fm.p.funcTable[fkey]
	if !ok {
		idx = uint32(len(fm.p.funcs))
		fm.p.funcs = append(fm.p.funcs, fkey)

        "outname": attr.string(),
    },
    outputs = {"out": "%{name}.java"},
    implementation = _impl,
)

def junit_tests(name, srcs, **kwargs):
    s_name = name.replace("-", "_") + "TestSuite"
    _GenSuite(
        name = s_name,
        srcs = srcs,
        outname = s_name,
    )
    java_test(
        name = name,
        test_class = s_name,
        srcs = srcs + [":" + s_name],

  std::string fname =
      absl::StrCat("_expanded_", ndef.name(), "_", std::to_string(x));
  if (!ctx.FindFunctionByName(fname)) {
    TF_ASSIGN_OR_RETURN(auto func, ExpandNode(ndef, fname));
    TF_RETURN_IF_ERROR(ctx.AddFunctionDef(func));
  }

  // Rewrite the out_op to be the call op. This essentially a deep copy of the
  // orig_op, except the op name.
  auto* new_op = new EagerOperation(&ctx);

		// Display warnings we encountered as well
		for _, fname := range filenames {
			if w := warningsByFilename[fname]; w != nil {
				if fname == "-" {
					_, _ = fmt.Fprint(writer, warningToString(w))
					break
				}
				_, _ = fmt.Fprintf(writer, "%q has warnings: %v\n", fname, warningToString(w))
			}
		}
		return errs
	}
	for _, fname := range filenames {
		if fname == "-" {

}

var HostIP = os.Getenv("HOST_IP")

// readBootstrapToJSON reads a config file, in YAML or JSON, and returns JSON string
func readBootstrapToJSON(fname string) (string, error) {
	b, err := os.ReadFile(fname)
	if err != nil {
		return "", fmt.Errorf("failed to read file: %s, %v", fname, err)
	}

	// Replace host with HOST_IP env var if it is "$(HOST_IP)".