}

func TestMultiWatcherShouldNotifyHandlers(t *testing.T) {
	watcherShouldNotifyHandlers(t, true)
}

func watcherShouldNotifyHandlers(t *testing.T, multi bool) {
	path := newTempFile(t)

	m := mesh.DefaultMeshConfig()
	writeMessage(t, path, m)

	w := newWatcher(t, path, multi)
	assert.Equal(t, w.Mesh(), m)

	doneCh := make(chan struct{}, 1)

	var newM *meshconfig.MeshConfig
	w.AddMeshHandler(func() {
		newM = w.Mesh()

  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.sonatype.mavenbook.multi</groupId>
    <artifactId>simple-parent</artifactId>
  </parent>

  <artifactId>simple-webapp</artifactId>
  <name>Multi Chapter Simple Web Application Project</name>
  <dependencies>
    <dependency>
      <groupId>org.sonatype.mavenbook.multi</groupId>
      <artifactId>simple-weather</artifactId>
    </dependency>
  </dependencies>

					{Name: "single2", Type: "string"},
					{Name: "multi", Type: "string"},
				},
				additionalColumns: []columnPrinter{
					newJSONPath("valueOnly", "{.spec.servers[0].hosts[0]}"),
					newJSONPath("single1", "{.spec.servers[0].hosts}"),
					newJSONPath("single2", "{.spec.servers[1].hosts}"),
					newJSONPath("multi", "{.spec.servers[*].hosts}"),
				},
			},
			args: args{

    private static final byte[] INSTRUMENTED_CLASS = new byte[]{2}
    private static final byte[] INSTRUMENTED_VERSIONED_CLASS = new byte[]{20}

    def "replaces original class with transformed in non-multi-release JAR"() {
        given:
        def original = jar(testDir.file("original.jar")) {
            manifest {}

            entry("Foo.class", ORIGINAL_CLASS)
        }

                // If the original JAR is not multi-release, we don't need the manifest in the transformed JAR at all.
                return;
            }
            isMultiReleaseJar = true;

            // We want the transformed JAR to also be a proper multi-release JAR.
            // To do so it must have the "Multi-Release: true" attribute.
            // "Manifest-Version" attribute is also required.

Leonardo Sarra <******@****.***> 1718116194 +0200

This sample shows how build logic in a multi-project build can be organized into reusable plugins.

== Use case

As an example, let's say a project with three subprojects produces two public Java libraries that use the third subproject as an internal shared library.
This is the project structure:

====
[.multi-language-sample]
=====
.Project structure
[source, kotlin]
----

        hasProject(gradleProjects, rootSingle, ':', 'A')

        where:
        modelType << buildScopedModels
    }

    def "ProjectConnection provides all GradleProjects for root of multi-project build"() {
        when:
        def gradleProjects = getGradleProjectsWithProjectConnectionUsingBuildModel(rootMulti, modelType)

        then:
        gradleProjects.size() == 3

	panic("important multi-line\nstringer message")
}

func StringerPanic() {
	panic(exampleStringer{})
}

type examplePanicStringer struct{}

func (s examplePanicStringer) String() string {
	panic(exampleStringer{})
}

func DoubleStringerPanic() {
	panic(examplePanicStringer{})
}

func StringPanic() {
	panic("important multi-line\nstring message")
}

// See the License for the specific language governing permissions and
// limitations under the License.

[[tweaking_structure]]
= Multi-project Build Considerations and Optimizations