v1.1

Author: Codegass

.gitignore

@@ -40,4 +40,6 @@ build/
 .cursor/
 
 /release-
-release-*/
+release-*/
+.DS_Store
+bin/main/META-INF/services/edu.stevens.swe.research.java.cli.analyzer.spi.AnalyzerTask

CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2024-05-30
+
+### ✨ New Features
+- **JUnit Lifecycle Annotation Detection**: Added support for detecting and extracting JUnit lifecycle methods
+  - `@Before`/`@BeforeEach`: Methods executed before each test
+  - `@BeforeAll`/`@BeforeClass`: Methods executed once before all tests
+  - `@After`/`@AfterEach`: Methods executed after each test  
+  - `@AfterAll`/`@AfterClass`: Methods executed once after all tests
+  - Supports both JUnit 4 and JUnit 5 annotations
+  - Lifecycle method source code is included in JSON output with field names: `beforeMethods`, `beforeAllMethods`, `afterMethods`, `afterAllMethods`
+
+### 🔧 Technical Enhancements
+- Enhanced `TestCaseAnalyzer` with `extractLifecycleMethods()` function
+- Added `extractMethodSourceCode()` helper method for consistent source code extraction
+- Extended `AnalysisResult` class with new fields for lifecycle methods
+
+### 📋 Updated Output Format
+```json
+{
+  "beforeMethods": ["@BeforeEach source code"],
+  "beforeAllMethods": ["@BeforeAll/@BeforeClass source code"], 
+  "afterMethods": ["@AfterEach source code"],
+  "afterAllMethods": ["@AfterAll/@AfterClass source code"],
+  // ... existing fields
+}
+```
+
 ## [1.0.1] - 2024-05-30
 
 ### 🐛 Bug Fixes

build.gradle

@@ -17,7 +17,7 @@ application {
 }
 
 group = 'edu.stevens'
