Weird display names and test names for the IntMath::pow function in some cases

[amandelpie]

Description

Summarization framework generates odd-looking display names for the IntMath::pow functions. It should be improved or rewritten.

To Reproduce

Run test generation for the IntMath::pow

Expected behavior

It should contain something before -> symbol and also test names should be improved

Actual behavior

It generates two tests with the following summaries:

methodName = "testPow_ReturnBMultiplyAccum"
displayName = "-> return b * accum"

or

methodName = "testPow_ReturnAccum"
displayName = "-> return accum"

[onewhl]

It seems there is some problem with handling switch case inside for loop.
Expected display name for the provided code is switch(k) case: 1 -> return b * accum.
I will investigate ways to fix it.

[onewhl]

Take a look at the couple of code snippets, corresponding jimples, and generated tests for them.
In the first example, we have switch case inside for loop without a condition for accum or k. It ends when k is equal to 1.
For some reason for a couple of generated tests left parts of display names are missed (testPow_ReturnAccum, testPow_ReturnBMultiplyAccum).

In the second example, we have a condition for k, and the generated display names have information aboutswitch case(testPow_ReturnAccum, testPow_ReturnBMultiplyAccum).

I guess the problem might be in processing jimples in ExecutionStructureAnalysis class, see findIteration() method for example.
1)

    public static int pow(int b, int k) {
        for (int accum = 1; ; k /= 2) {
            switch (k) {
                case 0:
                    return accum;
                case 1:
                    return b * accum;
                default:
                    accum *= ((k & 1) == 0) ? 1 : b;
                    b *= b;
            }
        }
    }

{
  "basicTypeTag": "Initialization",
  "callOrderTag": "First",
  "codeEnvironment": "MUT",
  "executionFrequency": 1,
  "executionTag": "Executed",
  "index": 0,
  "invoke": null,
  "iterations": [],
  "line": -1,
  "next": {
    "basicTypeTag": "Initialization",
    "callOrderTag": "First",
    "codeEnvironment": "MUT",
    "executionFrequency": 1,
    "executionTag": "Executed",
    "index": 1,
    "invoke": null,
    "iterations": [],
    "line": -1,
    "next": {
      "basicTypeTag": "Assignment",
      "callOrderTag": "First",
      "codeEnvironment": "MUT",
      "executionFrequency": 1,
      "executionTag": "Executed",
      "index": 2,
      "invoke": null,
      "iterations": [
        {
          "basicTypeTag": "IterationStart",
          "callOrderTag": "First",
          "codeEnvironment": "MUT",
          "executionFrequency": 1,
          "executionTag": "Executed",
          "index": 3,
          "invoke": null,
          "iterations": [],
          "line": 24,
          "next": {
            "basicTypeTag": "Return",
            "callOrderTag": "First",
            "codeEnvironment": "MUT",
            "executionFrequency": 1,
            "executionTag": "Executed",
            "index": 4,
            "invoke": null,
            "iterations": [],
            "line": 26,
            "next": null,
            "recursion": null,
            "step": "Step(stmt=return i5, depth=0, decision=0)",
            "uniquenessTag": "Partly"
          },
          "recursion": null,
          "step": "Step(stmt=lookupswitch(i4) {     case 0: goto return i5;     case 1: goto $i0 = i3 * i5;     default: goto $i2 = i5; }, depth=0, decision=0)",
          "uniquenessTag": "Partly"
        }
      ],
      "line": 23,
      "next": null,
      "recursion": null,
      "step": "Step(stmt=i5 = 1, depth=0, decision=0)",
      "uniquenessTag": "Common"
    },
    "recursion": null,
    "step": "Step(stmt=i4 := @parameter1: int, depth=0, decision=0)",
    "uniquenessTag": "Common"
  },
  "recursion": null,
  "step": "Step(stmt=i3 := @parameter0: int, depth=0, decision=0)",
  "uniquenessTag": "Common"
}

public class MainTest {
    ///region Test suites for executable com.company.Main.pow

    ///region SYMBOLIC EXECUTION ENGINE: SUCCESSFUL EXECUTIONS for method pow(int, int)

    /**
     * <pre>
     * Test iterates the loop {@code for(int accum = 1; ; k /= 2) } once,
     *     inside this loop, the test returns from: {@code return accum; }</pre>
     */
    @Test
    @DisplayName("pow: -> return accum")
    public void testPow_ReturnAccum() {
        int actual = Main.pow(1, 0);

        assertEquals(1, actual);
    }

    /**
     * <pre>
     * Test iterates the loop {@code for(int accum = 1; ; k /= 2) } once,
     *     inside this loop, the test returns from: {@code return b * accum; }</pre>
     */
    @Test
    @DisplayName("pow: -> return b * accum")
    public void testPow_ReturnBMultiplyAccum() {
        int actual = Main.pow(1, 1);

        assertEquals(1, actual);
    }

    /**
     * <pre>
     * Test iterates the loop {@code for(int accum = 1; ; k /= 2) } twice,
     *     inside this loop, the test executes conditions:
     *     {@code (((k & 1) == 0)): False }
     * returns from: {@code return accum; }</pre>
     */
    @Test
    @DisplayName("pow: (k & 1) == 0 : False -> return accum")
    public void testPow_KBitwiseAnd1NotEqualsZero() {
        int actual = Main.pow(1, -1);

        assertEquals(1, actual);
    }

