response = client.get("/default1?level1=foo")
    assert response.json() == "foo"
    assert response.headers["content-type"] == "application/x-level-0"
    assert "x-level0" in response.headers
    assert "x-level1" not in response.headers
    assert "x-level2" not in response.headers
    assert "x-level3" not in response.headers
    assert "x-level4" not in response.headers
    assert "x-level5" not in response.headers

		t.Error(err)
	}

	want := make([]Level3, 2)
	want[0] = Level3{Level2: Level2{Level1: Level1{Value: "value"}}}
	if err := DB.Create(&want[0]).Error; err != nil {
		t.Error(err)
	}
	want[1] = Level3{Level2: Level2{Level1: Level1{Value: "value2"}}}
	if err := DB.Create(&want[1]).Error; err != nil {
		t.Error(err)
	}

	var got []Level3

// license that can be found in the LICENSE file.

// Test indirection level computation in escape analysis.

package escape

var sink interface{}

func level0() {
	i := 0     // ERROR "moved to heap: i"
	p0 := &i   // ERROR "moved to heap: p0"
	p1 := &p0  // ERROR "moved to heap: p1"
	p2 := &p1  // ERROR "moved to heap: p2"
	sink = &p2
}

func level1() {
	i := 0    // ERROR "moved to heap: i"

	{CaseName: Name(""), in: " 42 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 5}},
	{CaseName: Name(""), in: "\x01 true", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
	{CaseName: Name(""), in: " false \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 8}},

  <modelVersion>4.0.0</modelVersion>
  <groupId>group</groupId>
  <artifactId>level2</artifactId>
  <version>1</version>
  <packaging>jar</packaging>
</project>'''

		file("mavenRoot/group/level2/1/level2-1.jar").text = 'foo'

		file("mavenRoot/group/level2/2/level2-2.pom").text = '''\
<?xml version="1.0" encoding="UTF-8"?>

// Level range. OpenTelemetry also has the names TRACE and FATAL, which slog
// does not. But those OpenTelemetry levels can still be represented as slog
// Levels by using the appropriate integers.
const (
	LevelDebug Level = -4
	LevelInfo  Level = 0
	LevelWarn  Level = 4
	LevelError Level = 8
)

// String returns a name for the level.
// If the level has a name, then that name
// in uppercase is returned.

package diag

import (
	"strings"
)

// Level is the severity level of a message.
type Level struct {
	sortOrder int
	name      string
}

func (l Level) String() string {
	return l.name
}

func (l Level) IsWorseThanOrEqualTo(target Level) bool {
	return l.sortOrder <= target.sortOrder
}

var (
	// Info level is for informational messages
	Info = Level{2, "Info"}

Michael Hudgins <******@****.***> 1695048765 +0000

		if level == 1 {
			levels[level].nextPairFreq = math.MaxInt32
		}
	}

	// We need a total of 2*n - 2 items at top level and have already generated 2.
	levels[maxBits].needed = 2*n - 4

	level := maxBits
	for {
		l := &levels[level]
		if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 {
			// We've run out of both leafs and pairs.
			// End all calculations for this level.

            'org:foo:1.1'()
            'org:first-level1:1.0' {
                constraint 'org:foo:1.1'
            }
            'org:first-level2:1.0' {
                dependsOn 'org:foo:1.0'
            }
        }

        buildFile << """
            dependencies {
                conf 'org:first-level1:1.0'
                conf 'org:first-level2:1.0'
            }
        """