fix the test and change back gradlew file

Author: Randall-Jiang

ui-tests-starter/build.gradle.kts

@@ -95,10 +95,6 @@ tasks.register<Test>("uiTest") {
 
     systemProperty("ui.test.plugins", testPlugins.get().asPath)
     systemProperty("org.gradle.project.ideProfileName", ideProfile.name)
-    val testSuite = System.getenv("TEST_DIR") ?: ""
-    filter {
-        includeTestsMatching("software.aws.toolkits.jetbrains.uitests.testTests.*")
-    }
 }
 
 // hack to disable ui tests in ./gradlew check

ui-tests-starter/tst-243+/software/aws/toolkits/jetbrains/uitests/testTests/QTestGenerationChatTest.kt

@@ -51,13 +51,13 @@ class QTestGenerationChatTest {
     }
 
     @Test
-    fun `can run a test from the chat`() {
+    fun `test method not found error handling`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
-                Paths.get("tstData", "qTestGenerationTestProject")
+                Paths.get("tstData", "qTestGenerationTestProject/")
             )
-        ).withVersion(System.getProperty("org.gradle.project.ideProfileName"))
+        ).useRelease(System.getProperty("org.gradle.project.ideProfileName"))
 
         // inject connection
         useExistingConnectionForTest()
@@ -74,22 +74,24 @@ class QTestGenerationChatTest {
         }.runIdeWithDriver()
             .useDriverAndCloseIde {
                 waitForProjectOpen()
-                // required wait time for the system to be fully ready
+                openFile(Paths.get("testModule1", "HappyPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testNoFilePathScript)
+                val result = executePuppeteerScript(testMethodNotFoundErrorScript)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("a source file open right now that I can generate a test for"))
+                assertTrue(result.contains("Error message displayed correctly"))
+                assertTrue(result.contains("Input field re-enabled after error"))
+                assertTrue(result.contains("Feedback button found with correct text after error"))
             }
     }
 
     @Test
-    fun `test happy path from the chat`() {
+    fun `test cancel button during test generation`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
                 Paths.get("tstData", "qTestGenerationTestProject/")
             )
-        ).withVersion(System.getProperty("org.gradle.project.ideProfileName"))
+        ).useRelease(System.getProperty("org.gradle.project.ideProfileName"))
 
         // inject connection
         useExistingConnectionForTest()
@@ -108,24 +110,25 @@ class QTestGenerationChatTest {
                 waitForProjectOpen()
                 openFile(Paths.get("testModule1", "HappyPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testHappyPathScript)
+                val result = executePuppeteerScript(testCancelButtonScript)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("View Diff opened"))
-                assertTrue(result.contains("Result Accepted"))
-                assertTrue(result.contains("Unit test generation completed."))
-                assertTrue(result.contains("Input field re-enabled after acceptance"))
+                assertTrue(result.contains("Progress bar text displayed"))
+                assertTrue(result.contains("Cancel button found"))
+                assertTrue(result.contains("Cancel button clicked"))
+                assertTrue(result.contains("Test generation cancelled successfully"))
+                assertTrue(result.contains("Input field re-enabled after cancellation"))
                 assertTrue(result.contains("Feedback button found with correct text"))
             }
     }
 
     @Test
-    fun `test expected error path from the chat`() {
+    fun `test documentation generation error handling`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
                 Paths.get("tstData", "qTestGenerationTestProject/")
             )
-        ).withVersion(System.getProperty("org.gradle.project.ideProfileName"))
+        ).useRelease(System.getProperty("org.gradle.project.ideProfileName"))
 
         // inject connection
         useExistingConnectionForTest()
@@ -142,22 +145,24 @@ class QTestGenerationChatTest {
         }.runIdeWithDriver()
             .useDriverAndCloseIde {
                 waitForProjectOpen()
-                openFile(Paths.get("testModule1", "ErrorPath.java").toString())
+                openFile(Paths.get("testModule1", "HappyPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(expectedErrorPath)
+                val result = executePuppeteerScript(testDocumentationErrorScript)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("Test generation complete with expected error"))
+                assertTrue(result.contains("Error message displayed correctly"))
+                assertTrue(result.contains("Input field re-enabled after error"))
+                assertTrue(result.contains("Feedback button found with correct text after error"))
             }
     }
 
     @Test
-    fun `test unsupported language error path from the chat`() {
+    fun `test remove function error handling`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
                 Paths.get("tstData", "qTestGenerationTestProject/")
             )
-        ).withVersion(System.getProperty("org.gradle.project.ideProfileName"))
+        ).useRelease(System.getProperty("org.gradle.project.ideProfileName"))
 
         // inject connection
         useExistingConnectionForTest()
