and can be asserted as desired.

You can change/extend these stubs, and tests should not be breaking too much, since most tests
assert using expected values from the stubs. Normally, when you try to use data from the stubs that
have not been properly populated, you'll get a nullpointer in your test and you then have to
identify which stub creates that specific piece of data.

The most important stubs are:
LifecycleExecutionPlanCalculatorStub

    RangeMap<Integer, Integer> sub1 = rangeMap.subRangeMap(Range.closed(5, 11));
    assertEquals(
        ImmutableMap.of(Range.closedOpen(5, 7), 1, Range.closed(9, 10), 2), sub1.asMapOfRanges());
    RangeMap<Integer, Integer> sub2 = sub1.subRangeMap(Range.open(6, 15));
    assertEquals(
        ImmutableMap.of(Range.open(6, 7), 1, Range.closed(9, 10), 2), sub2.asMapOfRanges());
  }

	ADDE	R1, R2                // b9880021
	SUB	R3, R4                // b9090043
	SUB	R3, R4, R5            // b9e93054
	SUB	$8192, R3             // a73be000
	SUB	$8192, R3, R4         // ec43e00000d9
	SUBC	R1, R2                // b90b0021
	SUBC	$1, R1, R2            // ec21ffff00db
	SUBC	R2, R3, R4            // b9eb2043
	SUBW	R3, R4                // 1b43
	SUBW	R3, R4, R5            // b9f93054

t2) // Z3 := b * t2 x3.Sub(y3, z3) // X3 := Y3 - Z3 z3.Add(x3, x3) // Z3 := X3 + X3 x3.Add(x3, z3) // X3 := X3 + Z3 z3.Sub(t1, x3) // Z3 := t1 - X3 x3.Add(t1, x3) // X3 := t1 + X3 y3.Mul({{.p}}B(), y3) // Y3 := b * Y3 t1.Add(t2, t2) // t1 := t2 + t2 t2.Add(t1, t2) // t2 := t1 + t2 y3.Sub(y3, t2) // Y3 := Y3 - t2 y3.Sub(y3, t0) // Y3 := Y3 - t0 t1.Add(y3, y3) // t1 := Y3 + Y3 y3.Add(t1, y3) // Y3 := t1 + Y3 t1.Add(t0, t0) // t1 := t0 + t0 t0.Add(t1, t0) // t0 := t1 + t0 t0.Sub(t0, t2) // t0 := t0 -...

t2) // Z3 := b * t2 x3.Sub(y3, z3) // X3 := Y3 - Z3 z3.Add(x3, x3) // Z3 := X3 + X3 x3.Add(x3, z3) // X3 := X3 + Z3 z3.Sub(t1, x3) // Z3 := t1 - X3 x3.Add(t1, x3) // X3 := t1 + X3 y3.Mul({{.p}}B(), y3) // Y3 := b * Y3 t1.Add(t2, t2) // t1 := t2 + t2 t2.Add(t1, t2) // t2 := t1 + t2 y3.Sub(y3, t2) // Y3 := Y3 - t2 y3.Sub(y3, t0) // Y3 := Y3 - t0 t1.Add(y3, y3) // t1 := Y3 + Y3 y3.Add(t1, y3) // Y3 := t1 + Y3 t1.Add(t0, t0) // t1 := t0 + t0 t0.Add(t1, t0) // t0 := t1 + t0 t0.Sub(t0, t2) // t0 := t0 -...

	SETCC	AX
	SETCC	foo+4(SB)

// LTYPE2 rimnon	{ outcode(int($1), &$2); }
	DIVB	AX
	DIVB	foo+4(SB)
	PUSHL	$foo+4(SB)
	POPL		AX

// LTYPE3 rimrem	{ outcode(int($1), &$2); }
	SUBB	$1, AX
	SUBB	$1, foo+4(SB)
	SUBB	BX, AX
	SUBB	BX, foo+4(SB)

// LTYPE4 remrim	{ outcode(int($1), &$2); }
	CMPB	AX, $1
	CMPB	foo+4(SB), $4
	CMPB	BX, AX
	CMPB	foo+4(SB), BX

// LTYPER nonrel	{ outcode(int($1), &$2); }
label:

	NEGQ	foo+4(SB)

// LTYPE2 rimnon	{ outcode($1, &$2); }
	INT	$4
	DIVB	R11
	DIVB	4(R11)
	DIVB	foo+4(SB)

// LTYPE3 rimrem	{ outcode($1, &$2); }
	SUBQ $4, DI
	SUBQ R11, DI
	SUBQ 4(R11), DI
	SUBQ foo+4(SB), DI
	SUBQ $4, 8(R12)
	SUBQ R11, 8(R12)
	SUBQ R11, foo+4(SB)

// LTYPE4 remrim	{ outcode($1, &$2); }
	CMPB	CX, $4

// LTYPER nonrel	{ outcode($1, &$2); }
label:
	JB	-4(PC) // JCS -4(PC)

	}

	var sub1 []User
	// limit < batchSize
	if result := DB.Limit(5).Where("name = ?", users[0].Name).FindInBatches(&sub1, 10, func(tx *gorm.DB, batch int) error {
		return nil
	}); result.Error != nil || result.RowsAffected != 5 {
		t.Errorf("Failed to batch find, got error %v, rows affected: %v", result.Error, result.RowsAffected)
	}

	var sub2 []User
	// only offset

### Unteranwendung { #sub-application }

Erstellen Sie dann Ihre Unteranwendung und deren *Pfadoperationen*.

Diese Unteranwendung ist nur eine weitere Standard-FastAPI-Anwendung, aber diese wird „gemountet“:

{* ../../docs_src/sub_applications/tutorial001_py39.py hl[11, 14:16] *}

### Die Unteranwendung mounten { #mount-the-sub-application }

Sebastián Ramírez <******@****.***> 1731896744 +0100