private String transformerName;

    private byte[] data;

    private String encoding;

    private Set<RequestData> childUrlSet = new LinkedHashSet<>();

    public byte[] getData() {
        return data;
    }

    public void setData(final byte[] data) {
        this.data = data;
    }

    public void addUrl(final RequestData url) {
        childUrlSet.add(url);
    }

        try {
            resultData.setData(data.getBytes(charsetName));
        } catch (final UnsupportedEncodingException e) {
            if (logger.isInfoEnabled()) {
                logger.info("Invalid charsetName: " + charsetName + ". Changed to " + Constants.UTF_8, e);
            }
            charsetName = Constants.UTF_8_CHARSET.name();
            resultData.setData(data.getBytes(Constants.UTF_8_CHARSET));
        }

    const togglePlot = function (chartId, label) {
        const plot = plots[chartId];
        const plotData = plot.getData();
        $.each(plotData, function (index, value) {
            if (value.label == label) {
                value.points.show = value.lines.show = !value.lines.show;
            }
        });
        plot.setData(plotData);
        plot.draw();
    };

    function renderGraphs(allDataJson, charts) {

            try {
                resultData.setData(data.getBytes(charsetName));
            } catch (final UnsupportedEncodingException e) {
                if (logger.isInfoEnabled()) {
                    logger.info("Invalid charsetName: " + charsetName + ". Changed to " + Constants.UTF_8, e);
                }
                charsetName = Constants.UTF_8_CHARSET.name();
                resultData.setData(data.getBytes(Constants.UTF_8_CHARSET));

	KeyPath []interface{}

	// Root object to traverse from
	RootObject    interface{}
	RootOldObject interface{}
}

func (c TestCase) Run() error {
	// Create the correlated object
	correlatedObject := common.NewCorrelatedObject(c.RootObject, c.RootOldObject, c.Schema)

	// Traverse the correlated object
	var err error
	for _, key := range c.KeyPath {
		if correlatedObject == nil {

		asmbElf(ctxt)
	}

	if *FlagC {
		fmt.Printf("textsize=%d\n", Segtext.Filelen)
		fmt.Printf("datsize=%d\n", Segdata.Filelen)
		fmt.Printf("bsssize=%d\n", Segdata.Length-Segdata.Filelen)
		fmt.Printf("symsize=%d\n", symSize)
		fmt.Printf("lcsize=%d\n", lcSize)
		fmt.Printf("total=%d\n", Segtext.Filelen+Segdata.Length+uint64(symSize)+uint64(lcSize))
	}
}

	// Returned name.
	name string
	// Returned value.
	value uint64
	// If the perfCounter should raise an error.
	raiseError bool
}

func (p *fakePerfCounterImpl) getData() (uint64, error) {
	if p.raiseError {
		return 0, errors.New("Expected getData error.")
	}
	return p.value, nil
}

func (p *fakePerfCounterImpl) getDataList() (map[string]uint64, error) {
	if p.raiseError {

		etext := ldr.Lookup("runtime.etext", 0)
		edata := ldr.Lookup("runtime.edata", 0)
		end := ldr.Lookup("runtime.end", 0)
		ldr.SetSymExtname(etext, "runtime.etext")
		ldr.SetSymExtname(edata, "runtime.edata")
		ldr.SetSymExtname(end, "runtime.end")
		ctxt.xdefine("_etext", ldr.SymType(etext), ldr.SymValue(etext))
		ctxt.xdefine("_edata", ldr.SymType(edata), ldr.SymValue(edata))

	}

	certPath := filepath.Join(certDir, "kubelet.cert")
	keyPath := filepath.Join(certDir, "kubelet.key")
	if err := removeThenCreate(certPath, cert, os.FileMode(0644)); err != nil {
		return "", "", err
	}

	if err := removeThenCreate(keyPath, key, os.FileMode(0600)); err != nil {
		return "", "", err
	}

	return certPath, keyPath, nil
}

	}

	writeIfNotEqual := func(fileName string, newData []byte) error {
		if newData == nil {
			return nil
		}
		oldData, _ := os.ReadFile(path.Join(dir, fileName))
		if !bytes.Equal(oldData, newData) {
			if err := file.AtomicWrite(path.Join(dir, fileName), newData, certFileMode); err != nil {
				return fmt.Errorf("failed to write data to file %v: %v", fileName, err)
			}
		}