    /**
     * <pre>
     * Test iterates the loop {@code for(int accum = 1; ; k /= 2) } twice,
     *     inside this loop, the test executes conditions:
     *     {@code (((k & 1) == 0)): True }
     * returns from: {@code return b * accum; }</pre>
     */
    @Test
    @DisplayName("pow: (k & 1) == 0 : True -> return b * accum")
    public void testPow_KBitwiseAnd1EqualsZero() {
        int actual = Main.pow(1, 2);

        assertEquals(1, actual);
    }
    ///endregion

    ///endregion
}

    public static int pow(int b, int k) {
        for (int accum = 1; k < 4; k /= 2) {
            switch (k) {
                case 0:
                    return accum;
                case 1:
                    return b * accum;
                default:
                    accum *= ((k & 1) == 0) ? 1 : b;
                    b *= b;
            }
        }
        return b;
    }

{
  "basicTypeTag": "Initialization",
  "callOrderTag": "First",
  "codeEnvironment": "MUT",
  "executionFrequency": 1,
  "executionTag": "Executed",
  "index": 0,
  "invoke": null,
  "iterations": [],
  "line": -1,
  "next": {
    "basicTypeTag": "Initialization",
    "callOrderTag": "First",
    "codeEnvironment": "MUT",
    "executionFrequency": 1,
    "executionTag": "Executed",
    "index": 1,
    "invoke": null,
    "iterations": [],
    "line": -1,
    "next": {
      "basicTypeTag": "Assignment",
      "callOrderTag": "First",
      "codeEnvironment": "MUT",
      "executionFrequency": 1,
      "executionTag": "Executed",
      "index": 2,
      "invoke": null,
      "iterations": [],
      "line": 5,
      "next": {
        "basicTypeTag": "Return",
        "callOrderTag": "First",
        "codeEnvironment": "MUT",
        "executionFrequency": 1,
        "executionTag": "Executed",
        "index": 4,
        "invoke": null,
        "iterations": [],
        "line": 16,
        "next": null,
        "recursion": null,
        "step": "Step(stmt=return i3, depth=0, decision=0)",
        "uniquenessTag": "Unique"
      },
      "recursion": null,
      "step": "Step(stmt=i5 = 1, depth=0, decision=0)",
      "uniquenessTag": "Common"
    },
    "recursion": null,
    "step": "Step(stmt=i4 := @parameter1: int, depth=0, decision=0)",
    "uniquenessTag": "Common"
  },
  "recursion": null,
  "step": "Step(stmt=i3 := @parameter0: int, depth=0, decision=0)",
  "uniquenessTag": "Common"
}

public class MainTest {
    ///region Test suites for executable com.company.Main.pow

    ///region SYMBOLIC EXECUTION ENGINE: SUCCESSFUL EXECUTIONS #0 for method pow(int, int)

    /**
     * <pre>
     * Test does not iterate {@code for(int accum = 1; k < 4; k /= 2) }, returns from: {@code return b; }
     * </pre>
     */
    @Test
    @DisplayName("pow: -> return b")
    public void testPow_ReturnB() {
        int actual = Main.pow(1, 4);

        assertEquals(1, actual);
    }

    /**
     * <pre>
     * Test iterates the loop {@code for(int accum = 1; k < 4; k /= 2) } once,
     *     inside this loop, the test activates switch case: {@code 0 }, returns from: {@code return accum; }</pre>
     */
    @Test
    @DisplayName("pow: switch(k) case: 0 -> return accum")
    public void testPow_ReturnAccum() {
        int actual = Main.pow(1, 0);

        assertEquals(1, actual);
    }

    /**
     * <pre>
     * Test iterates the loop {@code for(int accum = 1; k < 4; k /= 2) } once,
     *     inside this loop, the test activates switch case: {@code 1 }, returns from: {@code return b * accum; }</pre>
     */
    @Test
    @DisplayName("pow: switch(k) case: 1 -> return b * accum")
    public void testPow_ReturnBMultiplyAccum() {
        int actual = Main.pow(1, 1);

        assertEquals(1, actual);
    }
    ///endregion

    ///region SYMBOLIC EXECUTION ENGINE: SUCCESSFUL EXECUTIONS #1 for method pow(int, int)
    /// 
    /// Common steps:
    /// <pre>
    /// Tests activate switch case: {@code default}.
    /// </pre>

    /**
     * <pre>
     * Test iterates the loop {@code for(int accum = 1; k < 4; k /= 2) } twice,
     *     inside this loop, the test executes conditions:
     *     {@code (((k & 1) == 0)): True }
     * activates switch case: {@code 1 }, returns from: {@code return b * accum; }</pre>
     */
    @Test
    @DisplayName("pow: (k & 1) == 0 : True -> return b * accum")
    public void testPow_KBitwiseAnd1EqualsZero() {
        int actual = Main.pow(1, 2);

        assertEquals(1, actual);
    }

    /**
     * <pre>
     * Test iterates the loop {@code for(int accum = 1; k < 4; k /= 2) } twice,
     *     inside this loop, the test executes conditions:
     *     {@code (((k & 1) == 0)): False }
     * activates switch case: {@code 0 }, returns from: {@code return accum; }</pre>
     */
    @Test
    @DisplayName("pow: (k & 1) == 0 : False -> return accum")
    public void testPow_KBitwiseAnd1NotEqualsZero() {
        int actual = Main.pow(1, -1);

        assertEquals(1, actual);
    }
    ///endregion

    ///endregion
}