#1149

Committed 30 Aug 2025 01:23PM UTC coverage: 3.023% (+0.02%) from 3.008%

Build # #1149

Build Type

push

Committed by

Commit Message

code optimized

Run Details

0 of 13 new or added lines in 3 files covered. (0.0%)

3 existing lines in 1 file now uncovered.

248 of 8204 relevant lines covered (3.02%)

0.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/edu/jiangxin/apktoolbox/convert/protobuf/supervised/DescriptorCache.java

package edu.jiangxin.apktoolbox.convert.protobuf.supervised;

import com.google.protobuf.DescriptorProtos;
import com.google.protobuf.Descriptors;
import com.google.protobuf.InvalidProtocolBufferException;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import java.util.stream.Stream;

public final class DescriptorCache {
    private static final Descriptors.FileDescriptor[] DEPENDENCIES = new Descriptors.FileDescriptor[0];

    public static DescriptorCache emptyCache() {
        return new DescriptorCache();
    }

    public static DescriptorCache fromDirectory(final Path directory) {
        Objects.requireNonNull(directory);

        if (!Files.isDirectory(directory)) {
            throw new IllegalArgumentException("Path must be a directory: " + directory);
        }

        final DescriptorCache cache = new DescriptorCache();
        try (final Stream<Path> walk = Files.walk(directory)) {
            walk.filter(Files::isRegularFile)
                    .forEach(cache::addDescriptors);
        } catch (final IOException e) {
            throw new UncheckedIOException(e);
        }
        return cache;
    }

    public static DescriptorCache fromFile(final Path descriptorsFile) {
        Objects.requireNonNull(descriptorsFile);

        if (!Files.isRegularFile(descriptorsFile)) {
            throw new IllegalArgumentException("Path must be a regular file: " + descriptorsFile);
        }
        final DescriptorCache cache = new DescriptorCache();
        cache.addDescriptors(descriptorsFile);
        return cache;
    }

    private final Map<String, Descriptors.Descriptor> typeNameToDescriptor = new HashMap<>();

    private DescriptorCache() {

    }

    @SuppressWarnings({"WeakerAccess", "UnusedReturnValue"})
    public Optional<Descriptors.Descriptor> addDescriptor(final Descriptors.Descriptor descriptor) {
        Objects.requireNonNull(descriptor);
        final String typeName = Objects.requireNonNull(descriptor.getName());

        return Optional.ofNullable(typeNameToDescriptor.put(typeName, descriptor));
    }

    @SuppressWarnings("WeakerAccess")
    public void addDescriptors(final Path descriptorsFile) {
        Objects.requireNonNull(descriptorsFile);

        if (!Files.isRegularFile(descriptorsFile)) {
            throw new IllegalArgumentException("Path must be a regular file: " + descriptorsFile);
        }

        try {
            addDescriptors(Files.readAllBytes(descriptorsFile));
        } catch (final IOException e) {
            throw new UncheckedIOException("While reading: " + descriptorsFile.toAbsolutePath(), e);
        }
    }

    @SuppressWarnings("WeakerAccess")
    public void addDescriptors(final byte[] descriptorsRaw) {
        Objects.requireNonNull(descriptorsRaw);

        try {
            final DescriptorProtos.FileDescriptorSet descriptorSet =
                    DescriptorProtos.FileDescriptorSet.parseFrom(descriptorsRaw);
            for (final DescriptorProtos.FileDescriptorProto descriptorFile : descriptorSet.getFileList()) {
                final Descriptors.FileDescriptor fileDescriptor =
                        Descriptors.FileDescriptor.buildFrom(descriptorFile, DescriptorCache.DEPENDENCIES);
                for (final Descriptors.Descriptor descriptor : fileDescriptor.getMessageTypes()) {
                    addDescriptor(descriptor);
                }
            }
        } catch (final InvalidProtocolBufferException | Descriptors.DescriptorValidationException e) {
            throw new RuntimeException(e);
        }
    }

    public Optional<Descriptors.Descriptor> getByTypeName(final String typeName) {
        Objects.requireNonNull(typeName);

        return Optional.ofNullable(typeNameToDescriptor.get(typeName));
    }

    public Collection<Descriptors.Descriptor> getDescriptors() {
        return Collections.unmodifiableCollection(typeNameToDescriptor.values());
    }

    public Collection<Map.Entry<String, Descriptors.Descriptor>> getEntries() {
        return Collections.unmodifiableCollection(typeNameToDescriptor.entrySet());
    }

    public boolean isEmpty() {
        return typeNameToDescriptor.isEmpty();
    }

    public int size() {
        return typeNameToDescriptor.size();
    }
}

