return removeKeys(TimeKey, LevelKey, MessageKey, "a", "b")(groups, attr)
			},
			attrs:    []Attr{Group("i", Int("c", 3))},
			wantText: "g.n=4 g.h.i.c=3",
			wantJSON: `{"g":{"n":4,"h":{"i":{"c":3}}}}`,
		},
		{
			name: "replace partial empty attrs 3",
			with: func(h Handler) Handler {

				commit: func() {
					temp = temp + 2
				},
				revert: func() {
					temp = temp - 2
				},
			},
			callbackTransaction{
				commit: func() {
					temp = temp + 3
				},
				revert: func() {
					temp = temp - 3
				},
			},
		},
		want: 10,
	}, {
		name: "missing revert",
		mt: metaTransaction{
			callbackTransaction{
				commit: func() {
					temp = temp + 1
				},

go build -a -n -ldflags=-X=math.pi=3 my/cmd/prog
stderr 'link.* -X=math.pi=3'

# -ldflags applies to link of command even with strange directory name
go build -a -n -ldflags=-X=math.pi=3 my/cmd/prog/
stderr 'link.* -X=math.pi=3'

# -ldflags applies to current directory
cd my/cmd/prog
go build -a -n -ldflags=-X=math.pi=3
stderr 'link.* -X=math.pi=3'

			name:        "event not blocked when tokens available",
			serverBurst: 3,
			requests: []request{
				newEventRequest(),
			},
		},
		{
			name:        "non-event not blocked",
			serverBurst: 3,
			requests: []request{
				newNonEventRequest(),
			},
		},
		{
			name:        "event blocked after tokens exhausted",
			serverBurst: 3,
			requests: []request{
				newEventRequest(),

        list.addLast("2");
        assertThat(list.remove("3"), is(not(true)));
        assertThat(list.remove("1"), is(true));
        assertThat(list.remove(null), is(true));
        list.clear();
        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        list.remove(1);
        assertThat(list.get(0), is("1"));
        assertThat(list.get(1), is("3"));

        list.clear();

volumes:
  data1-1:
  data1-2:
  data1-3:
  data2-1:
  data2-2:
  data2-3:
  data3-1:
  data3-2:
  data3-3:
  data4-1:
  data4-2:

	fmt.Printf("%o %o", 3, i)
	fmt.Printf("%p", p)
	fmt.Printf("%q %q %q %q", 3, i, 'x', r)
	fmt.Printf("%s %s %s", "hi", s, []byte{65})
	fmt.Printf("%t %t", true, b)
	fmt.Printf("%T %T", 3, i)
	fmt.Printf("%U %U", 3, i)
	fmt.Printf("%v %v", 3, i)
	fmt.Printf("%x %x %x %x %x %x %x", 3, i, "hi", s, x, c, fslice)
	fmt.Printf("%X %X %X %X %X %X %X", 3, i, "hi", s, x, c, fslice)

		v := recover()
		if v == nil || v.(int) != 2 {
			println("wrong value", v, 2)
			die()
		}
		defer mustRecover(3)
		panic(3)
	}()
	panic(2)
}

func test3() {
	// Sequential panic - like test2 but less picky.
	defer mustNotRecover()
	defer func() {
		recover()
		defer mustRecover(3)
		panic(3)
	}()
	panic(2)
}

func test4() {
	// Single panic.
	defer mustNotRecover()
	defer func() {

		panic("fail")
	}
	if (*S1).val(ps) != 2 {
		println("(*S1).val(ps):", (*S1).val(ps))
		panic("fail")
	}
	if i.val() != 3 {
		println("i.val:", i.val())
		panic("fail")
	}
	if I.val(i) != 3 {
		println("I.val(i):", I.val(i))
		panic("fail")
	}
	if (*I).val(&i) != 3 {
		println("(*I).val(&i):", (*I).val(&i))
		panic("fail")
	}
	if pi.val() != 4 {
		println("pi.val:", pi.val())
		panic("fail")
	}

		panic("fail")
	}
}

func i64run() {
	var a, b int64

	for i := 0; i < Count; i++ {
		a = i64rand()

		b = a / 1
		i64test(a, b, 1)
		b = a / 2
		i64test(a, b, 2)
		b = a / 3
		i64test(a, b, 3)
		b = a / 4
		i64test(a, b, 4)
		b = a / 5
		i64test(a, b, 5)
		b = a / 6
		i64test(a, b, 6)
		b = a / 7
		i64test(a, b, 7)
		b = a / 8
		i64test(a, b, 8)
		b = a / 10
		i64test(a, b, 10)