return new ImmutableAsList<C>() {
        @Override
        ImmutableSortedSet<C> delegateCollection() {
          return RegularContiguousSet.this;
        }

        @Override
        public C get(int i) {
          checkElementIndex(i, size());
          return domain.offset(first(), i);
        }

        // redeclare to help optimizers with b/310253115
        @SuppressWarnings("RedundantOverride")

    CACHE 1
);
	`).Error; err != nil {
		t.Fatalf("failed to create table, got error %v", err)
	}

	columns, err := DB.Migrator().ColumnTypes("log_usage")
	if err != nil {
		t.Fatalf("failed to get columns, got error %v", err)
	}

	hasLogID := false
	for _, column := range columns {
		if column.Name() == "log_id" {
			hasLogID = true
			autoIncrement, ok := column.AutoIncrement()

        String value = "${var1}-${var2}";
        assertEquals("value1-value2", ResourceUtil.resolve(value));

        // Test nested-like patterns (but not actual nesting)
        value = "${var1${var2}}"; // The ${var2} part gets replaced first
        assertEquals("${var1value2}", ResourceUtil.resolve(value));

        // Test with special characters in replacement
        System.setProperty("special", "value$with\\backslash");

            cb.query().addOrderBy_SortOrder_Asc();
        });
        if (list.isEmpty()) {
            return OptionalEntity.empty();
        }
        return OptionalEntity.of(list.get(0));
    }

    /**
     * Stores a file configuration in the database.
     * This method encrypts the configuration parameters before saving and

        /**
         * Returns the algorithm end result as string, never {@code null}. After invoking this method, this instance should
         * be discarded and not reused. For new checksum calculation you have to get new instance.
         */
        @Nonnull
        String checksum();
    }

#### A "professional" attack { #a-professional-attack }

Of course, the attackers would not try all this by hand, they would write a program to do it, possibly with thousands or millions of tests per second. And they would get just one extra correct letter at a time.

But doing that, in some minutes or hours the attackers would have guessed the correct username and password, with the "help" of our application, just using the time taken to answer.

* `allow_methods` - A list of HTTP methods that should be allowed for cross-origin requests. Defaults to `['GET']`. You can use `['*']` to allow all standard methods.

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

Припустимо, що тепер файл `main.py` із вашим застосунком **FastAPI** містить інші **операції шляху**.

Він має `GET`-операцію, яка може повертати помилку.

Він має `POST`-операцію, яка може повертати кілька помилок.

Обидві *операції шляху* вимагають заголовок `X-Token`.

{* ../../docs_src/app_testing/app_b_an_py310/main.py *}

		reqRecorder := &xhttp.RequestRecorder{Reader: r.Body}
		r.Body = reqRecorder

		// Create tracing data structure and associate it to the request context
		tc := mcontext.TraceCtxt{
			AmzReqID:         w.Header().Get(xhttp.AmzRequestID),
			RequestRecorder:  reqRecorder,
			ResponseRecorder: respRecorder,
		}

		r = r.WithContext(context.WithValue(r.Context(), mcontext.ContextTraceKey, &tc))

		reqStartTime := time.Now().UTC()

	m.mu.RUnlock()
	if ok {
		return b.updateCacheEntry(update)
	}

	// We should have either a trashed bucket or this
	return metacache{}, errVolumeNotFound
}

// getBucket will get a bucket metacache or load it from disk if needed.
func (m *metacacheManager) getBucket(ctx context.Context, bucket string) *bucketMetacache {
	m.init.Do(m.initManager)