configurations.lax.files
                    } catch (Exception e) {
                        println "Lax failure swallowed"
                    }

                    // Try to resolve configuration "lax" again - this exception is printed
                    configurations.lax.files
                }
            }
        """

        when:
        moduleA.pom.expectGetBlocking()

 * flightNetwork.addEdge("LAX", "ATL", 3025);
 * flightNetwork.addEdge("LAX", "ATL", 1598);
 * flightNetwork.addEdge("ATL", "LAX", 2450);
 *
 * // Building a immutable network
 * ImmutableNetwork<String, Integer> immutableNetwork =
 *     NetworkBuilder.directed()
 *         .allowsParallelEdges(true)
 *         .<String, Integer>immutable()
 *         .addEdge("LAX", "ATL", 3025)
 *         .addEdge("LAX", "ATL", 1598)

 * flightNetwork.addEdge("LAX", "ATL", 3025);
 * flightNetwork.addEdge("LAX", "ATL", 1598);
 * flightNetwork.addEdge("ATL", "LAX", 2450);
 *
 * // Building a immutable network
 * ImmutableNetwork<String, Integer> immutableNetwork =
 *     NetworkBuilder.directed()
 *         .allowsParallelEdges(true)
 *         .<String, Integer>immutable()
 *         .addEdge("LAX", "ATL", 3025)
 *         .addEdge("LAX", "ATL", 1598)

						object["apiVersion"] = apiVersion
						object["kind"] = kind
					}

					if object["kind"] == "" {
						strict, lax = nil, runtime.NewMissingKindErr(diagnose(data))
						return
					}
					if object["apiVersion"] == "" {
						strict, lax = nil, runtime.NewMissingVersionErr(diagnose(data))
						return
					}

					unstructureds[i].Object = object
				}
				delete(content, "items")

// go into an infinite loop when handling negative dereference
// cycles. The critical thing being tested here is that compilation
// succeeds ("errorcheck -0"), not any particular diagnostic output,
// hence the very lax ERROR patterns below.

package p

type Node struct {
	Orig *Node
}

var sink *Node

func f1() {
	var n Node // ERROR "."
	n.Orig = &n

	m := n // ERROR "."
	sink = &m
}

    assertThat(parse(url, "a=b; SameSite= ")!!.sameSite).isEqualTo("")
    assertThat(parse(url, "a= b; SameSite= Lax")!!.sameSite).isEqualTo("Lax")
    assertThat(parse(url, "a=b ; SameSite=Lax ;")!!.sameSite).isEqualTo("Lax")
    assertThat(parse(url, "a=\r\t \nb\n; \rSameSite=\n \tLax")!!.sameSite).isEqualTo("Lax")
  }

  @Test fun builderSameSiteTrimmed() {
    var cookieBuilder =
      Cookie.Builder()
        .name("a")

		{in: "foo bar=3d", want: "foo bar="}, // lax.
		{in: "foo bar=\n", want: "foo bar"},
		{in: "foo bar\n", want: "foo bar\n"}, // somewhat lax.
		{in: "foo bar=0", want: "foo bar=0"}, // lax
		{in: "foo bar=0D=0A", want: "foo bar\r\n"},
		{in: " A B        \r\n C ", want: " A B\r\n C"},
		{in: " A B =\r\n C ", want: " A B  C"},
		{in: " A B =\n C ", want: " A B  C"}, // lax. treating LF as CRLF
		{in: "foo=\nbar", want: "foobar"},

	},
	{
		&Cookie{Name: "cookie-12", Value: "samesite-default", SameSite: SameSiteDefaultMode},
		"cookie-12=samesite-default",
	},
	{
		&Cookie{Name: "cookie-13", Value: "samesite-lax", SameSite: SameSiteLaxMode},
		"cookie-13=samesite-lax; SameSite=Lax",
	},
	{
		&Cookie{Name: "cookie-14", Value: "samesite-strict", SameSite: SameSiteStrictMode},
		"cookie-14=samesite-strict; SameSite=Strict",
	},
	{

			into: struct {
				A int `json:"a"`
			}{},
			assertOnError: assertIdenticalError(&cbor.UnknownFieldError{Index: 0}),
		},
		{
			name:  "case-insensitive match ignored in lax mode",
			modes: []cbor.DecMode{modes.DecodeLax},
			in:    hex("a1614101"), // {"A": 1}
			into: struct {
				A int `json:"a"`
			}{},
			want: struct {
				A int `json:"a"`
			}{
				A: 0,
			},

	"CMPUBNE",
	"MVC",
	"MVCIN",
	"CLC",
	"XC",
	"OC",
	"NC",
	"EXRL",
	"LARL",
	"LA",
	"LAY",
	"LAA",
	"LAAG",
	"LAAL",
	"LAALG",
	"LAN",
	"LANG",
	"LAX",
	"LAXG",
	"LAO",
	"LAOG",
	"LMY",
	"LMG",
	"STMY",
	"STMG",
	"STCK",
	"STCKC",
	"STCKE",
	"STCKF",
	"CLEAR",
	"KM",
	"KMC",
	"KLMD",
	"KIMD",
	"KDSA",