794 check for body validations and class validations

sootup.core/src/main/java/sootup/core/model/FieldModifier.java

@@ -24,14 +24,12 @@
  * #L%
  */
 
-import java.util.EnumSet;
 import java.util.Set;
-import java.util.stream.Collectors;
 import org.jspecify.annotations.NonNull;
 
 /**
- * An Enum that provides static methods and constants to represent and work with with Java modifiers
- * (ie public, final,...) Represents Java modifiers that can be packed and combined via EnumSet and
+ * An Enum that provides static methods and constants to represent and work with Java modifiers (ie
+ * public, final,...) Represents Java modifiers that can be packed and combined via EnumSet and
  * methods to query these.
  */
 public enum FieldModifier {
@@ -133,12 +131,6 @@ public static String toString(@NonNull Set<FieldModifier> m) {
     return builder.toString();
   }
 
-  @NonNull
-  // depends on the natural order of the Enums!
-  public static String toString(@NonNull EnumSet<FieldModifier> m) {
-    return m.stream().map((mod) -> mod.name().toLowerCase()).collect(Collectors.joining(" "));
-  }
-
   /**
    * @return the bytecode of this Modifier.
    */

sootup.core/src/main/java/sootup/core/validation/FieldModifiersValidator.java

@@ -4,7 +4,7 @@
  * #%L
  * Soot - a J*va Optimization Framework
  * %%
- * Copyright (C) 1997-2020 Raja Vallée-Rai, Linghui Luo, Akshita Dubey
+ * Copyright (C) 1997-2020 Raja Vallée-Rai, Linghui Luo, Akshita Dubey, Sahil Agichani
  * %%
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as
@@ -22,13 +22,81 @@
  * #L%
  */
 
+import java.util.Arrays;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.Set;
+import sootup.core.model.FieldModifier;
 import sootup.core.model.SootClass;
 import sootup.core.model.SootField;
 
 /** Validator that checks for impossible combinations of field modifiers */
 public class FieldModifiersValidator implements ClassValidator {
 
+  private final EnumSet<FieldModifier> modifiers;
+
+  public FieldModifiersValidator(EnumSet<FieldModifier> modifiers) {
+    validate(modifiers);
+    this.modifiers = EnumSet.copyOf(modifiers);
+  }
+
+  public static FieldModifiersValidator of(FieldModifier... mods) {
+    if (mods == null || mods.length == 0) {
+      return new FieldModifiersValidator(EnumSet.noneOf(FieldModifier.class));
+    }
+    return new FieldModifiersValidator(EnumSet.copyOf(Arrays.asList(mods)));
+  }
+
+  public static FieldModifiersValidator from(Set<FieldModifier> mods) {
+    return new FieldModifiersValidator(EnumSet.copyOf(mods));
+  }
+
+  public Set<FieldModifier> asSet() {
+    return EnumSet.copyOf(modifiers);
+  }
+
+  public boolean contains(FieldModifier mod) {
+    return modifiers.contains(mod);
+  }
+
+  private void validate(EnumSet<FieldModifier> mods) {
+    long accessModifiers =
+        mods.stream()
+            .filter(
+                m ->
+                    m == FieldModifier.PUBLIC
+                        || m == FieldModifier.PRIVATE
+                        || m == FieldModifier.PROTECTED)
+            .count();
+
+    if (accessModifiers > 1) {
+      throw new IllegalArgumentException("Only one of public, protected, private is allowed.");
+    }
+    // Add more rules here if needed
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder builder = new StringBuilder();
+
+    if (modifiers.contains(FieldModifier.PUBLIC)) builder.append("public ");
+    else if (modifiers.contains(FieldModifier.PRIVATE)) builder.append("private ");
+    else if (modifiers.contains(FieldModifier.PROTECTED)) builder.append("protected ");
+
+    if (modifiers.contains(FieldModifier.STATIC)) builder.append("static ");
+    if (modifiers.contains(FieldModifier.FINAL)) builder.append("final ");
+    if (modifiers.contains(FieldModifier.VOLATILE)) builder.append("volatile ");
+    if (modifiers.contains(FieldModifier.TRANSIENT)) builder.append("transient ");
+    if (modifiers.contains(FieldModifier.ENUM)) builder.append("enum ");
+    if (modifiers.contains(FieldModifier.SYNTHETIC)) builder.append("synthetic ");
+
+    if (!builder.isEmpty()) {
+      builder.setLength(builder.length() - 1); // remove trailing space
+    }
+
+    return builder.toString();
+  }
+
   @Override
   public void validate(SootClass sc, List<ValidationException> exceptions) {
     for (SootField sf : sc.getFields()) {

sootup.tests/src/test/java/sootup/tests/validator/FieldModifiersValidatorTest.java

@@ -1,6 +1,7 @@
 package sootup.tests.validator;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.*;
 import org.junit.jupiter.api.BeforeEach;
@@ -36,7 +37,7 @@ public class FieldModifiersValidatorTest {
   @BeforeEach
   public void setUp() {
     view = new JavaView(Collections.singletonList(new EagerInputLocation()));
-    fieldModifiersValidator = new FieldModifiersValidator();
+    fieldModifiersValidator = new FieldModifiersValidator(EnumSet.noneOf(FieldModifier.class));
   }
 
   public JavaSootClass testClassCreatorWithModifiers(
@@ -136,6 +137,36 @@ public void testFieldModifiersValidator_fail1() {
     assertEquals(1, validationExceptions_fail1.size());
   }
 
+  @Test
+  void testInvalidAccessModifiers() {
+    IllegalArgumentException ex =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> FieldModifiersValidator.of(FieldModifier.PUBLIC, FieldModifier.PRIVATE));
+    assertEquals("Only one of public, protected, private is allowed.", ex.getMessage());
+  }
+
+  @Test
+  void testInvalidModifiers2() {
+    IllegalArgumentException ex =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> {
+              EnumSet<FieldModifier> invalidFieldModifiers =
+                  EnumSet.of(FieldModifier.PRIVATE, FieldModifier.PROTECTED);
+              JavaSootField dummyField =
+                  new JavaSootField(
+                      new FieldSignature(
+                          new JavaClassType("FieldModifiersValidator", PackageName.DEFAULT_PACKAGE),
+                          "i",
+                          PrimitiveType.IntType.getInstance()),
+                      new FieldModifiersValidator(invalidFieldModifiers).asSet(),
+                      Collections.emptyList(),
+                      NoPositionInformation.getInstance());
+            });
+    assertEquals("Only one of public, protected, private is allowed.", ex.getMessage());
+  }
+
   @Test
   public void testFieldModifiersValidator_fail2() {
     List<ValidationException> validationExceptions_fail1 = new ArrayList<>();