builder.put(resourceEntry.getName(), resourceEntry.getContent(), resourceEntry.getCompressionMethod());
    }

    protected void finishProcessing(ClasspathBuilder.EntryBuilder builder) throws IOException {}

    private boolean isClassFile(ClasspathEntryVisitor.Entry entry) {
        return entry.getName().endsWith(".class");
    }

        File parentDir = codeSource.getParentFile();

        if (parentDir.getName().equals("lib")) {
            File pluginsDir = new File(parentDir, "plugins");
            return parentDir.isDirectory() && pluginsDir.exists() && pluginsDir.isDirectory() ? parentDir.getParentFile() : null;
        }

        if (parentDir.getName().equals("plugins")) {
            File libDir = parentDir.getParentFile();

        AttributeContainer candidateAttributes = candidate.getAllCandidateAttributes().getAttributes();
        for (Attribute<?> attribute : candidateAttributes.keySet()) {
            if (Objects.equals(attribute.getName(), Category.CATEGORY_ATTRIBUTE.getName())) {
                String category = String.valueOf(candidateAttributes.getAttribute(attribute));
                return Objects.equals(category, Category.LIBRARY);
            }
        }

    public Object getData(final AccessResultData<?> accessResultData) {
        // check transformer name
        if (!getName().equals(accessResultData.getTransformerName())) {
            throw new CrawlerSystemException(
                    "Transformer is invalid. Use " + accessResultData.getTransformerName() + ". This transformer is " + getName() + ".");
        }
        final byte[] data = accessResultData.getData();
        if (data == null) {

	require.Equal(t, "policy2", testContext.Source.Hooks()[0].Policy.GetName(), "policy name should be policy2")
	require.Len(t, testContext.Source.Hooks()[0].Bindings, 1, "should have one binding")
	require.Equal(t, "binding1", testContext.Source.Hooks()[0].Bindings[0].GetName(), "binding name should be binding1")

}

type FakePolicy struct {
	metav1.TypeMeta
	metav1.ObjectMeta

        }
    }

    @Override
    public <T> ImmutableAttributes concat(ImmutableAttributes node, Attribute<T> key, Isolatable<T> value) {
        if (key.equals(Usage.USAGE_ATTRIBUTE) || key.getName().equals(Usage.USAGE_ATTRIBUTE.getName())) {
            return usageCompatibilityHandler.doConcat(this, node, key, value);
        } else {
            return doConcatIsolatable(node, key, value);
        }
    }

            return new AccessorKey(containingType, replacedAccessor.getName(), replacedAccessor.getDescriptor());
        }

        public static AccessorKey ofNewMethod(JApiMethod jApiMethod) {
            String name = jApiMethod.getName();
            String descriptor = jApiMethod.getNewMethod().get().getSignature();

public class UnknownTestDescriptor implements TestDescriptorInternal {

    @Override
    public Object getId() {
        return "Unknown test (possible bug, please report)";
    }

    @Override
    public String getName() {
        return "Unknown test (possible bug, please report)";
    }

    @Override
    public String getClassName() {
        return null;
    }

    @Override
    public boolean isComposite() {

    @Test
    void testProjectInheritance() throws Exception {
        MavenProject p4 = getProject(projectFile("p4"));

        assertEquals("p4", p4.getName());

        // ----------------------------------------------------------------------
        // Value inherited from p3
        // ----------------------------------------------------------------------

    StringRef op_type_with_suffix =
        mlir::cast<NameLoc>(locations.front()).getName().strref();
    StringRef op_type =
        op_type_with_suffix.substr(0, op_type_with_suffix.size() - 1);
    new_unit.set_op_type(op_type.str());

    if (isa<NameLoc>(locations.back())) {
      StringRef name_loc_id =
          mlir::cast<NameLoc>(locations.back()).getName().strref();
      set_node_and_func_name(new_unit, name_loc_id);
    } else {