func (b *protobuf) startMessage() msgOffset {
	b.nest++
	return msgOffset(len(b.data))
}

func (b *protobuf) endMessage(tag int, start msgOffset) {
	n1 := int(start)
	n2 := len(b.data)
	b.length(tag, n2-n1)
	n3 := len(b.data)
	copy(b.tmp[:], b.data[n2:n3])
	copy(b.data[n1+(n3-n2):], b.data[n1:n2])
	copy(b.data[n1:], b.tmp[:n3-n2])
	b.nest--

import org.junit.*;

import play.mvc.*;
import play.test.*;
import play.libs.F.*;

import static play.test.Helpers.*;
import static org.fest.assertions.Assertions.*;

import static org.fluentlenium.core.filter.FilterConstructor.*;

public class IntegrationTest {

    /**
     * add your integration test here
     * in this example we just check if the welcome page is being shown
     */
    @Test
    public void test() {

    def "can nest included plugin builds"() {
        when:
        settingsFile << """
            pluginManagement {
                includeBuild("${build1.buildName}")
            }
        """
        build1.settingsFile << """
            includeBuild("../${build2.buildName}")
        """

        then:
        succeeds()
    }

    def "can nest early included plugin builds"() {

import play.data.validation.Constraints.RequiredValidator;
import play.i18n.Lang;
import play.libs.F;
import play.libs.F.*;
import play.twirl.api.Content;

import static play.test.Helpers.*;
import static org.fest.assertions.Assertions.*;


/**
*
* Simple (JUnit) tests that can call all parts of a play app.
* If you are interested in mocking a whole application, see the wiki for more details.
*
*/

    handler: Handler = logHandler(),
  ): Closeable {
    val logger = Logger.getLogger(loggerClass)
    if (configuredLoggers.add(logger)) {
      logger.addHandler(handler)
      logger.level = Level.FINEST
    }
    return Closeable {
      logger.removeHandler(handler)
    }
  }

  fun enable(loggerClass: KClass<*>) = enable(loggerClass.java.name)

            assert context.current().id == id
            assert context.current().source == source
        }

        and:
        context.current() == null
    }

    def "can nest application"() {
        def source = Stub(UserCodeSource)
        def source2 = Stub(UserCodeSource)
        def action = Mock(Action)
        def action2 = Mock(Action)
        def id1

        when:

            route:
              action: ANY
      patch:
        operation: MERGE
        value:
          rate_limits:
            - actions: # any actions in here
                  # Multiple actions nest the descriptors
                  # - generic_key:
                  # descriptor_value: "test"
              - request_headers:
                  header_name: ":path"
                  descriptor_key: "PATH"

            route:
              action: ANY
      patch:
        operation: MERGE
        value:
          rate_limits:
            - actions: # any actions in here
                  # Multiple actions nest the descriptors
                  # - generic_key:
                  # descriptor_value: "test"
              - request_headers:
                  header_name: ":path"
                  descriptor_key: "PATH"

      }
    }

  private var previousLevel: Level? = null

  override fun beforeEach(context: ExtensionContext?) {
    previousLevel = logger.level
    logger.addHandler(handler)
    logger.setLevel(Level.FINEST)
  }

  override fun afterEach(context: ExtensionContext?) {
    logger.setLevel(previousLevel)
    logger.removeHandler(handler)
  }

  override fun apply(
    base: Statement,

    /**
     * Configures debug logging.
     *
     * When enabled, {@link net.rubygrapefruit.platform.internal.jni.NativeLogger} will emit {@link java.util.logging.Level#FINEST} logs.
     */
    void setDebugLoggingEnabled(boolean debugLoggingEnabled);

    /**
     * Close the watcher registry. Stops watching without handling the changes.
     */
    @Override