Skip to content

Simplify JavaIntegerConstraint structure to align with decimal constraint improvements #1156

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 5 commits into from
Mar 5, 2025
Merged

Simplify JavaIntegerConstraint structure to align with decimal constraint improvements #1156

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
10ee7c8
refactor: simplify JavaIntegerConstraint to use a single min/max range
Seol-JY Feb 25, 2025
1abe618
chore: trigger workflow run
Seol-JY Feb 25, 2025
0bd71b9
refactor: Simplify number value fields in SimpleValueJqwikPlugin
Seol-JY Mar 3, 2025
a579aa0
refactor: Improve variable naming in constraint generator methods
Seol-JY Mar 3, 2025
ae95356
refactor: rename digitsAnn to digitsAnnotation
Seol-JY Mar 4, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 10 additions & 30 deletions ...y-api/src/main/java/com/navercorp/fixturemonkey/api/constraint/JavaIntegerConstraint.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,46 +28,26 @@
@API(since = "0.6.8", status = Status.MAINTAINED)
public final class JavaIntegerConstraint {
@Nullable
private final BigInteger positiveMin;
private final BigInteger min;

@Nullable
private final BigInteger positiveMax;

@Nullable
private final BigInteger negativeMin;

@Nullable
private final BigInteger negativeMax;
private final BigInteger max;

public JavaIntegerConstraint(
@Nullable BigInteger positiveMin,
@Nullable BigInteger positiveMax,
@Nullable BigInteger negativeMin,
@Nullable BigInteger negativeMax
@Nullable BigInteger min,
@Nullable BigInteger max
) {
this.positiveMin = positiveMin;
this.positiveMax = positiveMax;
this.negativeMin = negativeMin;
this.negativeMax = negativeMax;
}

@Nullable
public BigInteger getPositiveMin() {
return positiveMin;
}

@Nullable
public BigInteger getPositiveMax() {
return positiveMax;
this.min = min;
this.max = max;
}

@Nullable
public BigInteger getNegativeMin() {
return negativeMin;
public BigInteger getMin() {
return min;
}

@Nullable
public BigInteger getNegativeMax() {
return negativeMax;
public BigInteger getMax() {
return max;
}
}
30 changes: 6 additions & 24 deletions ...i/src/main/java/com/navercorp/fixturemonkey/api/generator/ValidateArbitraryGenerator.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -243,33 +243,15 @@ public CombinableArbitrary<?> generate(ArbitraryGeneratorContext context) {
}

BigInteger value = toBigInteger(it);
if (value.compareTo(BigInteger.ZERO) < 0) {
if (javaIntegerConstraint.getNegativeMin() != null) {
if (value.compareTo(javaIntegerConstraint.getNegativeMin()) < 0) {
return false;
}
}

if (javaIntegerConstraint.getNegativeMax() != null) {
if (value.compareTo(BigInteger.ZERO) < 0
&& value.compareTo(javaIntegerConstraint.getNegativeMax()) > 0) {
return false;
}
}
if (javaIntegerConstraint.getMin() != null
&& value.compareTo(javaIntegerConstraint.getMin()) < 0) {
return false;
}

if (value.compareTo(BigInteger.ZERO) > 0) {
if (javaIntegerConstraint.getPositiveMin() != null) {
if (value.compareTo(javaIntegerConstraint.getPositiveMin()) < 0) {
return false;
}
}

if (javaIntegerConstraint.getPositiveMax() != null) {
if (value.compareTo(javaIntegerConstraint.getPositiveMax()) > 0) {
return false;
}
}
if (javaIntegerConstraint.getMax() != null
&& value.compareTo(javaIntegerConstraint.getMax()) > 0) {
return false;
}

return true;
Expand Down
175 changes: 67 additions & 108 deletions ...y-api/src/main/java/com/navercorp/fixturemonkey/api/jqwik/JqwikJavaArbitraryResolver.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -135,30 +135,22 @@ public Arbitrary<Short> shorts(
return shortArbitrary;
}

BigInteger positiveMin = constraint.getPositiveMin();
BigInteger positiveMax = constraint.getPositiveMax();
BigInteger negativeMin = constraint.getNegativeMin();
BigInteger negativeMax = constraint.getNegativeMax();

ShortArbitrary positiveArbitrary = null;
ShortArbitrary negativeArbitrary = null;
if (positiveMin != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> shortArbitrary);
positiveArbitrary = positiveArbitrary.greaterOrEqual(positiveMin.shortValueExact());
}
if (positiveMax != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> shortArbitrary);
positiveArbitrary = positiveArbitrary.lessOrEqual(positiveMax.shortValueExact());
}
if (negativeMin != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> shortArbitrary);
negativeArbitrary = negativeArbitrary.greaterOrEqual(negativeMin.shortValueExact());
}
if (negativeMax != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> shortArbitrary);
negativeArbitrary = negativeArbitrary.lessOrEqual(negativeMax.shortValueExact());
}
return resolveArbitrary(shortArbitrary, positiveArbitrary, negativeArbitrary);
BigInteger min = constraint.getMin();
BigInteger max = constraint.getMax();

