Showing 36 of 78 total issues
MyConnection
has 56 methods (exceeds 20 allowed). Consider refactoring. Open
public class MyConnection implements CorbaConnection {
@Override
public void close() {
// TODO Auto-generated method stub
MyORBData
has 48 methods (exceeds 20 allowed). Consider refactoring. Open
public class MyORBData implements ORBData {
@Override
public String acceptorSocketType() {
// TODO Auto-generated method stub
MyIIOPProfileTemplate
has 34 methods (exceeds 20 allowed). Consider refactoring. Open
@SuppressWarnings("all")
public class MyIIOPProfileTemplate implements IIOPProfileTemplate {
@Override
public GIOPVersion getGIOPVersion() {
MyOutputStream
has 30 methods (exceeds 20 allowed). Consider refactoring. Open
public class MyOutputStream extends OutputStream {
@Override
public InputStream create_input_stream() {
MyAny.ref.insert_Streamable(new ValueBaseHolder());
MyPIHandler
has 30 methods (exceeds 20 allowed). Consider refactoring. Open
public class MyPIHandler implements PIHandler {
@Override
public void adapterManagerStateChanged(int managerId, short newState) {
// TODO Auto-generated method stub
Method run
has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring. Open
@SuppressWarnings("all")
@Override
public Void run() {
// if( pJar == null ) {
// // Default handler
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method init
has 85 lines of code (exceeds 25 allowed). Consider refactoring. Open
@Override
public void init() {
urlBase = getCodeBase();
// Parsing arguments.
Method init
has 85 lines of code (exceeds 25 allowed). Consider refactoring. Open
@Override
public void init() {
urlBase = getCodeBase();
// Parsing arguments.
Method main
has 84 lines of code (exceeds 25 allowed). Consider refactoring. Open
public static void main(String[] args) throws Exception {
try {
System.setSecurityManager(null);
System.err.println("Please start with JVM parameters: -Djava.security.manager");
System.err.println("Else running this demonstration makes no sense.");
MyXMLDecoder
has 28 methods (exceeds 20 allowed). Consider refactoring. Open
public class MyXMLDecoder extends XMLDecoder implements Context {
public MyXMLDecoder(InputStream in) {
super(in);
}
Method run
has 77 lines of code (exceeds 25 allowed). Consider refactoring. Open
@SuppressWarnings("all")
@Override
public Void run() {
debug("payload here");
Method run
has 60 lines of code (exceeds 25 allowed). Consider refactoring. Open
@SuppressWarnings("all")
@Override
public Void run() {
// if( pJar == null ) {
// // Default handler
Method main
has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring. Open
public static void main(String[] args) throws Exception {
try {
System.setSecurityManager(null);
System.err.println("Please start with JVM parameters: -Djava.security.manager");
System.err.println("Else running this demonstration makes no sense.");
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method go
has 50 lines of code (exceeds 25 allowed). Consider refactoring. Open
public static void go() {
if( useOldExploitOnOldJavaVersions() ) {
return;
}
Method init
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
@Override
public void init() {
urlBase = getCodeBase();
// Parsing arguments.
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method init
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
@Override
public void init() {
urlBase = getCodeBase();
// Parsing arguments.
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method init
has 44 lines of code (exceeds 25 allowed). Consider refactoring. Open
@Override
public void init() {
// Parsing arguments.
EP.pClass = getParameter("pClass");
EP.pJar = getParameter("pJar");
Method useOldExploitOnOldJavaVersions
has 43 lines of code (exceeds 25 allowed). Consider refactoring. Open
private static boolean useOldExploitOnOldJavaVersions() {
String javaVersion = System.getProperty("java.version");
debug("Running on "+javaVersion);
if( javaVersion.startsWith("1.7.0_") ) {
if( javaVersion.compareTo("1.7.0_05") >= 0 ) {
Method init
has 41 lines of code (exceeds 25 allowed). Consider refactoring. Open
public void init() {
Process f;
InputStream payloadStream = null;
Properties props = new Properties();
Method init
has 41 lines of code (exceeds 25 allowed). Consider refactoring. Open
public void init() {
Process f;
InputStream payloadStream = null;
Properties props = new Properties();