return Config{}, err
		}
	} else {
		cfg.RRS.Parity = defaultRRSParity
		if setDriveCount == 1 {
			cfg.RRS.Parity = 0
		}
	}

	// Validation is done after parsing both the storage classes. This is needed because we need one
	// storage class value to deduce the correct value of the other storage class.
	if err = validateParity(cfg.Standard.Parity, cfg.RRS.Parity, setDriveCount); err != nil {
		return Config{}, err

```Python
from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}
```

### Dockerfile { #dockerfile }

Теперь в той же директории проекта создайте файл `Dockerfile`:

```{ .dockerfile .annotate }
# (1)!

master into your branch. A reviewer might ask you to rebase a
long-running pull request in which case force pushing is okay for that
request. Note that squashing at the end of the review process should
also not be done, that can be done when the pull request is [integrated
via GitHub](https://github.com/blog/2141-squash-your-commits).

Contributing to the Elasticsearch codebase
------------------------------------------

        final FessXpathTransformer transformer = new FessXpathTransformer();
        final String value = transformer.normalizeCanonicalUrl("http://example.com/", "/100%25/done");
        assertNotNull(value);
        assertEquals("http://example.com/100%25/done", value);
    }

    @Test
    public void test_normalizeCanonicalUrl_withQueryAndFragment() throws Exception {

		// user or a "virtual" user (parent of an STS account).
		//
		// If parent is a regular user => policy mapping is done on that parent itself.
		//
		// If parent is "virtual" => policy mapping is done on the virtual
		// parent and that virtual parent is an stsUser.
		//
		// To load the appropriate mapping, we check the parent user type.

  }

  public void testToArray() {
    // need explicit type parameter to avoid javac warning!?
    List<Boolean> none = Arrays.<Boolean>asList();
    assertThat(Booleans.toArray(none)).isEqualTo(EMPTY);

    List<Boolean> one = Arrays.asList(false);
    assertThat(Booleans.toArray(one)).isEqualTo(ARRAY_FALSE);

    boolean[] array = {false, false, true};

    List<Boolean> three = Arrays.asList(false, false, true);

        }
        result += sizeIfKnown.get();
        if (result < 0) {
          // Overflow (or one or more sources that returned a negative size, but all bets are off in
          // that case)
          // Can't represent anything higher, and realistically there probably isn't anything that
          // can actually be done anyway with the supposed 8+ exbibytes of data the source is
          // claiming to have if we get here, so just stop.

				CheckUser(t, models3[idx], user)
			})
		}
	}

	var none []User
	if err := DB.Where("name in (?)", []string{}).Find(&none).Error; err != nil || len(none) != 0 {
		t.Errorf("errors happened when query find with in clause and zero length parameter: %v, length: %v", err, len(none))
	}
}

func TestQueryWithAssociation(t *testing.T) {

    private final T value;
    private boolean done;

    SingletonIterator(T value) {
      this.value = value;
    }

    @Override
    public boolean hasNext() {
      return !done;
    }

    @Override
    @ParametricNullness
    public T next() {
      if (done) {
        throw new NoSuchElementException();
      }
      done = true;
      return value;
    }
  }

    private final T value;
    private boolean done;

    SingletonIterator(T value) {
      this.value = value;
    }

    @Override
    public boolean hasNext() {
      return !done;
    }

    @Override
    @ParametricNullness
    public T next() {
      if (done) {
        throw new NoSuchElementException();
      }
      done = true;
      return value;
    }
  }