ShortArbitrary arbitrary = null;

if (min != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> shortArbitrary);
arbitrary = arbitrary.greaterOrEqual(min.shortValueExact());
}

if (max != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> shortArbitrary);
arbitrary = arbitrary.lessOrEqual(max.shortValueExact());
}

return arbitrary != null ? arbitrary : shortArbitrary;
}

@Override
Expand All @@ -171,30 +163,22 @@ public Arbitrary<Byte> bytes(
return byteArbitrary;
}

BigInteger positiveMin = constraint.getPositiveMin();
BigInteger positiveMax = constraint.getPositiveMax();
BigInteger negativeMin = constraint.getNegativeMin();
BigInteger negativeMax = constraint.getNegativeMax();
BigInteger min = constraint.getMin();
BigInteger max = constraint.getMax();

ByteArbitrary positiveArbitrary = null;
ByteArbitrary negativeArbitrary = null;
if (positiveMin != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> byteArbitrary);
positiveArbitrary = positiveArbitrary.greaterOrEqual(positiveMin.byteValueExact());
}
if (positiveMax != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> byteArbitrary);
positiveArbitrary = positiveArbitrary.lessOrEqual(positiveMax.byteValueExact());
}
if (negativeMin != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> byteArbitrary);
negativeArbitrary = negativeArbitrary.greaterOrEqual(negativeMin.byteValueExact());
ByteArbitrary arbitrary = null;

if (min != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> byteArbitrary);
arbitrary = arbitrary.greaterOrEqual(min.byteValueExact());
}
if (negativeMax != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> byteArbitrary);
negativeArbitrary = negativeArbitrary.lessOrEqual(negativeMax.byteValueExact());

if (max != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> byteArbitrary);
arbitrary = arbitrary.lessOrEqual(max.byteValueExact());
}
return resolveArbitrary(byteArbitrary, positiveArbitrary, negativeArbitrary);

return arbitrary != null ? arbitrary : byteArbitrary;
}

@Override
Expand Down Expand Up @@ -299,30 +283,22 @@ public Arbitrary<Integer> integers(
return integerArbitrary;
}

BigInteger positiveMin = constraint.getPositiveMin();
BigInteger positiveMax = constraint.getPositiveMax();
BigInteger negativeMin = constraint.getNegativeMin();
BigInteger negativeMax = constraint.getNegativeMax();
BigInteger min = constraint.getMin();
BigInteger max = constraint.getMax();

IntegerArbitrary positiveArbitrary = null;
IntegerArbitrary negativeArbitrary = null;
if (positiveMin != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> integerArbitrary);
positiveArbitrary = positiveArbitrary.greaterOrEqual(positiveMin.intValueExact());
}
if (positiveMax != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> integerArbitrary);
positiveArbitrary = positiveArbitrary.lessOrEqual(positiveMax.intValueExact());
}
if (negativeMin != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> integerArbitrary);
negativeArbitrary = negativeArbitrary.greaterOrEqual(negativeMin.intValueExact());
IntegerArbitrary arbitrary = null;

if (min != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> integerArbitrary);
arbitrary = arbitrary.greaterOrEqual(min.intValueExact());
}
if (negativeMax != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> integerArbitrary);
negativeArbitrary = negativeArbitrary.lessOrEqual(negativeMax.intValueExact());

if (max != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> integerArbitrary);
arbitrary = arbitrary.lessOrEqual(max.intValueExact());
}
return resolveArbitrary(integerArbitrary, positiveArbitrary, negativeArbitrary);

return arbitrary != null ? arbitrary : integerArbitrary;
}

@Override
Expand All @@ -335,30 +311,22 @@ public Arbitrary<Long> longs(
return longArbitrary;
}

BigInteger positiveMin = constraint.getPositiveMin();
BigInteger positiveMax = constraint.getPositiveMax();
BigInteger negativeMin = constraint.getNegativeMin();
BigInteger negativeMax = constraint.getNegativeMax();
BigInteger min = constraint.getMin();
BigInteger max = constraint.getMax();

LongArbitrary positiveArbitrary = null;
LongArbitrary negativeArbitrary = null;
if (positiveMin != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> longArbitrary);
positiveArbitrary = positiveArbitrary.greaterOrEqual(positiveMin.longValueExact());
}
if (positiveMax != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> longArbitrary);
positiveArbitrary = positiveArbitrary.lessOrEqual(positiveMax.longValueExact());
}
if (negativeMin != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> longArbitrary);
negativeArbitrary = negativeArbitrary.greaterOrEqual(negativeMin.longValueExact());
LongArbitrary arbitrary = null;

if (min != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> longArbitrary);
arbitrary = arbitrary.greaterOrEqual(min.longValueExact());
}
if (negativeMax != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> longArbitrary);
negativeArbitrary = negativeArbitrary.lessOrEqual(negativeMax.longValueExact());

if (max != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> longArbitrary);
arbitrary = arbitrary.lessOrEqual(max.longValueExact());
}
return resolveArbitrary(longArbitrary, positiveArbitrary, negativeArbitrary);

