serviceRegistry := map[host.Name]*model.Service{
			"*.example.org":             exampleWildcardService,
			"goodbye.hello.example.org": exampleNestedWildcardService,
		}

		wildcardIndex := map[host.Name]types.NamespacedName{
			"*.example.org":       virtualServiceWithWildcardHost.NamespacedName(),
			"*.hello.example.org": virtualServiceWithNestedWildcardHost.NamespacedName(),
		}

	}
	if string(b) != "hello" {
		t.Fatalf("Read: have %q want %q", string(b), "hello")
	}
}

// Verify that ReadAt doesn't allow negative offset.
func TestReadAtNegativeOffset(t *testing.T) {
	t.Parallel()

	f := newFile("TestReadAtNegativeOffset", t)
	defer Remove(f.Name())
	defer f.Close()

	const data = "hello, world\n"
	io.WriteString(f, data)

    def injectsGenericTypesFromParentIntoProviderFactoryMethod() {
        def parent = new DefaultServiceRegistry() {
            @Provides
            Callable<String> createStringCallable() {
                return { "hello" }
            }

            @Provides
            Factory<String> createStringFactory() {
                return { "world" } as Factory
            }
        }

    server.protocols = Arrays.asList(Protocol.HTTP_2, Protocol.HTTP_1_1)
    requestBodySuccess(
      "Hello".toRequestBody("text/plain".toMediaType()),
      CoreMatchers.equalTo(5L),
      CoreMatchers.equalTo(19L),
    )
  }

  @Test
  fun requestBodySuccessHttp() {
    requestBodySuccess(
      "Hello".toRequestBody("text/plain".toMediaType()),
      CoreMatchers.equalTo(5L),
      CoreMatchers.equalTo(19L),

[source.multi-language-sample,c]
.src/hello/headers/pch.h
----
include::{snippetsPath}/native-binaries/pre-compiled-headers/groovy/src/hello/headers/pch.h[]
----

=== Example: Including a precompiled header file in a source file

[source.multi-language-sample,cpp]
.src/hello/cpp/hello.cpp
----
include::{snippetsPath}/native-binaries/pre-compiled-headers/groovy/src/hello/cpp/hello.cpp[]
----

		t.Errorf("response X-Modified header = %q; want %q", got, want)
	}

	io.WriteString(rwc, "Hello\n")
	bs := bufio.NewScanner(rwc)
	if !bs.Scan() {
		t.Fatalf("Scan: %v", bs.Err())
	}
	got = bs.Text()
	want = `backend got "Hello"`
	if got != want {
		t.Errorf("got %#q, want %#q", got, want)
	}
}

  //
  // templates:
  //   hello: |
  //     metadata:
  //       labels:
  //         hello: world
  //
  // Then starting a pod with the `inject.istio.io/templates: hello` annotation, will result in the pod
  // being injected with the hello=world labels.
  // This is intended for advanced configuration only; most users should use the built in template

from .main import app

client = TestClient(app)


@pytest.mark.parametrize(
    "path,expected_status,expected_response",
    [
        ("/api_route", 200, {"message": "Hello World"}),
        ("/non_decorated_route", 200, {"message": "Hello World"}),
        ("/nonexistent", 404, {"detail": "Not Found"}),
    ],
)
def test_get_path(path, expected_status, expected_response):
    response = client.get(path)

	e.EncodeToken(start)
	e.EncodeToken(CharData([]byte("hello world")))
	e.EncodeToken(EndElement{start.Name})
	return nil
}

type MyMarshalerAttrTest struct {
}

var _ MarshalerAttr = (*MyMarshalerAttrTest)(nil)

func (m *MyMarshalerAttrTest) MarshalXMLAttr(name Name) (Attr, error) {
	return Attr{name, "hello world"}, nil
}

                hasAttribute('custom', 'hello')
            }
            dependency('publishTest:utils:1.0') {
                hasAttribute('custom', 'bazinga')
            }
            noMoreDependencies()
        }

        javaLibrary.parsedModuleMetadata.variant('runtimeElements') {
            dependency('org.test:bar:1.0') {
                hasAttribute('custom', 'hello')
            }