Sign upLogin

TestingResearchIllinois/NonDex

View on GitHub
Star

Showing 156 of 156 total issues

Method startDebugLinear has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
Open

    public List<Configuration> startDebugLinear(Configuration config, long start, long end) {
        List<Configuration> allFailingConfigurations = new LinkedList<Configuration>();

        List<Pair<Pair<Long, Long>, Configuration>> pairs = new LinkedList<Pair<Pair<Long, Long>, Configuration>>();
        pairs.add((Pair<Pair<Long, Long>, Configuration>)Pair.of((Pair<Long, Long>)Pair.of(start, end),
Severity: Minor
Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/DebugTask.java - About 2 hrs to fix

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 startDebugBinary has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
Open

    public List<Configuration> startDebugBinary(Configuration config) {
        List<Configuration> allFailingConfigurations = new LinkedList<Configuration>();

        List<Pair<Pair<Long, Long>, Configuration>> pairs = new LinkedList<Pair<Pair<Long, Long>, Configuration>>();
        pairs.add((Pair<Pair<Long, Long>, Configuration>)Pair.of((Pair<Long, Long>)Pair.of(0L,
Severity: Minor
Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/DebugTask.java - About 2 hrs to fix

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 startDebugBinary has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
Open

        private List<Configuration> startDebugBinary(Configuration config) {
            List<Configuration> allFailingConfigurations = new LinkedList<>();

            List<Pair<Pair<Long, Long>, Configuration>> pairs = new LinkedList<>();
            pairs.add(Pair.of(Pair.of(0L, (long) config.getInvocationCount()), config));
Severity: Minor
Found in nondex-gradle-plugin/plugin/src/main/java/edu/illinois/nondex/gradle/tasks/NonDexDebug.java - About 2 hrs to fix

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 generateHtml has 52 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    private void generateHtml(Set<String> allFailures, Configuration config) {
        String head = "<!DOCTYPE html>"
                + "<html>"
                + "<head>"
                + "<title>Test Results</title>"
Severity: Major
Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/NonDexMojo.java - About 2 hrs to fix

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

        private List<Configuration> createNewSeedsToRetry() {
        Configuration someFailingConfig = this.failingConfigurations.iterator().next();
        int newSeed = someFailingConfig.seed * ConfigurationDefaults.SEED_FACTOR;
        List<Configuration> retryWOtherSeeds = new LinkedList<>();
        for (int i = 0; i < 10; i++) {
    Severity: Major
    Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/DebugTask.java and 1 other location - About 1 hr to fix
    nondex-gradle-plugin/plugin/src/main/java/edu/illinois/nondex/gradle/tasks/NonDexDebug.java on lines 203..217

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 127.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

            private List<Configuration> createNewSeedsToRetry() {
            Configuration someFailingConfig = this.failingConfigurations.iterator().next();
            int newSeed = someFailingConfig.seed * ConfigurationDefaults.SEED_FACTOR;
            List<Configuration> retryWithOtherSeeds = new LinkedList<>();
            for (int i = 0; i < 10; i++) {
    Severity: Major
    Found in nondex-gradle-plugin/plugin/src/main/java/edu/illinois/nondex/gradle/tasks/NonDexDebug.java and 1 other location - About 1 hr to fix
    nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/DebugTask.java on lines 134..148

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 127.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Method generateHtml has 48 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        private void generateHtml(Set<String> allFailures, Configuration config) {
        String head = "<!DOCTYPE html>"
                + "<html>"
                + "<head>"
                + "<title>Test Results</title>"
    Severity: Minor
    Found in nondex-gradle-plugin/plugin/src/main/java/edu/illinois/nondex/gradle/internal/NonDexTestExecuter.java - About 1 hr to fix

      Method run has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
      Open

          public void run() throws MojoExecutionException {
        Xpp3Dom origNode = null;
        if (this.surefire.getConfiguration() != null) {
            origNode = new Xpp3Dom((Xpp3Dom) this.surefire.getConfiguration());
        }
      Severity: Minor
      Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/CleanSurefireExecution.java - About 1 hr to fix

      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 printAndGetSummary has 44 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          private boolean printAndGetSummary(Configuration config) {
        Set<String> allFailures = new LinkedHashSet<>();
        Map<String, Integer> countsOfFailingTestsWithoutShuffling = new LinkedHashMap<>();
        boolean failsWithoutShuffling = false;
        Logger.getGlobal().log(Level.INFO, "NonDex SUMMARY:");
      Severity: Minor
      Found in nondex-gradle-plugin/plugin/src/main/java/edu/illinois/nondex/gradle/internal/NonDexTestExecuter.java - About 1 hr to fix

        Method printSummary has 44 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            private void printSummary(Configuration config) {
        Set<String> allFailures = new LinkedHashSet<>();
        Map<String, Integer> countsOfFailingTestsWithoutShuffling =
            new LinkedHashMap<String, Integer>();
        boolean failsWithoutShuffling = false;
        Severity: Minor
        Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/NonDexMojo.java - About 1 hr to fix

          Identical blocks of code found in 2 locations. Consider refactoring.
          Open

              private String makeResultString(List<Configuration> debuggedOnes) {
        StringBuilder sb = new StringBuilder();
        for (Configuration config : debuggedOnes) {
            if (config == null) {
                continue;
          Severity: Major
          Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/DebugTask.java and 1 other location - About 1 hr to fix
          nondex-gradle-plugin/plugin/src/main/java/edu/illinois/nondex/gradle/tasks/NonDexDebug.java on lines 185..201

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 112.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Identical blocks of code found in 2 locations. Consider refactoring.
          Open

                  private String makeResultString(List<Configuration> debuggedOnes) {
            StringBuilder sb = new StringBuilder();
            for (Configuration config : debuggedOnes) {
                if (config == null) {
                    continue;
          Severity: Major
          Found in nondex-gradle-plugin/plugin/src/main/java/edu/illinois/nondex/gradle/tasks/NonDexDebug.java and 1 other location - About 1 hr to fix
          nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/DebugTask.java on lines 116..132

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 112.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Method run has 41 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              public void run() throws MojoExecutionException {
        Xpp3Dom origNode = null;
        if (this.surefire.getConfiguration() != null) {
            origNode = new Xpp3Dom((Xpp3Dom) this.surefire.getConfiguration());
        }
          Severity: Minor
          Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/CleanSurefireExecution.java - About 1 hr to fix

            Identical blocks of code found in 2 locations. Consider refactoring.
            Open

            package edu.illinois.nondex.functionalTest;

import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertThat;
            Severity: Major
            Found in nondex-gradle-plugin/plugin/src/functionalTest/resources/comprehensive-it/src/test/java/edu/illinois/nondex/functionalTest/MethodTest.java and 1 other location - About 1 hr to fix
            nondex-test/src/test/java/edu/illinois/nondex/core/MethodTest.java on lines 1..69

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 108.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Identical blocks of code found in 2 locations. Consider refactoring.
            Open

            /*
The MIT License (MIT)
Copyright (c) 2015 Alex Gyori
Copyright (c) 2022 Kaiyao Ke
Copyright (c) 2015 Owolabi Legunsen
            Severity: Major
            Found in nondex-test/src/test/java/edu/illinois/nondex/core/MethodTest.java and 1 other location - About 1 hr to fix
            nondex-gradle-plugin/plugin/src/functionalTest/resources/comprehensive-it/src/test/java/edu/illinois/nondex/functionalTest/MethodTest.java on lines 1..40

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 108.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Method execute has 40 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                @Override
    public void execute() throws MojoExecutionException, MojoFailureException {
        super.execute();
        Logger.getGlobal().log(Level.INFO, "The original argline is: " + this.originalArgLine);
        MojoExecutionException allExceptions = null;
            Severity: Minor
            Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/NonDexMojo.java - About 1 hr to fix

              Method setupArgline has 40 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  @Override
    protected void setupArgline(Xpp3Dom configNode) {
        String localRepo = this.mavenSession.getSettings().getLocalRepository();
        String pathToNondex = this.getPathToNondexJar(localRepo);
        String annotationsModuleName = "nondex-annotations";
              Severity: Minor
              Found in nondex-maven-plugin/src/main/java/edu/illinois/nondex/plugin/NonDexSurefireExecution.java - About 1 hr to fix

                Similar blocks of code found in 2 locations. Consider refactoring.
                Open

                    public void addHasNext() {
        MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC, "hasNext", "()Z", null, null);
        mv.visitCode();
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitFieldInsn(Opcodes.GETFIELD, "java/util/PriorityQueue$Itr", "iter", "Ljava/util/Iterator;");
                Severity: Major
                Found in nondex-instrumentation/src/main/java/edu/illinois/nondex/instr/PriorityQueueShufflingAdder.java and 1 other location - About 1 hr to fix
                nondex-instrumentation/src/main/java/edu/illinois/nondex/instr/WeakHashMapShufflingAdder.java on lines 50..59

                Duplicated Code

                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                Tuning

                This issue has a mass of 103.

                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                Refactorings

                Further Reading

                Similar blocks of code found in 2 locations. Consider refactoring.
                Open

                    public void addHasNext() {
        MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC, "hasNext", "()Z", null, null);
        mv.visitCode();
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitFieldInsn(Opcodes.GETFIELD, "java/util/WeakHashMap$HashIterator", "iter", "Ljava/util/Iterator;");
                Severity: Major
                Found in nondex-instrumentation/src/main/java/edu/illinois/nondex/instr/WeakHashMapShufflingAdder.java and 1 other location - About 1 hr to fix
                nondex-instrumentation/src/main/java/edu/illinois/nondex/instr/PriorityQueueShufflingAdder.java on lines 87..96

                Duplicated Code

                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                Tuning

                This issue has a mass of 103.

                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                Refactorings

                Further Reading

                Method execute has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    @Override
    public void execute(JvmTestExecutionSpec spec, TestResultProcessor testResultProcessor) {
        Logger.getGlobal().log(Level.INFO, "The original argline is: " + nondexTestTask.getOriginalArgLine());
        NonDexTestProcessor cleanRunProcessor = new NonDexTestProcessor(testResultProcessor);
                Severity: Minor
                Found in nondex-gradle-plugin/plugin/src/main/java/edu/illinois/nondex/gradle/internal/NonDexTestExecuter.java - About 1 hr to fix
                  Severity
                  Category
                  Status
                  Source
                  Language