return arbitrary != null ? arbitrary : longArbitrary;
}

@Override
Expand All @@ -371,31 +339,22 @@ public Arbitrary<BigInteger> bigIntegers(
return bigIntegerArbitrary;
}

BigInteger positiveMin = constraint.getPositiveMin();
BigInteger positiveMax = constraint.getPositiveMax();
BigInteger negativeMin = constraint.getNegativeMin();
BigInteger negativeMax = constraint.getNegativeMax();
BigInteger min = constraint.getMin();
BigInteger max = constraint.getMax();

BigIntegerArbitrary positiveArbitrary = null;
BigIntegerArbitrary negativeArbitrary = null;
if (positiveMin != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> bigIntegerArbitrary);
positiveArbitrary = positiveArbitrary.greaterOrEqual(positiveMin);
}
if (positiveMax != null) {
positiveArbitrary = Types.defaultIfNull(positiveArbitrary, () -> bigIntegerArbitrary);
positiveArbitrary = positiveArbitrary.lessOrEqual(positiveMax);
}
if (negativeMin != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> bigIntegerArbitrary);
negativeArbitrary = negativeArbitrary.greaterOrEqual(negativeMin);
BigIntegerArbitrary arbitrary = null;

if (min != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> bigIntegerArbitrary);
arbitrary = arbitrary.greaterOrEqual(min);
}
if (negativeMax != null) {
negativeArbitrary = Types.defaultIfNull(negativeArbitrary, () -> bigIntegerArbitrary);
negativeArbitrary = negativeArbitrary.lessOrEqual(negativeMax);

if (max != null) {
arbitrary = Types.defaultIfNull(arbitrary, () -> bigIntegerArbitrary);
arbitrary = arbitrary.lessOrEqual(max);
}

return resolveArbitrary(bigIntegerArbitrary, positiveArbitrary, negativeArbitrary);
return arbitrary != null ? arbitrary : bigIntegerArbitrary;
}

@Override
Expand Down
29 changes: 9 additions & 20 deletions ...nkey-api/src/main/java/com/navercorp/fixturemonkey/api/plugin/SimpleValueJqwikPlugin.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -232,32 +232,21 @@ public JavaStringConstraint generateStringConstraint(ArbitraryGeneratorContext c

@Override
public JavaIntegerConstraint generateIntegerConstraint(ArbitraryGeneratorContext context) {
BigInteger positiveMin = ifNotNull(this.positiveMinNumberValue, BigInteger::valueOf);
BigInteger positiveMax = ifNotNull(this.positiveMaxNumberValue, BigInteger::valueOf);
BigInteger negativeMin = ifNotNull(this.negativeMinNumberValue, BigInteger::valueOf);
BigInteger negativeMax = ifNotNull(this.negativeMaxNumberValue, BigInteger::valueOf);

if (positiveMin == null) {
negativeMin = defaultIfNull(negativeMin, () -> BigInteger.valueOf(DEFAULT_MIN_NUMBER_VALUE));
negativeMax = defaultIfNull(negativeMax, () -> BigInteger.ZERO);
}
BigInteger min = negativeMinNumberValue != null
Copy link
Contributor

@seongahjo seongahjo Mar 1, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think the fields in SimpleValueJqwikPlugin should be also simplified.

	@Nullable
	private Long positiveMinNumberValue = null;
	@Nullable
	private Long positiveMaxNumberValue = null;
	@Nullable
	private Long negativeMinNumberValue = null;
	@Nullable
	private Long negativeMaxNumberValue = null;

? BigInteger.valueOf(negativeMinNumberValue) :
BigInteger.valueOf(defaultIfNull(positiveMinNumberValue, () -> DEFAULT_MIN_NUMBER_VALUE));

if (negativeMax == null) {
positiveMin = defaultIfNull(positiveMin, () -> BigInteger.ZERO);
positiveMax = defaultIfNull(positiveMax, () -> BigInteger.valueOf(DEFAULT_MAX_NUMBER_VALUE));
}
BigInteger max = positiveMaxNumberValue != null
? BigInteger.valueOf(positiveMaxNumberValue) :
BigInteger.valueOf(defaultIfNull(negativeMaxNumberValue, () -> DEFAULT_MAX_NUMBER_VALUE));

Class<?> type = Types.getActualType(context.getResolvedType());
if (type == Byte.class || type == byte.class) {
positiveMax = positiveMax != null
? positiveMax.min(BIG_INTEGER_MAX_BYTE)
: BIG_INTEGER_MAX_BYTE;
negativeMin = negativeMin != null
? negativeMin.max(BIG_INTEGER_MIN_BYTE)
: BIG_INTEGER_MIN_BYTE;
max = max.min(BIG_INTEGER_MAX_BYTE);
min = min.max(BIG_INTEGER_MIN_BYTE);
Copy link
Contributor Author

@Seol-JY Seol-JY Feb 25, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think this part may be a bit ambiguous. Should we change the variable name?

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Sure

}

return new JavaIntegerConstraint(positiveMin, positiveMax, negativeMin, negativeMax);
return new JavaIntegerConstraint(min, max);
}

@Override
Expand Down
Loading
Loading