"""

    def test_boilerplate(self):
        os.chdir("test/")

        class Args:
            filenames = []
            rootdir = "."
            boilerplate_dir = "../"
            verbose = True

        # capture stdout
        old_stdout = sys.stdout
        sys.stdout = StringIO()

        boilerplate.args = Args
        ret = boilerplate.main()
        self.assertEqual(ret, 0)

	// are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map
	// are accessible via CEL macros and functions such as `self.all(...)`.
	// If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and
	// functions.
	// If the Rule is scoped to a scalar, `self` is bound to the scalar value.
	// Examples:

		rootCertFile, false, rsaKeySize)
	if err != nil {
		t.Fatalf("Failed to create a self-signed CA Options: %v", err)
	}

	ca, err := NewIstioCA(caopts)
	if err != nil {
		t.Errorf("Got error while creating self-signed CA: %v", err)
	}
	if ca == nil {
		t.Fatalf("Failed to create a self-signed CA.")
	}

	signingCert, _, certChainBytes, rootCertBytes := ca.GetCAKeyCertBundle().GetAll()

	// are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map
	// are accessible via CEL macros and functions such as `self.all(...)`.
	// If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and
	// functions.
	// If the Rule is scoped to a scalar, `self` is bound to the scalar value.
	// Examples:

  protected B usingGenerator(G subjectGenerator) {
    this.subjectGenerator = subjectGenerator;
    return self();
  }

  public G getSubjectGenerator() {
    return subjectGenerator;
  }

  @CanIgnoreReturnValue
  public B withSetUp(Runnable setUp) {
    this.setUp = setUp;
    return self();
  }

  public Runnable getSetUp() {
    return setUp;
  }

  @CanIgnoreReturnValue

        @Receiver FileTypeDetector self,
        Path path,
        @CallerClassName String consumer
    ) throws IOException {
        tryReportFileOpened(path, consumer);
        return self.probeContentType(path);
    }

    @InterceptCalls
    @InstanceMethod
    public static SeekableByteChannel intercept_newByteChannel(
        @Receiver FileSystemProvider self,
        Path path,
        Set<?> options,

    @InterceptCalls
    @CallableKind.InstanceMethod
    @SuppressWarnings("NewMethodNamingConvention")
    public static void intercept_testInstrumentation(@ParameterKind.Receiver CallInterceptionFilteringTestReceiver self) {
        self.intercepted = "testInstrumentation()";
    }

												{
													Rule: "self == 'singleton'",
												},
											},
											Default: jsonPtr("singleton"),
										},
									},
								},
							},
						},
						"value": {
							Type: "string",
							XValidations: apiextensions.ValidationRules{
								{
									Rule: "self.startsWith('kube')",
								},
							},

//go:build !windows && !darwin

package pprof

import (
	"errors"
	"os"
)

// readMapping reads /proc/self/maps and writes mappings to b.pb.
// It saves the address ranges of the mappings in b.mem for use
// when emitting locations.
func (b *profileBuilder) readMapping() {
	data, _ := os.ReadFile("/proc/self/maps")
	parseProcSelfMaps(data, b.addMapping)
	if len(b.mem) == 0 { // pprof expects a map entry, so fake one.

// one.

import (
	"bytes"
	"debug/elf"
	"os"
	"testing"
)

func testBuildID(t *testing.T) {
	f, err := elf.Open("/proc/self/exe")
	if err != nil {
		if os.IsNotExist(err) {
			t.Skip("no /proc/self/exe")
		}
		t.Fatal("opening /proc/self/exe: ", err)
	}
	defer f.Close()

	c := 0
sections:
	for i, s := range f.Sections {
		if s.Type != elf.SHT_NOTE {
			continue
		}