out, err = cmd.CombinedOutput()
	if err != nil {
		t.Errorf("pprof -disasm failed: %v\n%s", err, out)

		// Try to print out profile content for debugging.
		cmd = testenv.Command(t, pprofPath(t), "-raw", cpuExe, profile)
		out, err = cmd.CombinedOutput()
		if err != nil {
			t.Logf("pprof -raw failed: %v\n%s", err, out)
		} else {
			t.Logf("profile content:\n%s", out)
		}
		return
	}

#include <iostream>

int main () {
  std::cout << "Hello, World!\n";
  return 0;

    return std::string(wide.begin(), wide.end());
}

void hello() {
    std::string foo1 = LoadStringFromResource(IDS_FOO1);
    std::string foo2 = LoadStringFromResource(IDS_FOO2);
    std::cout << foo1;
    std::cout << foo2;
}
"""),
        sourceFile("rc/dir1", "resources.rc", """
#include "hello.h"

STRINGTABLE
{
    IDS_FOO1, "foo1"
}
"""),
        sourceFile("rc/dir2", "resources.rc", """

#include <iostream>
#include "hello.h"

void LIB_FUNC hello () {
  std::cout << "Hello, World!\n";

#import <iostream>
#import "greeter.h"

@implementation Greeter

- (void) sayHello {
    NSString *helloWorld = @"Hello world!";
    std::cout << [helloWorld UTF8String] << std::endl;
}

            using namespace std;

            void foo1() {
                cout << "foo1";
            }
        """),

         sourceFile("cpp/foo2", "foo.cpp", """
            #include <iostream>
            #include "foo.h"
            using namespace std;

            void foo2() {
                cout << "foo2";
            }
        """)]
    }

    @Override

func sysctlInt(mib []uint32) (int32, bool) {
	var out int32
	nout := unsafe.Sizeof(out)
	ret := sysctl(&mib[0], uint32(len(mib)), (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
	if ret < 0 {
		return 0, false
	}
	return out, true
}

func sysctlUint64(mib []uint32) (uint64, bool) {
	var out uint64
	nout := unsafe.Sizeof(out)
	ret := sysctl(&mib[0], uint32(len(mib)), (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
	if ret < 0 {

}

// newSequencer returns a sequencer that allows concurrent tasks up to maxWeight
// and writes tasks' output to out and err.
func newSequencer(maxWeight int64, out, err io.Writer) *sequencer {
	sem := semaphore.NewWeighted(maxWeight)
	prev := make(chan *reporterState, 1)
	prev <- &reporterState{out: out, err: err}
	return &sequencer{
		maxWeight: maxWeight,
		sem:       sem,
		prev:      prev,
	}
}

        """

        librarySourceFile.replace("cout << message", "cout << PREFIX << message")

        def libDefsHeader = file("library/src/main/headers/local_defs.h")
        libDefsHeader << """
            #define PREFIX "LOG: "
        """

        then:
        succeeds installApp
        install.exec().out == "LOG: [info] hello world"

        when:

#include <stdlib.h>
#include "app.h"

std::string ${namespace.groovyString}::Greeter::greeting() {
    return std::string("Hello, World!");
}

int main () {
    ${namespace.groovyString}::Greeter greeter;
    std::cout << greeter.greeting() << std::endl;
    return 0;