Add fractional evaluation support

pom.xml

@@ -115,6 +115,11 @@
             <artifactId>jackson-databind</artifactId>
             <version>2.19.0</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>33.3.0-jre</version>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>

src/main/java/com/octopus/openfeature/provider/OctopusClient.java

@@ -64,7 +64,7 @@ FeatureToggles getFeatureToggleEvaluationManifest()
                 logger.log(System.Logger.Level.WARNING,String.format("Feature toggle response from %s did not contain expected ContentHash header", manifestURI.toString()));      
                 return null;
             }
-            List<FeatureToggleEvaluation> evaluations = OctopusObjectMapper.INSTANCE.readValue(httpResponse.body(), new TypeReference<>(){});
+            var evaluations = OctopusObjectMapper.INSTANCE.readValue(httpResponse.body(), new TypeReference<List<FeatureToggleEvaluation>>(){});
             return new FeatureToggles(evaluations, Base64.getDecoder().decode(contentHashHeader.get()));
         } catch (Exception e) {
             logger.log(System.Logger.Level.WARNING, "Unable to query Octopus Feature Toggle service", e);

src/main/java/com/octopus/openfeature/provider/OctopusContext.java

@@ -1,9 +1,11 @@
 package com.octopus.openfeature.provider;
 
+import com.google.common.hash.Hashing;
 import dev.openfeature.sdk.*;
 import dev.openfeature.sdk.exceptions.FlagNotFoundError;
 import dev.openfeature.sdk.exceptions.ParseError;
 
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 
 import static java.util.stream.Collectors.groupingBy;
@@ -26,10 +28,10 @@ byte[] getContentHash() {
     }
 
     ProviderEvaluation<Boolean> evaluate(String slug, Boolean defaultValue, EvaluationContext evaluationContext) {
-        // find the feature toggle matching the slug
-        var toggleValue = featureToggles.getEvaluations().stream().filter(f -> f.getSlug().equalsIgnoreCase(slug)).findFirst().orElse(null);
+        var toggleValue = featureToggles.getEvaluations().stream()
+                .filter(f -> f.getSlug().equalsIgnoreCase(slug))
+                .findFirst().orElse(null);
 
-        // this exception will be handled by OpenFeature, and the default value will be used
         if (toggleValue == null) {
             throw new FlagNotFoundError();
         }
@@ -38,18 +40,46 @@ ProviderEvaluation<Boolean> evaluate(String slug, Boolean defaultValue, Evaluati
             throw new ParseError("Feature toggle " + toggleValue.getSlug() + " is missing necessary information for client-side evaluation.");
         }
 
-        // if the toggle is disabled, or if it has no segments, then we don't need to evaluate dynamically
-        if (!toggleValue.isEnabled() || !toggleValue.hasSegments()) {
+        if (!toggleValue.isEnabled()) {
             return ProviderEvaluation.<Boolean>builder()
-                    .value(toggleValue.isEnabled())
+                    .value(false)
                     .reason(Reason.DEFAULT.toString())
                     .build();
         }
 
-        // If the toggle is enabled and has segments configured, then we need to evaluate dynamically,
-        // checking the context matches the segments
+        // EvaluationKey and ClientRolloutPercentage are guaranteed non-null here via missingRequiredPropertiesForClientSideEvaluation()
+        String evaluationKey = toggleValue.getEvaluationKey().orElseThrow();
+        int rolloutPercentage = toggleValue.getClientRolloutPercentage().orElseThrow();
+        String targetingKey = evaluationContext != null ? evaluationContext.getTargetingKey() : null;
+
+        if (targetingKey == null || targetingKey.isEmpty()) {
+            if (rolloutPercentage < 100) {
+                return ProviderEvaluation.<Boolean>builder()
+                        .value(false)
+                        .reason(Reason.TARGETING_MATCH.toString())
+                        .build();
+            }
+            // rolloutPercentage == 100: fall through to segment check
+        } else {
+            if (getNormalizedNumber(evaluationKey, targetingKey) > rolloutPercentage) {
+                return ProviderEvaluation.<Boolean>builder()
+                        .value(false)
+                        .reason(Reason.TARGETING_MATCH.toString())
+                        .build();
+            }
+        }
+
+        if (!toggleValue.hasSegments()) {
+            return ProviderEvaluation.<Boolean>builder()
+                    .value(true)
+                    .reason(Reason.DEFAULT.toString())
+                    .build();
+        }
+
+        var segments = toggleValue.getSegments().orElseThrow();
+
         return ProviderEvaluation.<Boolean>builder()
-                .value(matchesSegment(evaluationContext, toggleValue.getSegments().orElseThrow())) // checked in hasSegments
+                .value(matchesSegment(evaluationContext, segments))
                 .reason(Reason.TARGETING_MATCH.toString())
                 .build();
     }
@@ -64,7 +94,22 @@ private boolean missingRequiredPropertiesForClientSideEvaluation(FeatureToggleEv
                 || evaluation.getSegments().isEmpty();
     }
 
-    private Boolean matchesSegment(EvaluationContext evaluationContext, List<Segment> segments) {
+    static int getNormalizedNumber(String evaluationKey, String targetingKey) {
+        byte[] bytes = (evaluationKey + ":" + targetingKey).getBytes(StandardCharsets.UTF_8);
+
+        // MurmurHash3 32-bit, seed 0. murmur3_32_fixed is Guava's corrected implementation
+        // that processes tail bytes in little-endian order, matching the reference C spec and
+        // equivalent to .NET's MurmurHash.Create32() + BinaryPrimitives.ReadUInt32LittleEndian().
+        int hash = Hashing.murmur3_32_fixed(0).hashBytes(bytes).asInt();
+
+        // Java has no unsigned integer type. Integer.toUnsignedLong() reinterprets the signed
+        // int as an unsigned 32-bit value (widened to long) — equivalent to casting to uint in C#.
+        long unsignedHash = Integer.toUnsignedLong(hash);
+
+        return (int) (unsignedHash % 100) + 1;
+    }
+
+    Boolean matchesSegment(EvaluationContext evaluationContext, List<Segment> segments) {
         if (evaluationContext == null) {
             return false;
         }

src/test/java/com/octopus/openfeature/provider/FeatureToggleEvaluationDeserializationTests.java

@@ -70,10 +70,9 @@ void shouldDeserializeToggleWithSegments() throws Exception {
 
     @Test
     void shouldDeserializeListOfToggles() throws Exception {
-        List<FeatureToggleEvaluation> result = objectMapper.readValue(
+        var result = objectMapper.readValue(
                 resource("toggle-list.json"),
-                new TypeReference<>() {
-                }
+                new TypeReference<List<FeatureToggleEvaluation>>() {}
         );
 
         assertThat(result).hasSize(2);
@@ -85,10 +84,9 @@ void shouldDeserializeListOfToggles() throws Exception {
 
     @Test
     void shouldDeserializeListOfTogglesWithVariousFieldCasings() throws Exception {
-        List<FeatureToggleEvaluation> result = objectMapper.readValue(
+        var result = objectMapper.readValue(
                 resource("toggles-with-different-field-capitalisation.json"),
-                new TypeReference<>() {
-                }
+                new TypeReference<List<FeatureToggleEvaluation>>() {}
         );
 
         assertThat(result).hasSize(3);