private void assertLegacyQuery(GeoDistanceRangeQueryBuilder queryBuilder, Query query)
throws IOException {
assertThat(query, instanceOf(GeoDistanceRangeQuery.class));
GeoDistanceRangeQuery geoQuery = (GeoDistanceRangeQuery) query;
assertThat(geoQuery.fieldName(), equalTo(queryBuilder.fieldName()));
if (queryBuilder.point() != null) {
GeoPoint expectedPoint = new GeoPoint(queryBuilder.point());
if (GeoValidationMethod.isCoerce(queryBuilder.getValidationMethod())) {
GeoUtils.normalizePoint(expectedPoint, true, true);
}
assertThat(geoQuery.lat(), equalTo(expectedPoint.lat()));
assertThat(geoQuery.lon(), equalTo(expectedPoint.lon()));
}
assertThat(geoQuery.geoDistance(), equalTo(queryBuilder.geoDistance()));
if (queryBuilder.from() != null && queryBuilder.from() instanceof Number) {
double fromValue = ((Number) queryBuilder.from()).doubleValue();
if (queryBuilder.unit() != null) {
fromValue = queryBuilder.unit().toMeters(fromValue);
}
if (queryBuilder.geoDistance() != null) {
fromValue = queryBuilder.geoDistance().normalize(fromValue, DistanceUnit.DEFAULT);
}
double fromSlop = Math.abs(fromValue) / 1000;
if (queryBuilder.includeLower() == false) {
fromSlop =
NumericUtils.sortableLongToDouble(
(NumericUtils.doubleToSortableLong(Math.abs(fromValue)) + 1L))
/ 1000.0;
}
assertThat(geoQuery.minInclusiveDistance(), closeTo(fromValue, fromSlop));
}
if (queryBuilder.to() != null && queryBuilder.to() instanceof Number) {
double toValue = ((Number) queryBuilder.to()).doubleValue();
if (queryBuilder.unit() != null) {
toValue = queryBuilder.unit().toMeters(toValue);
}
if (queryBuilder.geoDistance() != null) {
toValue = queryBuilder.geoDistance().normalize(toValue, DistanceUnit.DEFAULT);
}
double toSlop = Math.abs(toValue) / 1000;
if (queryBuilder.includeUpper() == false) {
toSlop =
NumericUtils.sortableLongToDouble(
(NumericUtils.doubleToSortableLong(Math.abs(toValue)) - 1L))
/ 1000.0;
}
assertThat(geoQuery.maxInclusiveDistance(), closeTo(toValue, toSlop));
}
}
public void testInvalidGeoDistance() {
GeoDistanceRangeQueryBuilder builder =
new GeoDistanceRangeQueryBuilder(GEO_POINT_FIELD_NAME, new GeoPoint());
IllegalArgumentException e =
expectThrows(IllegalArgumentException.class, () -> builder.geoDistance(null));
assertEquals("geoDistance calculation mode must not be null", e.getMessage());
}
@Override
protected GeoDistanceRangeQueryBuilder doCreateTestQueryBuilder() {
GeoDistanceRangeQueryBuilder builder;
GeoPoint randomPoint = RandomGeoGenerator.randomPointIn(random(), -180.0, -89.9, 180.0, 89.9);
if (randomBoolean()) {
builder = new GeoDistanceRangeQueryBuilder(GEO_POINT_FIELD_NAME, randomPoint.geohash());
} else {
if (randomBoolean()) {
builder = new GeoDistanceRangeQueryBuilder(GEO_POINT_FIELD_NAME, randomPoint);
} else {
builder =
new GeoDistanceRangeQueryBuilder(
GEO_POINT_FIELD_NAME, randomPoint.lat(), randomPoint.lon());
}
}
GeoPoint point = builder.point();
final double maxRadius = GeoUtils.maxRadialDistanceMeters(point.lat(), point.lon());
final int fromValueMeters = randomInt((int) (maxRadius * 0.5));
final int toValueMeters = randomIntBetween(fromValueMeters + 1, (int) maxRadius);
DistanceUnit fromToUnits = randomFrom(DistanceUnit.values());
final String fromToUnitsStr = fromToUnits.toString();
final double fromValue =
DistanceUnit.convert(fromValueMeters, DistanceUnit.DEFAULT, fromToUnits);
final double toValue = DistanceUnit.convert(toValueMeters, DistanceUnit.DEFAULT, fromToUnits);
if (randomBoolean()) {
int branch = randomInt(2);
fromToUnits = DistanceUnit.DEFAULT;
switch (branch) {
case 0:
builder.from(fromValueMeters);
break;
case 1:
builder.to(toValueMeters);
break;
case 2:
builder.from(fromValueMeters);
builder.to(toValueMeters);
break;
}
} else {
int branch = randomInt(2);
switch (branch) {
case 0:
builder.from(fromValue + fromToUnitsStr);
break;
case 1:
builder.to(toValue + fromToUnitsStr);
break;
case 2:
builder.from(fromValue + fromToUnitsStr);
builder.to(toValue + fromToUnitsStr);
break;
}
}
if (randomBoolean()) {
builder.includeLower(randomBoolean());
}
if (randomBoolean()) {
builder.includeUpper(randomBoolean());
}
if (randomBoolean()) {
builder.geoDistance(randomFrom(GeoDistance.values()));
}
builder.unit(fromToUnits);
if (randomBoolean()) {
builder.setValidationMethod(randomFrom(GeoValidationMethod.values()));
}
if (randomBoolean()) {
builder.ignoreUnmapped(randomBoolean());
}
return builder;
}