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 "hello.h"

  ExpectHasSubstr(h_file_text, "class Foo {");
  ExpectDoesNotHaveSubstr(h_file_text, "class Foo1");
  ExpectDoesNotHaveSubstr(h_file_text, "class Foo2");

  // With ApiDef
  TF_ASSERT_OK(api_def_map.LoadApiDef(api_def));
  GenerateCcOpFiles(env, op_defs, api_def_map, &h_file_text,
                    &internal_h_file_text);
  ExpectHasSubstr(h_file_text, "class Foo1");
  ExpectHasSubstr(h_file_text, "typedef Foo1 Foo2");

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

/*
void foo1(void) {}
void foo2(void* p) {}
*/
import "C"
import (
	"fmt"
	"os"
	"runtime"
	"strconv"
	"time"
	"unsafe"
)

func init() {
	register("CgoSignalDeadlock", CgoSignalDeadlock)
	register("CgoTraceback", CgoTraceback)

            #import "foo.h"

            void sayFoo1()
            {
                NSFileHandle *stdout = [NSFileHandle fileHandleWithStandardOutput];
                NSData *strData = [@"foo1" dataUsingEncoding: NSASCIIStringEncoding];
                [stdout writeData: strData];
            }
        """),
                sourceFile("objcpp/foo2", "foo.mm", """
            #import <iostream>
            #import "foo.h"

// in inlined functions.  Issue 3593.

package main

var did int

func main() {
	foo(side())
	foo2(side(), side())
	foo3(side(), side())
	T.m1(T(side()))
	T(1).m2(side())
	const want = 7
	if did != want {
		println("BUG: missing", want-did, "calls")
	}
}

func foo(_ int) {}
func foo2(_, _ int) {}
func foo3(int, int) {}
type T int
func (_ T) m1() {}
func (t T) m2(_ int) {}

func side() int {

// 	var b Bar[t]
// 	f.Foo(&b)
// 	return t(b)
// }

// Test case 2 from issue

// For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639).
// type Fooer2[t any] interface {
// 	Foo()
// }
// 
// type Foo2[t any] t
// 
// func (f *Foo2[t]) Foo() {}
// 
// func _[t any](v t) {
// 	var f = Foo2[t](v)
// 	_ = Fooer2[t](&f)

        def foo1 = Attribute.of("foo", String)
        def foo2 = Attribute.of("foo", String)
        def attr3 = Attribute.of("baz", String)

        given:

        ImmutableAttributes[] candidates = [candidate(ImmutableMap.of(attr3, "v2", foo1, "v2"))]
        AttributeContainer requested = attribute(attr3, "v3")
        attributesSchema.getAttributeByName("foo") >> foo2

        when:

			Size:        2,
		},
		{
			ID:          "3",
			RepoTags:    []string{"foo-tag31", "foo-tag32"},
			RepoDigests: []string{"foo-rd31", "foo-rd32"},
			Size:        3,
		},
		{
			ID:          "4",
			RepoTags:    []string{"foo-tag41", "foo-tag42"},
			RepoDigests: []string{"foo-rd41", "foo-rd42"},
			Size:        3,
		},
	}
}

func TestByImageSizeLen(t *testing.T) {

func TestFinalizerOnGlobal(t *testing.T) {
	runtime.SetFinalizer(Foo1, func(p *Object1) {})
	runtime.SetFinalizer(Foo2, func(p *Object2) {})
	runtime.SetFinalizer(Foo1, nil)
	runtime.SetFinalizer(Foo2, nil)
}

type Object1 struct {
	Something []byte
}

type Object2 struct {
	Something byte
}

var (
	Foo2 = &Object2{}
	Foo1 = &Object1{}
)

func TestDeferKeepAlive(t *testing.T) {

				simpleEndpointSlice("foo1", "10.1.2.3", discovery.AddressTypeIPv4),
				simpleEndpointSlice("foo2", "10.3.4.5", discovery.AddressTypeIPv4),
			},
			toDelete: []*discovery.EndpointSlice{simpleEndpointSlice("bar", "10.2.3.4", discovery.AddressTypeIPv4)},
		},
		expectedSlices: &slicesByAction{
			toCreate: []*discovery.EndpointSlice{simpleEndpointSlice("foo2", "10.3.4.5", discovery.AddressTypeIPv4)},