return err
	}

	setupSuccess = true
	return nil
}

// CollectData collects requested downwardAPI in data map.
// Map's key is the requested name of file to dump
// Map's value is the (sorted) content of the field to be dumped in the file.
//
// Note: this function is exported so that it can be called from the projection volume driver

				found = true
				break
			}
		}
		if !found {
			t.Errorf("dump output regexp match failed for %q", testpoint.tag)
			bad = true
		}
	}
	if bad {
		dumplines(lines)
	}
}

func testPercent(t *testing.T, s state) {
	// Run the dumper on the two dirs we generated.
	dargs := []string{"-pkg=" + mainPkgPath, "-i=" + s.outdirs[0] + "," + s.outdirs[1]}

		// make sure we dump suite-level/top-level resources, but don't dump sibling tests or their children
		for _, scope := range c.topLevelScopes() {
			scope.dump(c, false)
		}
		c.scope.dump(c, true)
		scopes.Framework.Debugf("Completed dumping testContext: %q", c.id)
	} else {
		scopes.Framework.Debugf("Begin skipping dump of testContext: %q. Maximum number of test dumps exceeded", c.id)
	}
}

    rewriter.setInsertionPointAfterValue(result);

    // In Whole model, we first need to set file_name as
    // unquantized_tensor_data.pb as it is used by unquantized dump model.
    // After saving unquantized dump model, the file name will be changed to
    // quantized_tensor_data.pb.
    // Since this process doesn't happen for per layer, we need to set file_name
    // as quantized_tensor_data.pb here.

		written += int64(n)
		if err != nil {
			return written, err
		}
		dumper := hex.Dumper(w)
		n, err = dumper.Write(flow)
		written += int64(n)
		if err != nil {
			return written, err
		}
		err = dumper.Close()
		if err != nil {
			return written, err
		}
		clientToServer = !clientToServer
	}
	return written, nil
}

  if (!status.ok()) {
    LOG(WARNING) << "error writing to file '" << prefix
                 << "': " << status.message();
    return;
  }
  (void)file_writer->Close();
  VLOG(1) << "Dumped MLIR module to " << prefix;
}

MlirOptimizationPassRegistry& MlirOptimizationPassRegistry::Global() {
  static auto* global = new MlirOptimizationPassRegistry();
  return *global;
}

- [profile](../operator/cmd/mesh/profile.go): dumps the default values for a selected profile, it has the following subcommands:
    - [diff](../operator/cmd/mesh/profile-diff.go): the diff subcommand is used to display the difference between two Istio configuration profiles.
    - [dump](../operator/cmd/mesh/profile-dump.go): the dump subcommand is used to dump the values in an Istio configuration profile.

		{tcs, "(dump.customString) (len=4) \"test\"\n"},
		{&tcs, "(*dump.customString)((len=4) \"test\")\n"},
		{tpcs, "(dump.pCustomString) (len=5) \"&test\"\n"},
		{&tpcs, "(*dump.pCustomString)((len=5) \"&test\")\n"},
		{tce, "(dump.customError) 0\n"},
		{&tce, "(*dump.customError)(0)\n"},
		{tpce, "(dump.pCustomError) 0\n"},
		{&tpce, "(*dump.pCustomError)(0)\n"},
		{
			struct {

                                 absl::string_view error_message,
                                 toco::GraphVizDumpOptions* dump_options) {
  // Make sure the graphviz file will be dumped under the same folder.
  dump_options->dump_graphviz = toco_flags->conversion_summary_dir();
  // Here we construct the `toco::Model` class based on the input graph def,
  // it will then be used to populate the conversion log.

	return buffer.String()
}

func (dump *IPTablesDump) GetTable(table iptables.Table) (*Table, error) {
	for i := range dump.Tables {
		if dump.Tables[i].Name == table {
			return &dump.Tables[i], nil
		}
	}
	return nil, fmt.Errorf("no such table %q", table)
}

func (dump *IPTablesDump) GetChain(table iptables.Table, chain iptables.Chain) (*Chain, error) {
	t, err := dump.GetTable(table)
	if err != nil {