}

    /**
     * Registers CustomBinary type
     */
    void withCustomBinaryType() {
        buildFile << """
            interface CustomBinary extends BinarySpec {
                String getData()
                void setData(String value)
            }
            class DefaultCustomBinary extends BaseBinarySpec implements CustomBinary {
                String data = "bar"
            }

    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 {

		}
		if !bytes.Equal(der, plainDER) {
			t.Errorf("data mismatch")
		}
	}
}

var testData = []struct {
	kind     PEMCipher
	password []byte
	pemData  []byte
	plainDER string
}{
	{
		kind:     PEMCipherDES,
		password: []byte("asdf"),
		pemData: []byte(testingKey(`
-----BEGIN RSA TESTING KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-CBC,34F09A4FC8DE22B5

		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))