UpgradeResult result = orchestrator.executeStrategies(context, pomMap);

            // The orchestrator may handle exceptions gracefully and continue
            assertNotNull(result, "Result should not be null");
            // We can't guarantee failure behavior without knowing the exact implementation
        }
    }

    @Nested

        for (BoundType aLowType : BoundType.values()) {
          for (BoundType aHighType : BoundType.values()) {
            if ((aLow == aHigh && aLowType == OPEN && aHighType == OPEN) || aLow > aHigh) {
              continue;
            }
            for (int bLow = 0; bLow < 6; bLow++) {
              for (int bHigh = 0; bHigh < 6; bHigh++) {
                for (BoundType bLowType : BoundType.values()) {

  var previousMappedRanges: List<MappedRange>? = null

  for ((section, sectionMappedRanges) in sections) {
    // Skip sequential ranges when they are equal.
    if (sectionMappedRanges == previousMappedRanges) continue
    previousMappedRanges = sectionMappedRanges

    val sectionOffset = rangesBuffer.size.toInt() / 4

    // Section prefix.
    sectionIndexBuffer.writeByte(section and 0x1fc000 shr 14)

Now let's extend this example and add more details to see how to test different parts.

### Extended **FastAPI** app file { #extended-fastapi-app-file }

Let's continue with the same file structure as before:

```
.
├── app
│   ├── __init__.py
│   ├── main.py
│   └── test_main.py
```

            return Collections.emptyList();
        }
        for (final Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>> pair : boostList) {
            if (!keyMatch.getId().equals(pair.getValue1())) {
                continue;
            }
            final FessConfig fessConfig = ComponentUtil.getFessConfig();
            return searchEngineClient.getDocumentList(fessConfig.getIndexDocumentSearchIndex(), searchRequestBuilder -> {

        when {
          // Compute the delay of the soonest-executable task.
          candidateDelay > 0L -> {
            minDelayNanos = minOf(candidateDelay, minDelayNanos)
            continue@eachQueue
          }

          // If we already have more than one task, that's enough work for now. Stop searching.
          readyTask != null -> {
            multipleReadyTasks = true

		return err
	}

	files, err := store.list()
	if err != nil {
		return err
	}

	for _, file := range files {
		if file.IsDir() {
			continue
		}
		if fi, err := file.Info(); err == nil {
			store.entries[file.Name()] = fi.ModTime().UnixNano()
		}
	}

	return nil
}

// Delete - Remove the store directory from disk

			if n, err := w.ReadFrom(r); err != nil || n != int64(len(input)) {
				t.Errorf("ws[%d],rs[%d]: w.ReadFrom(r) = %d, %v, want %d, nil", wi, ri, n, err, len(input))
				continue
			}
			if err := w.Flush(); err != nil {
				t.Errorf("Flush returned %v", err)
				continue
			}
			if got, want := b.String(), string(input); got != want {
				t.Errorf("ws[%d], rs[%d]:\ngot  %q\nwant %q\n", wi, ri, got, want)
			}
		}
	}

			// metric group, so that it will affect collection. If no buckets
			// are provided, we will not return bucket metrics.
			if bmg, ok := h.metricsData.bucketMGMap[collectorPath]; ok {
				if len(buckets) == 0 {
					continue
				}
				unLocker := bmg.LockAndSetBuckets(buckets)
				defer unLocker()
			}
			gatherers = append(gatherers, gatherer)
		}
	}

	if len(gatherers) == 0 {
		return notFoundHandler
	}

				return
			}
		}
	}()

	// Start parsers
	for range runtime.GOMAXPROCS(0) {
		go func() {
			for in := range r.input {
				if len(in.input) == 0 {
					in.dst <- nil
					continue
				}
				dst := r.kvDstPool.Get()
				if len(dst) < 1000 {
					dst = make([]jstream.KVS, 0, 1000)
				}

				d := jstream.NewDecoder(bytes.NewBuffer(in.input), 0).ObjectAsKVS().MaxDepth(100)