Adding Javi's comment

Signed-off-by: Ricardo Zanini <ricardozanini@gmail.com>

Author: ricardozanini

impl/test/src/test/java/io/serverlessworkflow/impl/test/junit/BinaryCheckUtil.java

@@ -22,31 +22,31 @@
 
 public final class BinaryCheckUtil {
 
-  private BinaryCheckUtil() {}
-
   private static final ConcurrentMap<String, Boolean> BINARY_CHECKS = new ConcurrentHashMap<>();
 
+  private BinaryCheckUtil() {}
+
   public static boolean isBinaryAvailable(String... command) {
     return BINARY_CHECKS.computeIfAbsent(
         String.join(" ", command),
         __ -> {
+          Process process;
           try {
-            Process process =
+            process =
                 new ProcessBuilder(command)
                     .redirectErrorStream(true)
                     .redirectOutput(ProcessBuilder.Redirect.DISCARD)
                     .start();
-            boolean finished = process.waitFor(2, TimeUnit.SECONDS);
-            if (finished) {
-              return process.exitValue() == 0;
-            }
-            process.destroyForcibly();
+          } catch (IOException e) {
             return false;
-          } catch (IOException | InterruptedException e) {
-            if (e instanceof InterruptedException) {
-              Thread.currentThread().interrupt();
-            }
+          }
+          try {
+            return process.waitFor(2, TimeUnit.SECONDS) && process.exitValue() == 0;
+          } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
             return false;
+          } finally {
+            process.destroyForcibly();
           }
         });
   }

impl/test/src/test/java/io/serverlessworkflow/impl/test/junit/ProtocCheckCondition.java

@@ -18,49 +18,36 @@
 import static io.serverlessworkflow.impl.test.junit.BinaryCheckUtil.isBinaryAvailable;
 
 import com.github.os72.protocjar.Protoc;
-import java.util.concurrent.atomic.AtomicReference;
 import org.junit.jupiter.api.extension.ConditionEvaluationResult;
 import org.junit.jupiter.api.extension.ExecutionCondition;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.platform.commons.util.AnnotationUtils;
 
 public class ProtocCheckCondition implements ExecutionCondition {
 
-  private static final AtomicReference<Boolean> protocAvailable = new AtomicReference<>(null);
+  private static boolean protocAvailable = false;
 
-  @Override
-  public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
-    return AnnotationUtils.findAnnotation(context.getElement(), DisabledIfProtocUnavailable.class)
-        .map(
-            annotation -> {
-              if (isProtocAvailable()) {
-                return ConditionEvaluationResult.enabled(
-                    "Protoc is available for the current platform.");
-              } else {
-                return ConditionEvaluationResult.disabled(
-                    "Test disabled: Protoc not currently available not found.");
-              }
-            })
-        .orElse(ConditionEvaluationResult.enabled("No @DisabledIfProtocUnavailable found."));
-  }
-
-  private boolean isProtocAvailable() {
-    Boolean cached = protocAvailable.get();
-    if (cached != null) {
-      return cached;
-    }
-
-    boolean found = false;
+  static {
     try {
-      if (Protoc.runProtoc(new String[] {"--version"}) == 0) found = true;
+      protocAvailable = Protoc.runProtoc(new String[] {"--version"}) == 0;
     } catch (Exception e) {
       // ignore
     }
+    if (!protocAvailable) {
+      protocAvailable = isBinaryAvailable("protoc", "--version");
+    }
+  }
 
-    if (!found) found = isBinaryAvailable("protoc", "--version");
-
-    protocAvailable.compareAndSet(null, found);
-
-    return protocAvailable.get();
+  @Override
+  public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
+    return AnnotationUtils.findAnnotation(context.getElement(), DisabledIfProtocUnavailable.class)
+        .map(
+            annotation ->
+                protocAvailable
+                    ? ConditionEvaluationResult.enabled(
+                        "Protoc is available for the current platform.")
+                    : ConditionEvaluationResult.disabled(
+                        "Test disabled: Protoc not currently available not found."))
+        .orElse(ConditionEvaluationResult.enabled("No @DisabledIfProtocUnavailable found."));
   }
 }

impl/test/src/test/java/io/serverlessworkflow/impl/test/junit/PythonCheckCondition.java

@@ -32,13 +32,10 @@ public class PythonCheckCondition implements ExecutionCondition {
   public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
     return AnnotationUtils.findAnnotation(context.getElement(), DisabledIfPythonUnavailable.class)
         .map(
-            annotation -> {
-              if (isBinaryAvailable("python", "--version")) {
-                return ConditionEvaluationResult.enabled("Python is available.");
-              } else {
-                return ConditionEvaluationResult.disabled("Test disabled: Python not found.");
-              }
-            })
+            annotation ->
+                isBinaryAvailable("python", "--version")
+                    ? ConditionEvaluationResult.enabled("Python is available.")
+                    : ConditionEvaluationResult.disabled("Test disabled: Python not found."))
         .orElse(ConditionEvaluationResult.enabled("No @DisabledIfBinaryUnavailable found."));
   }
 }