Each operation evaluates the next case of the selected case file through the provider. The
+ * setup first evaluates every case once and fails if a value or reason differs from the expected
+ * one, so the benchmark never measures a wrong result.
+ *
+ *
Run: {@code ./gradlew :dd-openfeature:jmh -Pjmh.includes=ScaleSuiteBenchmark}.
+ */
+@State(Scope.Benchmark)
+@Warmup(iterations = 3, time = 2, timeUnit = SECONDS)
+@Measurement(iterations = 5, time = 2, timeUnit = SECONDS)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(NANOSECONDS)
+@Fork(value = 1)
+public class ScaleSuiteBenchmark {
+ private static final String SUITE_PATH =
+ "dd-smoke-tests/openfeature/src/test/resources/ffe-system-test-data/evaluation-suites/scale";
+ private static final JsonFactory JSON_FACTORY = new JsonFactory();
+
+ /** The case file of the scale suite, without the {@code .json} extension. */
+ @Param({"json-values", "one-of", "regex", "rules", "wide-context"})
+ public String cases;
+
+ private Provider provider;
+ private ScaleCase[] scaleCases;
+ private int next;
+
+ @Setup(Level.Trial)
+ public void setUp() throws IOException {
+ final Path suite = suiteRoot();
+ final DDEvaluator evaluator =
+ new DDEvaluator(
+ () -> {},
+ AgentBridge.NONE,
+ Settings.load(AgentBridge.NONE),
+ ExperimentationOptOutMode.DISABLED);
+ evaluator.accept(
+ UniversalFlagConfigParser.parse(Files.readAllBytes(suite.resolve("ufc-config.json"))));
+ provider = new Provider(new Provider.Options(), evaluator, false);
+
+ final List loaded = new ArrayList<>();
+ for (final Object json : (List>) read(suite.resolve("cases").resolve(cases + ".json"))) {
+ loaded.add(new ScaleCase((Map, ?>) json));
+ }
+ scaleCases = loaded.toArray(new ScaleCase[0]);
+ for (final ScaleCase scaleCase : scaleCases) {
+ scaleCase.check(scaleCase.evaluate(provider));
+ }
+ }
+
+ @TearDown(Level.Trial)
+ public void tearDown() {
+ provider.shutdown();
+ }
+
+ @Benchmark
+ public ProviderEvaluation> evaluate() {
+ final ScaleCase scaleCase = scaleCases[next];
+ next = next + 1 == scaleCases.length ? 0 : next + 1;
+ return scaleCase.evaluate(provider);
+ }
+
+ /** One evaluation case, with its expected value and reason. */
+ private static final class ScaleCase {
+ private final String flag;
+ private final String variationType;
+ private final Object defaultValue;
+ private final Object expectedValue;
+ private final String expectedReason;
+ private final EvaluationContext context;
+
+ ScaleCase(final Map, ?> json) {
+ this.flag = (String) json.get("flag");
+ this.variationType = (String) json.get("variationType");
+ final Map, ?> result = (Map, ?>) json.get("result");
+ this.defaultValue = typed(json.get("defaultValue"));
+ this.expectedValue = typed(result.get("value"));
+ this.expectedReason = (String) result.get("reason");
+ final MutableContext context =
+ new MutableContext(Value.objectToValue(json.get("attributes")).asStructure().asMap());
+ context.setTargetingKey((String) json.get("targetingKey"));
+ this.context = context;
+ }
+
+ ProviderEvaluation> evaluate(final Provider provider) {
+ switch (variationType) {
+ case "BOOLEAN":
+ return provider.getBooleanEvaluation(flag, (Boolean) defaultValue, context);
+ case "INTEGER":
+ return provider.getIntegerEvaluation(flag, (Integer) defaultValue, context);
+ case "NUMERIC":
+ return provider.getDoubleEvaluation(flag, (Double) defaultValue, context);
+ case "STRING":
+ return provider.getStringEvaluation(flag, (String) defaultValue, context);
+ case "JSON":
+ return provider.getObjectEvaluation(flag, (Value) defaultValue, context);
+ default:
+ throw new IllegalArgumentException("Unsupported variationType: " + variationType);
+ }
+ }
+
+ void check(final ProviderEvaluation> details) {
+ if (!Objects.equals(expectedValue, details.getValue())
+ || !Objects.equals(expectedReason, details.getReason())) {
+ throw new IllegalStateException(
+ "Unexpected result for "
+ + flag
+ + ": expected "
+ + expectedReason
+ + " "
+ + expectedValue
+ + ", got "
+ + details.getReason()
+ + " "
+ + details.getValue());
+ }
+ }
+
+ /** Converts a fixture value to the type that the provider returns for this variation type. */
+ private Object typed(final Object value) {
+ if (value == null) {
+ return null;
+ }
+ switch (variationType) {
+ case "INTEGER":
+ return ((Number) value).intValue();
+ case "NUMERIC":
+ return ((Number) value).doubleValue();
+ case "JSON":
+ return Value.objectToValue(exactIntegers(value));
+ default:
+ return value;
+ }
+ }
+ }
+
+ /** Reads integral numbers as Integer when they fit, as the UFC parser does for JSON variants. */
+ private static Object exactIntegers(final Object value) {
+ if (value instanceof Long) {
+ final long number = (Long) value;
+ return number == (int) number ? (Object) (int) number : value;
+ }
+ if (value instanceof Map) {
+ final Map map = new LinkedHashMap<>();
+ ((Map, ?>) value).forEach((k, v) -> map.put((String) k, exactIntegers(v)));
+ return map;
+ }
+ if (value instanceof List) {
+ final List