Adds another test for deeply nested classes.

This tests when the containing class is private.

Author: jeannielynnmoulton

jbmc/unit/java_bytecode/java_bytecode_parser/ContainsAnonymousClass$1.class

@@ -85,6 +85,39 @@ private PrivateDoublyNestedInnerClass(int i) {
     }
 }
 
+class InnerPrivateClassesDeeplyNested {
+    private class SinglyNestedPrivateClass {
+        int i;
+        SinglyNestedPrivateClass(int i) {
+            this.i = i;
+        }
+        public class PublicDoublyNestedInnerClass {
+            public int i;
+            public PublicDoublyNestedInnerClass(int i) {
+                this.i = i;
+            }
+        }
+        class DefaultDoublyNestedInnerClass {
+            int i;
+            DefaultDoublyNestedInnerClass(int i) {
+                this.i = i;
+            }
+        }
+        protected class ProtectedDoublyNestedInnerClass {
+            protected int i;
+            protected ProtectedDoublyNestedInnerClass(int i) {
+                this.i = i;
+            }
+        }
+        private class PrivateDoublyNestedInnerClass {
+            private int i;
+            private PrivateDoublyNestedInnerClass(int i) {
+                this.i = i;
+            }
+        }
+    }
+}
+
 class ContainsAnonymousClass {
     interface InnerInterface {
         int i = 0;

jbmc/unit/java_bytecode/java_bytecode_parser/ContainsAnonymousClass$2.class

@@ -216,6 +216,85 @@ SCENARIO(
     }
   }
 
+  GIVEN(
+    "Some package-private class files in the class path with private deeply"
+    "nested inner classes")
+  {
+    const symbol_tablet &new_symbol_table = load_java_class(
+      "InnerPrivateClassesDeeplyNested",
+      "./java_bytecode/java_bytecode_parser");
+    WHEN(
+      "Parsing the InnerClasses attribute for a public doubly-nested inner "
+      "class")
+    {
+      THEN(
+        "The inner class should be marked as private because its containing "
+        "class has stricter access ")
+      {
+        const symbolt &class_symbol = new_symbol_table.lookup_ref(
+          "java::InnerPrivateClassesDeeplyNested$SinglyNestedPrivateClass$"
+          "PublicDoublyNestedInnerClass");
+        const java_class_typet java_class =
+          to_java_class_type(class_symbol.type);
+        REQUIRE_FALSE(java_class.get_is_anonymous_class());
+        REQUIRE(java_class.get_is_inner_class());
+        REQUIRE(java_class.get_access() == ID_private);
+      }
+    }
+    WHEN(
+      "Parsing the InnerClasses attribute for a package private doubly-nested "
+      "inner class")
+    {
+      THEN(
+        "The inner class should be marked as private because its containing "
+        "class has stricter access ")
+      {
+        const symbolt &class_symbol = new_symbol_table.lookup_ref(
+          "java::InnerPrivateClassesDeeplyNested$SinglyNestedPrivateClass$"
+          "DefaultDoublyNestedInnerClass");
+        const java_class_typet java_class =
+          to_java_class_type(class_symbol.type);
+        REQUIRE_FALSE(java_class.get_is_anonymous_class());
+        REQUIRE(java_class.get_is_inner_class());
+        REQUIRE(java_class.get_access() == ID_private);
+      }
+    }
+    WHEN(
+      "Parsing the InnerClasses attribute for a protected doubly-nested inner "
+      "class")
+    {
+      THEN(
+        "The inner class should be marked as private because its containing "
+        "class has stricter access ")
+      {
+        const symbolt &class_symbol = new_symbol_table.lookup_ref(
+          "java::InnerPrivateClassesDeeplyNested$SinglyNestedPrivateClass$"
+          "ProtectedDoublyNestedInnerClass");
+        const java_class_typet java_class =
+          to_java_class_type(class_symbol.type);
+        REQUIRE_FALSE(java_class.get_is_anonymous_class());
+        REQUIRE(java_class.get_is_inner_class());
+        REQUIRE(java_class.get_access() == ID_private);
+      }
+    }
+    WHEN(
+      "Parsing the InnerClasses attribute for a private doubly-nested inner "
+      "class")
+    {
+      THEN("The inner class should be marked as private ")
+      {
+        const symbolt &class_symbol = new_symbol_table.lookup_ref(
+          "java::InnerPrivateClassesDeeplyNested$SinglyNestedPrivateClass$"
+          "PrivateDoublyNestedInnerClass");
+        const java_class_typet java_class =
+          to_java_class_type(class_symbol.type);
+        REQUIRE_FALSE(java_class.get_is_anonymous_class());
+        REQUIRE(java_class.get_is_inner_class());
+        REQUIRE(java_class.get_access() == ID_private);
+      }
+    }
+  }
+
   GIVEN(
     "Some package-private class files in the class path with anonymous classes")
   {