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"

STRINGTABLE
{
    IDS_FOO2, "foo2"
}
""")]

    }

    @Override
    List<SourceFile> getHeaderFiles() {

#include "resources.h"

STRINGTABLE
{
    IDS_HELLO,   "Hello world!"

}
"""),
        new SourceFile("rc", "resources.rc", """
#include "hello.h"

// HACK: Ensure include root are correctly setup
// See: https://github.com/gradle/gradle/issues/3662
#include "winres.h"

STRINGTABLE
{
    #ifdef FRENCH
    IDS_HELLO, "${HELLO_WORLD_FRENCH}"
    #else
    IDS_HELLO, "${HELLO_WORLD}"
    #endif
}
""")
    ]

    List<SourceFile> getResourceSources() {

import java.util.concurrent.TimeUnit
import mockwebserver3.Stream
import mockwebserver3.StreamHandler
import okio.utf8Size

private typealias Action = (Stream) -> Unit

/**
 * A scriptable request/response conversation. Create the script by calling methods like
 * [receiveRequest] in the sequence they are run.
 */
class MockStreamHandler : StreamHandler {
  private val actions = LinkedBlockingQueue<Action>()

	Sections       []*Section
	Symbols        []*Symbol    // COFF symbols with auxiliary symbol records removed
	COFFSymbols    []COFFSymbol // all COFF symbols (including auxiliary symbol records)
	StringTable    StringTable

	closer io.Closer
}

// Open opens the named file using [os.Open] and prepares it for use as a PE binary.
func Open(name string) (*File, error) {
	f, err := os.Open(name)
	if err != nil {

	// one byte. Further, the staticTable has a fixed, small length.
	return d.dynTab.table.len() + staticTable.len()
}

func (d *Decoder) at(i uint64) (hf HeaderField, ok bool) {
	// See Section 2.3.3.
	if i == 0 {
		return
	}
	if i <= uint64(staticTable.len()) {
		return staticTable.ents[i-1], true
	}
	if i > uint64(d.maxTableIndex()) {
		return
	}

// meaning t.ents is reversed for dynamic tables. Hence, when t is a dynamic
// table, the return value i actually refers to the entry t.ents[t.len()-i].
//
// All tables are assumed to be a dynamic tables except for the global staticTable.
//
// See Section 2.3.3.
func (t *headerFieldTable) search(f HeaderField) (i uint64, nameValueMatch bool) {
	if !f.Sensitive {
		if id := t.byNameValue[pairNameValue{f.Name, f.Value}]; id != 0 {

pkg database/sql, type TxOptions struct, ReadOnly bool
pkg debug/pe, method (*COFFSymbol) FullName(StringTable) (string, error)
pkg debug/pe, method (StringTable) String(uint32) (string, error)
pkg debug/pe, type File struct, COFFSymbols []COFFSymbol
pkg debug/pe, type File struct, StringTable StringTable
pkg debug/pe, type Reloc struct
pkg debug/pe, type Reloc struct, SymbolTableIndex uint32

// becomes false.
func (e *Encoder) searchTable(f HeaderField) (i uint64, nameValueMatch bool) {
	i, nameValueMatch = staticTable.search(f)
	if nameValueMatch {
		return i, true
	}

	j, nameValueMatch := e.dynTab.table.search(f)
	if nameValueMatch || (i == 0 && j != 0) {
		return j + uint64(staticTable.len()), nameValueMatch
	}

	return i, false
}

		if !ok {
			continue
		}
		sym := &f.COFFSymbols[k]
		if sym.NumberOfAuxSymbols == 0 {
			t.Errorf("expected aux symbols for sym %d", k)
			continue
		}
		name, nerr := sym.FullName(f.StringTable)
		if nerr != nil {
			t.Errorf("FullName(%d) failed with %v", k, nerr)
			continue
		}
		if name != tp.name {
			t.Errorf("name check for %d, got %s want %s", k, name, tp.name)
			continue
		}