@@ -174,22 +179,24 @@ class QTestGenerationChatTest {
         }.runIdeWithDriver()
             .useDriverAndCloseIde {
                 waitForProjectOpen()
-                openFile(Paths.get("testModule2", "UnSupportedLanguage.kt").toString())
+                openFile(Paths.get("testModule1", "HappyPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(unsupportedLanguagePath)
+                val result = executePuppeteerScript(testRemoveFunctionErrorScript)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("Test generation complete with expected error"))
+                assertTrue(result.contains("Error message displayed correctly"))
+                assertTrue(result.contains("Input field re-enabled after error"))
+                assertTrue(result.contains("Feedback button found with correct text after error"))
             }
     }
 
     @Test
-    fun `test reject path from the chat`() {
+    fun `can run a test from the chat`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
-                Paths.get("tstData", "qTestGenerationTestProject/")
+                Paths.get("tstData", "qTestGenerationTestProject")
             )
-        ).useRelease(System.getProperty("org.gradle.project.ideProfileName"))
+        ).withVersion(System.getProperty("org.gradle.project.ideProfileName"))
 
         // inject connection
         useExistingConnectionForTest()
@@ -206,26 +213,22 @@ class QTestGenerationChatTest {
         }.runIdeWithDriver()
             .useDriverAndCloseIde {
                 waitForProjectOpen()
-                openFile(Paths.get("testModule1", "HappyPath.java").toString())
+                // required wait time for the system to be fully ready
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testRejectPathScript)
+                val result = executePuppeteerScript(testNoFilePathScript)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("View Diff opened"))
-                assertTrue(result.contains("Result Reject"))
-                assertTrue(result.contains("Unit test generation completed."))
-                assertTrue(result.contains("Input field re-enabled after rejection"))
-                assertTrue(result.contains("Feedback button found with correct text"))
+                assertTrue(result.contains("a source file open right now that I can generate a test for"))
             }
     }
 
     @Test
-    fun `test NL error from the chat`() {
+    fun `test happy path from the chat`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
                 Paths.get("tstData", "qTestGenerationTestProject/")
             )
-        ).useRelease(System.getProperty("org.gradle.project.ideProfileName"))
+        ).withVersion(System.getProperty("org.gradle.project.ideProfileName"))
 
         // inject connection
         useExistingConnectionForTest()
@@ -244,21 +247,24 @@ class QTestGenerationChatTest {
                 waitForProjectOpen()
                 openFile(Paths.get("testModule1", "HappyPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testNLErrorPathScript)
+                val result = executePuppeteerScript(testHappyPathScript)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("Command entered: /test /something/"))
-                assertTrue(result.contains("Error message displayed correctly"))
+                assertTrue(result.contains("View Diff opened"))
+                assertTrue(result.contains("Result Accepted"))
+                assertTrue(result.contains("Unit test generation completed."))
+                assertTrue(result.contains("Input field re-enabled after acceptance"))
+                assertTrue(result.contains("Feedback button found with correct text"))
             }
     }
 
     @Test
-    fun `test progress bar during test generation`() {
+    fun `test expected error path from the chat`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
                 Paths.get("tstData", "qTestGenerationTestProject/")
             )
-        ).useRelease(System.getProperty("org.gradle.project.ideProfileName"))
+        ).withVersion(System.getProperty("org.gradle.project.ideProfileName"))
 
         // inject connection
         useExistingConnectionForTest()
@@ -275,23 +281,22 @@ class QTestGenerationChatTest {
         }.runIdeWithDriver()
             .useDriverAndCloseIde {
                 waitForProjectOpen()
-                openFile(Paths.get("testModule1", "HappyPath.java").toString())
+                openFile(Paths.get("testModule1", "ErrorPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testProgressBarScript)
+                val result = executePuppeteerScript(expectedErrorPath)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("Progress bar text displayed"))
-                assertTrue(result.contains("Test generation completed successfully"))
+                assertTrue(result.contains("Test generation complete with expected error"))
             }
     }
 
     @Test
-    fun `test cancel button during test generation`() {
+    fun `test unsupported language error path from the chat`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
                 Paths.get("tstData", "qTestGenerationTestProject/")
             )
-        ).useRelease(System.getProperty("org.gradle.project.ideProfileName"))
+        ).withVersion(System.getProperty("org.gradle.project.ideProfileName"))
 
         // inject connection
         useExistingConnectionForTest()
@@ -308,21 +313,16 @@ class QTestGenerationChatTest {
         }.runIdeWithDriver()
             .useDriverAndCloseIde {
                 waitForProjectOpen()
-                openFile(Paths.get("testModule1", "HappyPath.java").toString())
+                openFile(Paths.get("testModule2", "UnSupportedLanguage.kt").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testCancelButtonScript)
+                val result = executePuppeteerScript(unsupportedLanguagePath)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("Progress bar text displayed"))
-                assertTrue(result.contains("Cancel button found"))
-                assertTrue(result.contains("Cancel button clicked"))
-                assertTrue(result.contains("Test generation cancelled successfully"))
-                assertTrue(result.contains("Input field re-enabled after cancellation"))
-                assertTrue(result.contains("Feedback button found with correct text"))
+                assertTrue(result.contains("Test generation complete with expected error"))
             }
     }
 
     @Test
