Uploaded image for project: 'Rules Repository'
  1. Rules Repository
  2. RSPEC-5845

Assertions comparing incompatible types should not be made

    XMLWordPrintable

    Details

    • Type: Bug Detection
    • Status: Active
    • Resolution: Unresolved
    • Labels:
    • Message:
      Change the assertion arguments to not compare dissimilar types
    • Highlighting:
      Hide

      Primary: The assertion actual argument.
      Secondary: if possible, the assertion expected argument.

      Show
      Primary: The assertion actual argument. Secondary: if possible, the assertion expected argument.
    • Default Severity:
      Critical
    • Impact:
      High
    • Likelihood:
      Low
    • Default Quality Profiles:
      Sonar way
    • Covered Languages:
      Java
    • Remediation Function:
      Constant/Issue
    • Constant Cost:
      5min
    • Analysis Level:
      Semantic Analysis
    • Analysis Scope:
      Test Sources

      Description

      Assertions comparing incompatible types always fail, and negative assertions always pass. At best, negative assertions are useless. At worst, the developer loses time trying to fix his code logic before noticing wrong assertions.

      Dissimilar types are:

      • comparing a primitive with null
      • comparing an object with an unrelated primitive (E.G. a string with an int)
      • comparing unrelated classes
      • comparing an array to a non-array
      • comparing two arrays of dissimilar types

      This rule also raises issues for unrelated class and interface or unrelated interface types in negative assertions. Because except in some corner cases, those types are more likely to be dissimilar. And inside a negative assertion, there is no test failure to inform the developer about this unusual comparison.

      Supported test frameworks:

      • JUnit4
      • JUnit5
      • AssertJ

      Noncompliant Code Example

      interface KitchenTool {}
      interface Plant {}
      class Spatula implements KitchenTool {}
      class Tree implements Plant {}
      
      void assertValues(int size,
                        Spatula spatula, KitchenTool tool,  KitchenTool[] tools,
                        Tree    tree,    Plant       plant, Tree[]        trees) {
      
        // Whatever the given values, those negative assertions will always pass due to dissimilar types:
        assertThat(size).isNotNull();           // Noncompliant; primitives can not be null
        assertThat(spatula).isNotEqualTo(tree); // Noncompliant; unrelated classes
        assertThat(tool).isNotSameAs(tools);    // Noncompliant; array & non-array
        assertThat(trees).isNotEqualTo(tools);  // Noncompliant; incompatible arrays
      
        // Those assertions will always fail
        assertThat(size).isNull();                       // Noncompliant
        assertThat(spatula).isEqualTo(tree);             // Noncompliant
      
        // Those negative assertions are more likely to always pass
        assertThat(spatula).isNotEqualTo(plant); // Noncompliant; unrelated class and interface
        assertThat(tool).isNotEqualTo(plant);    // Noncompliant; unrelated interfaces
      }
      

      See

      • S2159 - Silly equality checks should not be made

        Attachments

          Issue Links

          1.
          Python RSPEC-5908 Language-Specification Active Unassigned
          2.
          Javascript RSPEC-6088 Language-Specification Active Unassigned

            Activity

              People

              Assignee:
              Unassigned Unassigned
              Reporter:
              alban.auzeill Alban Auzeill
              Votes:
              0 Vote for this issue
              Watchers:
              1 Start watching this issue

                Dates

                Created:
                Updated: