builder.get(handler)

        then:
        1 * asyncConnection.run(!null, !null) >> {args ->
            ConsumerAction<GradleProject> action = args[0]
            action.run(connection)
            adaptedHandler = args[1]
        }
        1 * connection.run(GradleProject, _) >> {args ->
            ConsumerOperationParameters params = args[1]
            assert params.standardOutput == null
            assert params.standardError == null

        Long id = args.containsKey("id") ? args.id : ++counter
        String category = args.containsKey("category") ? args.category : CATEGORY
        return new ProgressStartEvent(new OperationIdentifier(id), parent, tenAm, category, args.description, args.loggingHeader, args.status, 0, buildOperationStart, buildOperationId, buildOperationCategory)

		})
	}
}

func TestCamelCaseWithSeparator(t *testing.T) {
	type args struct {
		n   string
		sep string
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		{
			name: "foo_bar",
			args: args{
				n:   "foo_bar",
				sep: "_",
			},
			want: "FooBar",
		},
		{
			name: "foo-bar",
			args: args{
				n:   "foo-bar",
				sep: "-",
			},
			want: "FooBar",
		},

        1 * repo1.content(_) >> { args ->
            args[0].execute(repo1Content)
        }
        1 * repo1Content.includeGroup("foo")
        1 * repo2.content(_) >> { args ->
            args[0].execute(repo2Content)
        }
        1 * repo2Content.excludeGroup("foo")
        1 * repo3.content(_) >> { args ->
            args[0].execute(repo3Content)
        }

	args := []string{
		"--utc",
		"--no-pager",
		"--output=short-precise",
	}
	if n.SinceTime != nil {
		args = append(args, fmt.Sprintf("--since=%s", n.SinceTime.Format(dateLayout)))
	}
	if n.UntilTime != nil {
		args = append(args, fmt.Sprintf("--until=%s", n.UntilTime.Format(dateLayout)))
	}
	if n.TailLines != nil {

                args.add("-shared");
                maybeSetInstallName((SharedLibraryLinkerSpec) spec, args);
            }
            args.add("-o");
            args.add(spec.getOutputFile().getAbsolutePath());
            for (File file : spec.getObjectFiles()) {
                args.add(file.getAbsolutePath());
            }
            for (File file : spec.getLibraries()) {
                args.add(file.getAbsolutePath());

	}
	ev := event.Type(evb)
	spec := r.specs[ev]
	args, err := r.readArgs(len(spec.Args))
	if err != nil {
		return Event{}, err
	}
	if spec.IsStack {
		len := int(args[1])
		for i := 0; i < len; i++ {
			// Each stack frame has four args: pc, func ID, file ID, line number.
			frame, err := r.readArgs(4)
			if err != nil {
				return Event{}, err
			}
			args = append(args, frame...)
		}
	}
	var data []byte

		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsInterface()) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, OpLoad, typ.Uintptr)
		v.copyOf(v0)
		v0.AddArg2(ptr, mem)
		return true
	}
	return false
}
func rewriteValuedec_OpLoad(v *Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types

        when:
        def args = transformer.transform(spec)

        then:
        assertHasArguments(args, "-I", includes)
        assertHasArguments(args, "-isystem", systemIncludes)

        and:
        args.indexOf(includes.last().absoluteFile.toString()) < args.indexOf(systemIncludes.first().absoluteFile.toString())
    }

    boolean assertHasArguments(List<String> args, String option, List<File> files) {

	})
}

func TestIsRegularMemory(t *testing.T) {
	type args struct {
		t reflect.Type
	}
	type S struct {
		int
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		{"struct{i int}", args{reflect.TypeOf(struct{ i int }{})}, true},
		{"struct{}", args{reflect.TypeOf(struct{}{})}, true},
		{"struct{i int; s S}", args{reflect.TypeOf(struct {
			i int
			s S
		}{})}, true},