-    fun `test documentation generation error handling`() {
+    fun `test reject path from the chat`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
@@ -347,16 +347,18 @@ class QTestGenerationChatTest {
                 waitForProjectOpen()
                 openFile(Paths.get("testModule1", "HappyPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testDocumentationErrorScript)
+                val result = executePuppeteerScript(testRejectPathScript)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("Error message displayed correctly"))
-                assertTrue(result.contains("Input field re-enabled after error"))
-                assertTrue(result.contains("Feedback button found with correct text after error"))
+                assertTrue(result.contains("View Diff opened"))
+                assertTrue(result.contains("Result Reject"))
+                assertTrue(result.contains("Unit test generation completed."))
+                assertTrue(result.contains("Input field re-enabled after rejection"))
+                assertTrue(result.contains("Feedback button found with correct text"))
             }
     }
 
     @Test
-    fun `test remove function error handling`() {
+    fun `test NL error from the chat`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
@@ -381,16 +383,15 @@ class QTestGenerationChatTest {
                 waitForProjectOpen()
                 openFile(Paths.get("testModule1", "HappyPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testRemoveFunctionErrorScript)
+                val result = executePuppeteerScript(testNLErrorPathScript)
                 assertTrue(result.contains("new tab opened"))
+                assertTrue(result.contains("Command entered: /test /something/"))
                 assertTrue(result.contains("Error message displayed correctly"))
-                assertTrue(result.contains("Input field re-enabled after error"))
-                assertTrue(result.contains("Feedback button found with correct text after error"))
             }
     }
 
     @Test
-    fun `test method not found error handling`() {
+    fun `test progress bar during test generation`() {
         val testCase = TestCase(
             IdeProductProvider.IC,
             LocalProjectInfo(
@@ -415,11 +416,10 @@ class QTestGenerationChatTest {
                 waitForProjectOpen()
                 openFile(Paths.get("testModule1", "HappyPath.java").toString())
                 Thread.sleep(30000)
-                val result = executePuppeteerScript(testMethodNotFoundErrorScript)
+                val result = executePuppeteerScript(testProgressBarScript)
                 assertTrue(result.contains("new tab opened"))
-                assertTrue(result.contains("Error message displayed correctly"))
-                assertTrue(result.contains("Input field re-enabled after error"))
-                assertTrue(result.contains("Feedback button found with correct text after error"))
+                assertTrue(result.contains("Progress bar text displayed"))
+                assertTrue(result.contains("Test generation completed successfully"))
             }
     }
 

ui-tests-starter/tstData/qTestGenerationTestProject/test/HappyPathTest.java

@@ -23,4 +23,64 @@ public void test_multiply_1() {
         double result = HappyPath.multiply(2.5, 3.0);
         assertEquals(7.5, result, 0.0001);
     }
+
+    /**
+     * Tests the multiply method with the largest possible double values.
+     * This verifies that the method handles extreme input values correctly.
+     */
+    @Test
+    public void testMultiplyWithMaxDoubleValues() {
+        double result = HappyPath.multiply(Double.MAX_VALUE, Double.MAX_VALUE);
+        assertEquals(Double.POSITIVE_INFINITY, result, 0);
+    }
+
+    /**
+     * Tests the multiply method with the smallest possible double values.
+     * This verifies that the method handles very small input values correctly.
+     */
+    @Test
+    public void testMultiplyWithMinDoubleValues() {
+        double result = HappyPath.multiply(Double.MIN_VALUE, Double.MIN_VALUE);
+        assertEquals(0.0, result, 0);
+    }
+
+    /**
+     * Tests the multiply method with NaN as input.
+     * This verifies that the method handles NaN correctly.
+     */
+    @Test
+    public void testMultiplyWithNaN() {
+        double result = HappyPath.multiply(Double.NaN, 1.0);
+        assertTrue(Double.isNaN(result));
+    }
+
+    /**
+     * Tests the multiply method with negative infinity as input.
+     * This verifies that the method handles negative infinity correctly.
+     */
+    @Test
+    public void testMultiplyWithNegativeInfinity() {
+        double result = HappyPath.multiply(Double.NEGATIVE_INFINITY, 1.0);
+        assertEquals(Double.NEGATIVE_INFINITY, result, 0);
+    }
+
+    /**
+     * Tests the multiply method with positive infinity as input.
+     * This verifies that the method handles infinity correctly.
+     */
+    @Test
+    public void testMultiplyWithPositiveInfinity() {
+        double result = HappyPath.multiply(Double.POSITIVE_INFINITY, 1.0);
+        assertEquals(Double.POSITIVE_INFINITY, result, 0);
+    }
+
+    /**
+     * Tests the multiply method with positive numbers.
+     * Verifies that the method correctly multiplies two positive doubles.
+     */
+    @Test
+    public void test_multiply_1_2() {
+        double result = HappyPath.multiply(2.5, 3.0);
+        assertEquals(7.5, result, 0.0001);
+    }
 }