-version = '1.0.1'
+version = '1.1.0'
 
 dependencies {
     // Use JitPack dependency for release builds

src/main/java/edu/stevens/swe/research/java/cli/Main.java

@@ -15,7 +15,7 @@
 import edu.stevens.swe.research.java.cli.analyzer.TaskResult;
 import edu.stevens.swe.research.java.cli.analyzer.ResultFormatter;
 
-@Command(name = "analyzer", mixinStandardHelpOptions = true, version = "Analyzer CLI 1.0",
+@Command(name = "analyzer", mixinStandardHelpOptions = true, version = "Analyzer CLI 1.1",
         description = "Analyzes Java source code based on specified tasks.")
 public class Main implements Callable<Integer> {
 

src/main/java/edu/stevens/swe/research/java/cli/analyzer/core/TestCaseAnalyzer.java

@@ -38,6 +38,10 @@ public static class AnalysisResult {
         public String testClassName = "";
         public String testCaseName = "";
         public String projectName = "";
+        public List<String> beforeMethods = new ArrayList<>();
+        public List<String> beforeAllMethods = new ArrayList<>();
+        public List<String> afterMethods = new ArrayList<>();
+        public List<String> afterAllMethods = new ArrayList<>();
 
         // Helper to create the JSON filename
         public String getJsonFileName() {
@@ -89,6 +93,9 @@ public AnalysisResult analyzeTestCase(CompilationUnit testCu, MethodDeclaration
             }
         }
 
+        // Extract lifecycle methods (@Before, @BeforeAll, @After, @AfterAll) from the test class
+        extractLifecycleMethods(testCu, result, originalFileSource);
+
         // Perform DFS-like analysis for parsed_statements_sequence and production_function_implementations
         dfsAnalyze(testCu, testMethodDeclaration, 0, result, result.testClassName + "." + result.testCaseName + getParameters(testMethodDeclaration.resolveBinding()), originalFileSource);
         return result;
@@ -432,4 +439,74 @@ public String getSourceFilePathForClass(String className, String sourceRootPath)
         System.err.println("Warning: Source file not found for class " + className + " under roots: " + potentialSourceRoots);
         return null;
     }
+
+    private void extractLifecycleMethods(CompilationUnit testCu, AnalysisResult result, String originalFileSource) {
+        // Get all type declarations in the compilation unit
+        for (Object type : testCu.types()) {
+            if (type instanceof TypeDeclaration) {
+                TypeDeclaration typeDecl = (TypeDeclaration) type;
+                
+                // Get all methods in the type
+                for (MethodDeclaration method : typeDecl.getMethods()) {
+                    // Check for lifecycle annotations
+                    for (Object modifier : method.modifiers()) {
+                        if (modifier instanceof Annotation) {
+                            Annotation annotation = (Annotation) modifier;
+                            String annotationName = annotation.getTypeName().getFullyQualifiedName();
+                            
+                            String methodSourceCode = extractMethodSourceCode(method, originalFileSource);
+                            
+                            // Check for @Before annotations (JUnit 4 and 5)
+                            if ("Before".equals(annotationName) || 
+                                "org.junit.Before".equals(annotationName) || 
+                                "org.junit.jupiter.api.BeforeEach".equals(annotationName) ||
+                                "BeforeEach".equals(annotationName)) {
+                                result.beforeMethods.add(methodSourceCode);
+                                System.out.println("  Found @Before method: " + method.getName().getIdentifier());
+                            }
+                            
+                            // Check for @BeforeAll annotations (JUnit 5)
+                            else if ("BeforeAll".equals(annotationName) || 
+                                     "org.junit.jupiter.api.BeforeAll".equals(annotationName) ||
+                                     "BeforeClass".equals(annotationName) ||
+                                     "org.junit.BeforeClass".equals(annotationName)) {
+                                result.beforeAllMethods.add(methodSourceCode);
+                                System.out.println("  Found @BeforeAll/@BeforeClass method: " + method.getName().getIdentifier());
+                            }
+                            
+                            // Check for @After annotations (JUnit 4 and 5)
+                            else if ("After".equals(annotationName) || 
+                                     "org.junit.After".equals(annotationName) || 
+                                     "org.junit.jupiter.api.AfterEach".equals(annotationName) ||
+                                     "AfterEach".equals(annotationName)) {
+                                result.afterMethods.add(methodSourceCode);
+                                System.out.println("  Found @After method: " + method.getName().getIdentifier());
+                            }
+                            
+                            // Check for @AfterAll annotations (JUnit 5)
+                            else if ("AfterAll".equals(annotationName) || 
+                                     "org.junit.jupiter.api.AfterAll".equals(annotationName) ||
+                                     "AfterClass".equals(annotationName) ||
+                                     "org.junit.AfterClass".equals(annotationName)) {
+                                result.afterAllMethods.add(methodSourceCode);
+                                System.out.println("  Found @AfterAll/@AfterClass method: " + method.getName().getIdentifier());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    private String extractMethodSourceCode(MethodDeclaration method, String originalFileSource) {
+        int startPos = method.getStartPosition();
+        int length = method.getLength();
+        
+        if (startPos >= 0 && length > 0 && (startPos + length) <= originalFileSource.length()) {
+            return originalFileSource.substring(startPos, startPos + length);
+        } else {
+            System.err.println("Warning: Invalid start/length for lifecycle method source code extraction. Method: " + method.getName().getIdentifier());
+            return "// Error extracting source code for " + method.getName().getIdentifier();
+        }
+    }
 } 

src/test/java/edu/stevens/swe/research/java/cli/analyzer/core/TestCaseAnalyzerTest.java

@@ -0,0 +1,42 @@
+package edu.stevens.swe.research.java.cli.analyzer.core;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+
+public class TestCaseAnalyzerTest {
+
+    @BeforeAll
+    static void setUpBeforeClass() {
+        System.out.println("Setting up before all tests");
+    }
+    
+    @BeforeEach
+    void setUp() {
+        System.out.println("Setting up before each test");
+    }
+    
+    @AfterEach
+    void tearDown() {
+        System.out.println("Cleaning up after each test");
+    }
+    
+    @AfterAll
+    static void tearDownAfterClass() {
+        System.out.println("Cleaning up after all tests");
+    }
+    
+    @Test
+    void testLifecycleMethodDetection() {
+        // This test method contains lifecycle annotations in the class
+        System.out.println("Running test method");
+    }
+    
+    @Test
+    void testAnotherMethod() {
+        // Another test method to verify multiple tests work
+        System.out.println("Running another test method");
+    }
+}