1	package edu.jiangxin.apktoolbox.convert.protobuf.supervised;
2
3	import com.google.protobuf.DescriptorProtos;
4	import com.google.protobuf.Descriptors;
5	import com.google.protobuf.InvalidProtocolBufferException;
6
7	import java.io.IOException;
8	import java.io.UncheckedIOException;
9	import java.nio.file.Files;
10	import java.nio.file.Path;
11	import java.util.*;
12	import java.util.stream.Stream;
13
14	public final class DescriptorCache {
15	private static final Descriptors.FileDescriptor[] DEPENDENCIES = new Descriptors.FileDescriptor[0];	×
16
17	public static DescriptorCache emptyCache() {
18	return new DescriptorCache();	×
19	}
20
21	public static DescriptorCache fromDirectory(final Path directory) {
22	Objects.requireNonNull(directory);	×
23
24	if (!Files.isDirectory(directory)) {	×
25	throw new IllegalArgumentException("Path must be a directory: " + directory);	×
26	}
27
28	final DescriptorCache cache = new DescriptorCache();	×
29	try (final Stream<Path> walk = Files.walk(directory)) {	×
30	walk.filter(Files::isRegularFile)	×
31	.forEach(cache::addDescriptors);	×
32	} catch (final IOException e) {	×
33	throw new UncheckedIOException(e);	×
34	}	×
35	return cache;	×
36	}
37
38	public static DescriptorCache fromFile(final Path descriptorsFile) {
39	Objects.requireNonNull(descriptorsFile);	×
40
41	if (!Files.isRegularFile(descriptorsFile)) {	×
42	throw new IllegalArgumentException("Path must be a regular file: " + descriptorsFile);	×
43	}
44	final DescriptorCache cache = new DescriptorCache();	×
45	cache.addDescriptors(descriptorsFile);	×
46	return cache;	×
47	}
48
49	private final Map<String, Descriptors.Descriptor> typeNameToDescriptor = new HashMap<>();	×
50
51	private DescriptorCache() {	×
52
53	}	×
54
55	@SuppressWarnings({"WeakerAccess", "UnusedReturnValue"})
56	public Optional<Descriptors.Descriptor> addDescriptor(final Descriptors.Descriptor descriptor) {
57	Objects.requireNonNull(descriptor);	×
58	final String typeName = Objects.requireNonNull(descriptor.getName());	×
59
60	return Optional.ofNullable(typeNameToDescriptor.put(typeName, descriptor));	×
61	}
62
63	@SuppressWarnings("WeakerAccess")
64	public void addDescriptors(final Path descriptorsFile) {
65	Objects.requireNonNull(descriptorsFile);	×
66
67	if (!Files.isRegularFile(descriptorsFile)) {	×
68	throw new IllegalArgumentException("Path must be a regular file: " + descriptorsFile);	×
69	}
70
71	try {
72	addDescriptors(Files.readAllBytes(descriptorsFile));	×
73	} catch (final IOException e) {	×
74	throw new UncheckedIOException("While reading: " + descriptorsFile.toAbsolutePath(), e);	×
75	}	×
76	}	×
77
78	@SuppressWarnings("WeakerAccess")
79	public void addDescriptors(final byte[] descriptorsRaw) {
80	Objects.requireNonNull(descriptorsRaw);	×
81
82	try {
83	final DescriptorProtos.FileDescriptorSet descriptorSet =	×
84	DescriptorProtos.FileDescriptorSet.parseFrom(descriptorsRaw);	×
85	for (final DescriptorProtos.FileDescriptorProto descriptorFile : descriptorSet.getFileList()) {	×
86	final Descriptors.FileDescriptor fileDescriptor =	×
87	Descriptors.FileDescriptor.buildFrom(descriptorFile, DescriptorCache.DEPENDENCIES);	×
88	for (final Descriptors.Descriptor descriptor : fileDescriptor.getMessageTypes()) {	×
89	addDescriptor(descriptor);	×
90	}	×
91	}	×
NEW 92	} catch (final InvalidProtocolBufferException \| Descriptors.DescriptorValidationException e) {	×
NEW 93	throw new RuntimeException(e);	×
94	}	×
95	}	×
96
97	public Optional<Descriptors.Descriptor> getByTypeName(final String typeName) {
98	Objects.requireNonNull(typeName);	×
99
100	return Optional.ofNullable(typeNameToDescriptor.get(typeName));	×
101	}
102
103	public Collection<Descriptors.Descriptor> getDescriptors() {
104	return Collections.unmodifiableCollection(typeNameToDescriptor.values());	×
105	}
106
107	public Collection<Map.Entry<String, Descriptors.Descriptor>> getEntries() {
108	return Collections.unmodifiableCollection(typeNameToDescriptor.entrySet());	×
109	}
110
111	public boolean isEmpty() {
112	return typeNameToDescriptor.isEmpty();	×
113	}
114
115	public int size() {
116	return typeNameToDescriptor.size();	×
117	}
118	}

jiangxincode / ApkToolBoxGUI / #1149

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous