}
	return tag
}

func appendSettingFromTag(tag reflect.StructTag, value string) reflect.StructTag {
	t := tag.Get("gorm")
	if strings.Contains(t, value) {
		return tag
	}
	return reflect.StructTag(fmt.Sprintf(`gorm:"%s;%s"`, value, t))
}

// GetRelationsValues get relations's values from a reflect value

        Objects.requireNonNull(input, "input cannot be null");

        try (Reader in = input) {
            InputSource source = (InputSource) options.get(InputSource.class.getName());
            return new PersistedToolchains(new MavenToolchainsStaxReader().read(in, isStrict(options), source));
        } catch (XMLStreamException e) {
            throw new ToolchainsParseException(

      dummy += algorithm.multipleQuantiles(ImmutableSet.of(90, 99), 100, dataset(i)).get(90);
    }
    return dummy;
  }

  @Benchmark
  double threePercentiles(int reps) {
    double dummy = 0.0;
    for (int i = 0; i < reps; i++) {
      dummy += algorithm.multipleQuantiles(ImmutableSet.of(90, 95, 99), 100, dataset(i)).get(90);
    }
    return dummy;
  }

  @Benchmark
  double allDeciles(int reps) {

  private final int size;
  private int position;

  /** Returns the element with the specified index. This method is called by {@link #next()}. */
  @ParametricNullness
  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link

        repository.find('class') == value
        repository.get('class') == value
    }

    def findReturnsNullForUnknownClass() {
        expect:
        repository.find('unknown') == null
    }

    def getFailsForUnknownClass() {
        given:
        repository.put('unkown', new TestDomainObject('unknown'))

        when:
        repository.get('unknown')

        then:

    assertThat(iia.get(0)).isEqualTo(0L);
    assertThat(iia.get(2)).isEqualTo(3L);
    assertThat(iia.subArray(1, 3).get(1)).isEqualTo(3L);
  }

  public void testGet_bad() {
    ImmutableLongArray iia = ImmutableLongArray.of(0, 1, 3);
    assertThrows(IndexOutOfBoundsException.class, () -> iia.get(-1));
    assertThrows(IndexOutOfBoundsException.class, () -> iia.get(3));

var (
	ODirectPoolLarge  = NewAlignedBytePool(LargeBlock)
	ODirectPoolMedium = NewAlignedBytePool(MediumBlock)
	ODirectPoolSmall  = NewAlignedBytePool(SmallBlock)
)

// Get a block.
func (p *AlignedBytePool) Get() *[]byte {
	return p.p.Get()
}

// Put a block.
func (p *AlignedBytePool) Put(pb *[]byte) {
	if pb != nil && len(*pb) == p.size {
		p.p.Put(pb)
	}
}

        final ProjectBuildList segments = buildList.getByTaskSegment(taskSegments.get(0));
        assertEquals(3, taskSegments.size(), "Stub data contains 3 segments");
        assertEquals(6, segments.size(), "Stub data contains 6 items");
        final ProjectSegment build = segments.get(0);
        assertNotNull(build);

        for (ProjectSegment segment : segments) {

    mod_name = f"docs_src.dependencies.{request.param}"
    mod = importlib.import_module(mod_name)
    return mod


def test_get_db(module: ModuleType):
    app = FastAPI()

    @app.get("/")
    def read_root(c: Annotated[Any, Depends(module.dependency_c)]):
        return {"c": str(c)}

    client = TestClient(app)

    a_mock = Mock()
    b_mock = Mock()
    c_mock = Mock()

    with (

        pytest.param("tutorial001_an_py310", marks=needs_py310),
    ],
)
def get_client(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.custom_request_and_route.{request.param}")

    @mod.app.get("/check-class")
    async def check_gzip_request(request: Request):
        return {"request_class": type(request).__name__}

    client = TestClient(mod.app)
    return client