@ai-dev-tools/csharp-copilot-core 0.0.33 → 0.0.35

package/out/utils/getTestFile.js

@@ -33,15 +33,120 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExistingTestFile = getExistingTestFile;
-exports.createTestFile = createTestFile;
+exports.isTestFile = isTestFile;
+exports.determineTestFilePath = determineTestFilePath;
 exports.getOrCreatTestFile = getOrCreatTestFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const getCodeStructurePath_1 = require("./getCodeStructurePath");
+const getOrCreateDir_1 = require("./getOrCreateDir");
 const fast_xml_parser_1 = require("fast-xml-parser");
 const TEST_NAME_REGEX = /(Test|Tests)/i;
 const TEST_ATTR_REGEX = /\[(Fact|Theory|TestClass|TestMethod|Test)\]/;
+/**
+ * Check if a file path is a test file based on common naming conventions.
+ * Checks if the file name (without .cs extension) ends with test, tests, unittest, or unittests.
+ */
+function isTestFile(filepath) {
+    const fileName = path.basename(filepath).toLowerCase();
+    const fileNameWithoutExt = fileName.replace(/\.cs$/, '');
+    return fileNameWithoutExt.endsWith('test') ||
+        fileNameWithoutExt.endsWith('tests') ||
+        fileNameWithoutExt.endsWith('unittest') ||
+        fileNameWithoutExt.endsWith('unittests');
+}
+// Modifier pattern for C# type declarations (sealed, abstract, static, partial)
+const MODIFIER_PATTERN = `(?:sealed|abstract|static|partial)?\\s*`;
+// Helper function to create test file name pattern
+function getTestFileNamePattern(sourceFileName) {
+    return new RegExp(`^${sourceFileName}(Unit)?(\\.)?(Test|Tests)$`);
+}
+/**
+ * Extract words from a name string (e.g., project name, file name)
+ * Splits by camelCase and special characters, returns lowercase words
+ *
+ * @param name - The name string to extract words from
+ * @returns Array of lowercase words
+ */
+function extractWordsFromName(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(w => w.toLowerCase());
+}
+/**
+ * Calculate word-level matching score between two names
+ * Returns the count of matching words
+ *
+ * @param name1 - First name to compare
+ * @param name2 - Second name to compare
+ * @returns Number of matching words
+ */
+function calculateWordMatchCount(name1, name2) {
+    const words1 = extractWordsFromName(name1);
+    const words2 = extractWordsFromName(name2);
+    const words1Set = new Set(words1);
+    return words2.filter(w => words1Set.has(w)).length;
+}
+/**
+ * Get all subfolder names under a directory (recursive)
+ * Skips: bin, obj, .vs directories
+ *
+ * @param dirPath - Path to directory
+ * @returns Set of lowercase folder names
+ */
+function getSubfolderNamesRecursive(dirPath) {
+    const subfolders = new Set();
+    try {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && entry.name !== 'bin' && entry.name !== 'obj' && entry.name !== '.vs') {
+                subfolders.add(entry.name.toLowerCase());
+                // Recursively get subfolders
+                const subPath = path.join(dirPath, entry.name);
+                const deepSubfolders = getSubfolderNamesRecursive(subPath);
+                deepSubfolders.forEach(f => subfolders.add(f));
+            }
+        }
+    }
+    catch (err) {
+        // Ignore errors for inaccessible directories
+    }
+    return subfolders;
+}
+/**
+ * Get all .cs file names under a directory (recursive)
+ * Skips: bin, obj, .vs directories
+ *
+ * @param dirPath - Path to directory
+ * @returns Set of lowercase file names (without .cs extension)
+ */
+function getFileNamesRecursive(dirPath) {
+    const fileNames = new Set();
+    try {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === 'bin' || entry.name === 'obj' || entry.name === '.vs') {
+                continue;
+            }
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively get file names from subdirectories
+                const subFileNames = getFileNamesRecursive(fullPath);
+                subFileNames.forEach(f => fileNames.add(f));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.cs')) {
+                // Add file name without .cs extension
+                fileNames.add(entry.name.slice(0, -3).toLowerCase());
+            }
+        }
+    }
+    catch (err) {
+        // Ignore errors for inaccessible directories
+    }
+    return fileNames;
+}
 function findAllCsprojFiles(dir, excludedPaths) {
     const results = [];
     const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -134,47 +239,197 @@ function isFalconUnitTestProject(csprojPath) {
 }
 function isProjectNameMatchedTestProject(csprojPath, projectAssemblyName, projectName) {
     const testProjectName = path.basename(csprojPath, '.csproj').toLowerCase();
-    const fileNameEndWithTests = testProjectName.endsWith('.tests') || testProjectName.endsWith('.test') || testProjectName.endsWith('.unittest') || testProjectName.endsWith('.unittests');
-    if (testProjectName.startsWith(projectName.toLowerCase()) && fileNameEndWithTests) {
+    const projectNameLower = projectName.toLowerCase();
+    // Check if test project name exactly matches: projectName + suffix
+    const suffixes = ['.tests', '.test', '.unittest', '.unittests', 'tests', 'test'];
+    const exactMatch = suffixes.some(suffix => testProjectName === projectNameLower + suffix);
+    if (exactMatch) {
         return true;
     }
+    // Fallback: check assembly name with exact match
     const testProjectAssemblyName = (0, getCodeStructurePath_1.getAssemblyName)(csprojPath);
-    return testProjectAssemblyName?.toLowerCase()?.startsWith(projectAssemblyName.toLowerCase()) && fileNameEndWithTests;
+    if (testProjectAssemblyName) {
+        const assemblyNameLower = testProjectAssemblyName.toLowerCase();
+        const projectAssemblyNameLower = projectAssemblyName.toLowerCase();
+        return suffixes.some(suffix => assemblyNameLower === projectAssemblyNameLower + suffix);
+    }
+    return false;
 }
-function findTestProjectFromCsFile(csFilePath) {
+/**
+ * Search for test projects in repository directories
+ * Walks up from source file directory and collects all test projects that reference the source project
+ *
+ * @param csFilePath - Path to the source .cs file
+ * @param repoRoot - Repository root directory
+ * @param projectFilePath - Path to source project's .csproj
+ * @param normalizedProjectPath - Normalized path to source project
+ * @returns Array of test project paths that reference the source project
+ */
+function searchTestProjectsInRepositories(csFilePath, repoRoot, projectFilePath, normalizedProjectPath) {
     let currentDir = path.dirname(csFilePath);
-    const repoRoot = (0, getCodeStructurePath_1.getCodeRepoRoot)(csFilePath);
-    const projectFilePath = (0, getCodeStructurePath_1.getSourceFileCsprojFilePath)(csFilePath);
-    const projectName = path.basename(projectFilePath, '.csproj');
-    const projectAssemblyName = (0, getCodeStructurePath_1.getAssemblyName)(projectFilePath);
+    const possibleTestProjects = [];
     const excludedPaths = [currentDir];
     const repoRootParentPath = path.dirname(repoRoot);
-    // Start from the parent directory of the source file, because test project is usually in the parent directory
     currentDir = path.dirname(currentDir);
     while (currentDir !== repoRootParentPath) {
         const csprojFiles = findAllCsprojFiles(currentDir, excludedPaths);
-        for (const csproj of csprojFiles) {
-            if (isProjectNameMatchedTestProject(csproj, projectAssemblyName, projectName)) {
-                return csproj;
-            }
-            else if (isXapTestProject(csproj)) {
-                return csproj;
+        // Filter csproj files by standard test project naming patterns
+        const testProjectCandidates = csprojFiles.filter(csproj => {
+            const rawName = path.basename(csproj, '.csproj');
+            const csprojName = rawName.toLowerCase();
+            // Standard test naming: ends with .tests, .test, .unittests, .unittest, Tests, or Test
+            if (csprojName.endsWith('.tests') ||
+                csprojName.endsWith('.test') ||
+                csprojName.endsWith('.unittests') ||
+                csprojName.endsWith('.unittest') ||
+                csprojName.endsWith('tests') ||
+                csprojName.endsWith('test')) {
+                return true;
             }
-            else if (isFalconUnitTestProject(csproj)) {
-                const filename = path.basename(csproj, '.csproj').toLowerCase();
-                if (filename.endsWith('unittest') || filename.endsWith('unittests')) {
-                    return csproj;
-                }
+            // Word-level match: any word ends with "test" or "tests"
+            const words = extractWordsFromName(rawName);
+            return words.some(w => w.endsWith('test') || w.endsWith('tests'));
+        });
+        for (const csproj of testProjectCandidates) {
+            // Check if this csproj references the source project
+            const projectReferences = getProjectReferencesFromCsproj(csproj);
+            const referencesSourceProject = checkTestProjectReferencesSourceProject(csproj, normalizedProjectPath, projectReferences);
+            if (!referencesSourceProject) {
+                continue;
             }
-            else if (isGeneralTestProject(csproj)) {
-                return csproj;
+            const projectName = path.basename(projectFilePath, '.csproj');
+            const projectAssemblyName = (0, getCodeStructurePath_1.getAssemblyName)(projectFilePath);
+            if (isProjectNameMatchedTestProject(csproj, projectAssemblyName, projectName)) {
+                return [csproj];
             }
+            // Collect all test projects that reference the source project
+            possibleTestProjects.push(csproj);
         }
-        // Add current directory to excluded paths to avoid re-checking
         excludedPaths.push(currentDir);
         currentDir = path.dirname(currentDir);
     }
-    return null;
+    return possibleTestProjects;
+}
+/**
+ * Filter test projects by subfolder matching
+ * Returns projects sorted by match count, or proceeds to file name matching if all zero
+ *
+ * @param possibleTestProjects - List of test project paths
+ * @param projectFilePath - Path to source project's .csproj
+ * @returns Filtered projects with scores, or null if needs file name matching
+ */
+function filterBySubfolderMatching(possibleTestProjects, projectFilePath) {
+    const sourceProjectDir = path.dirname(projectFilePath);
+    const sourceSubfolders = getSubfolderNamesRecursive(sourceProjectDir);
+    const projectsWithScores = possibleTestProjects.map(csproj => {
+        const testProjectDir = path.dirname(csproj);
+        const testSubfolders = getSubfolderNamesRecursive(testProjectDir);
+        let matchCount = 0;
+        testSubfolders.forEach(folderName => {
+            if (sourceSubfolders.has(folderName)) {
+                matchCount++;
+            }
+        });
+        return { csproj, matchCount };
+    });
+    projectsWithScores.sort((a, b) => b.matchCount - a.matchCount);
+    const allZero = projectsWithScores.every(p => p.matchCount === 0);
+    return allZero ? null : projectsWithScores;
+}
+/**
+ * Filter test projects by file name matching with test suffixes
+ * Returns filtered projects if any matches found
+ *
+ * @param projectsWithScores - Projects with scores
+ * @param projectFilePath - Path to source project's .csproj
+ * @returns Filtered projects by file name, or null if no matches
+ */
+function filterByFileNameMatching(projectsWithScores, projectFilePath) {
+    const sourceProjectDir = path.dirname(projectFilePath);
+    const sourceFileNames = getFileNamesRecursive(sourceProjectDir);
+    const testSuffixes = ['.tests', '.test', '.unittests', '.unittest', 'tests', 'test'];
+    const filteredProjectsWithScores = projectsWithScores.filter(projectScore => {
+        const testProjectDir = path.dirname(projectScore.csproj);
+        const testFileNames = getFileNamesRecursive(testProjectDir);
+        for (const sourceFileName of sourceFileNames) {
+            for (const suffix of testSuffixes) {
+                const expectedTestFileName = (sourceFileName + suffix).toLowerCase();
+                if (testFileNames.has(expectedTestFileName)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    });
+    return filteredProjectsWithScores.length > 0 ? filteredProjectsWithScores : null;
+}
+/**
+ * Filter test projects by word-level matching
+ * Returns top 2 projects with highest word match count
+ *
+ * @param projectsWithScores - Projects with scores
+ * @param projectName - Name of source project
+ * @returns Top 2 projects by word match count, or empty array if no matches
+ */
+function filterByWordLevelMatching(projectsWithScores, projectName) {
+    const projectsWithWordScores = projectsWithScores.map(projectScore => {
+        const testProjectName = path.basename(projectScore.csproj, '.csproj');
+        const wordMatchCount = calculateWordMatchCount(projectName, testProjectName);
+        return { ...projectScore, wordMatchCount };
+    });
+    const projectsWithMatches = projectsWithWordScores.filter(p => p.wordMatchCount > 0);
+    if (projectsWithMatches.length === 0) {
+        return [];
+    }
+    projectsWithMatches.sort((a, b) => b.wordMatchCount - a.wordMatchCount);
+    const countToReturn = Math.min(2, projectsWithMatches.length);
+    return projectsWithMatches.slice(0, countToReturn).map(p => p.csproj);
+}
+/**
+ * Select top projects by score percentage or minimum count
+ *
+ * @param projectsWithScores - Projects with scores
+ * @param minCount - Minimum projects to return (default 2)
+ * @returns Array of selected project paths
+ */
+function selectTopProjectsByScore(projectsWithScores, minCount = 2) {
+    const countToReturn = Math.max(minCount, Math.ceil(projectsWithScores.length * 0.3));
+    return projectsWithScores.slice(0, countToReturn).map(p => p.csproj);
+}
+/**
+ * Find possible test projects for a C# source file
+ * Uses multi-level matching: folder names -> file names -> word-level matching
+ *
+ * @param csFilePath - Path to the source .cs file
+ * @returns Array of possible test project paths
+ */
+function findPossibleTestProjectsFromCsFile(csFilePath) {
+    const repoRoot = (0, getCodeStructurePath_1.getCodeRepoRoot)(csFilePath);
+    const projectFilePath = (0, getCodeStructurePath_1.getSourceFileCsprojFilePath)(csFilePath);
+    const projectName = path.basename(projectFilePath, '.csproj');
+    const normalizedProjectPath = path.normalize(projectFilePath);
+    // Search for test projects in repository
+    const possibleTestProjects = searchTestProjectsInRepositories(csFilePath, repoRoot, projectFilePath, normalizedProjectPath);
+    if (possibleTestProjects.length === 0) {
+        return [];
+    }
+    if (possibleTestProjects.length === 1) {
+        return possibleTestProjects;
+    }
+    // Try subfolder-level matching
+    const subfolderMatchResults = filterBySubfolderMatching(possibleTestProjects, projectFilePath);
+    if (subfolderMatchResults !== null) {
+        return selectTopProjectsByScore(subfolderMatchResults);
+    }
+    // If subfolder matching is all zero, try file name matching
+    const projectsWithScores = possibleTestProjects.map(csproj => ({ csproj, matchCount: 0 }));
+    const fileNameMatchResults = filterByFileNameMatching(projectsWithScores, projectFilePath);
+    if (fileNameMatchResults !== null) {
+        return selectTopProjectsByScore(fileNameMatchResults);
+    }
+    // If file name matching fails, try word-level matching
+    const wordLevelResults = filterByWordLevelMatching(projectsWithScores, projectName);
+    return wordLevelResults.length > 0 ? wordLevelResults : [];
 }
 function findPossibleTestFiles(testProjectDir, className) {
     const results = [];
@@ -201,27 +456,205 @@ function fileContainsTestAttributes(filePath) {
     const content = fs.readFileSync(filePath, 'utf-8');
     return TEST_ATTR_REGEX.test(content);
 }
-function getExistingTestFile(sourceCodePath) {
-    const absPath = path.resolve(sourceCodePath);
-    const testProjectPath = findTestProjectFromCsFile(absPath);
-    if (!testProjectPath) {
-        console.error(`No test project found for ${sourceCodePath}`);
-        return { testFilePath: null, testProjectPath: null };
+/**
+ * Check if a test project references a source project.
+ *
+ * @param testCsprojPath - Path to the test project's csproj file
+ * @param sourceCsprojPath - Path to the source project's csproj file
+ * @param projectReferences - Project references from the test csproj
+ * @returns True if test project references the source project, false otherwise
+ */
+function checkTestProjectReferencesSourceProject(testCsprojPath, sourceCsprojPath, projectReferences) {
+    const normalizedSourceCsprojPath = path.normalize(sourceCsprojPath).toLowerCase();
+    return projectReferences.some(ref => {
+        const resolvedRefPath = path.normalize(path.resolve(path.dirname(testCsprojPath), ref)).toLowerCase();
+        return resolvedRefPath === normalizedSourceCsprojPath;
+    });
+}
+function getProjectReferencesFromCsproj(csprojPath) {
+    const projectReferences = [];
+    try {
+        const xmlContent = fs.readFileSync(csprojPath, 'utf-8');
+        const parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: ''
+        });
+        const projectData = parser.parse(xmlContent);
+        const project = projectData.Project;
+        const itemGroups = Array.isArray(project.ItemGroup) ? project.ItemGroup : [project.ItemGroup];
+        for (const group of itemGroups) {
+            if (!group)
+                continue;
+            const projectRefs = group.ProjectReference;
+            if (!projectRefs)
+                continue;
+            const refList = Array.isArray(projectRefs) ? projectRefs : [projectRefs];
+            for (const ref of refList) {
+                if (ref.Include) {
+                    projectReferences.push(ref.Include);
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Failed to parse csproj: ${csprojPath}`, err);
     }
-    const testProjectDir = path.dirname(testProjectPath);
-    const className = path.basename(sourceCodePath, '.cs');
-    const candidateFiles = findPossibleTestFiles(testProjectDir, className);
-    for (const testFilePath of candidateFiles) {
-        if (TEST_NAME_REGEX.test(path.basename(testFilePath))) {
-            return { testFilePath, testProjectPath };
+    return projectReferences;
+}
+/**
+ * Calculate matching score between test file path and source file path based on directory structure.
+ * Returns two scores: continuous matching folders from end, and total matching folders.
+ *
+ * @param testRelativePath - Relative path of test file from test project root
+ * @param sourceRelativePath - Relative path of source file from source project root
+ * @returns Object with 'continuous' (right-to-left consecutive matches) and 'total' (all matches)
+ */
+function calculateMatchingScore(testRelativePath, sourceRelativePath) {
+    // Extract directory paths (remove file names)
+    const testDir = path.dirname(testRelativePath);
+    const sourceDir = path.dirname(sourceRelativePath);
+    // If both files are in root directory (no subdirectories), give highest priority
+    if ((testDir === '.' || testDir === '') && (sourceDir === '.' || sourceDir === '')) {
+        return { continuous: 1000, total: 1000 };
+    }
+    // Split paths into folder arrays (case-insensitive)
+    const testFolders = testDir === '.' || testDir === '' ? [] : testDir.split(path.sep).map(f => f.toLowerCase());
+    const sourceFolders = sourceDir === '.' || sourceDir === '' ? [] : sourceDir.split(path.sep).map(f => f.toLowerCase());
+    // 1. Calculate continuous matching folders from end (right to left)
+    let continuous = 0;
+    const minLength = Math.min(testFolders.length, sourceFolders.length);
+    for (let i = 1; i <= minLength; i++) {
+        if (testFolders[testFolders.length - i] === sourceFolders[sourceFolders.length - i]) {
+            continuous++;
+        }
+        else {
+            // Stop at first mismatch
+            break;
         }
     }
-    return { testFilePath: null, testProjectPath: testProjectPath };
+    // 2. Calculate total matching folders (not required to be continuous)
+    const sourceSet = new Set(sourceFolders);
+    const total = testFolders.filter(f => sourceSet.has(f)).length;
+    return { continuous, total };
 }
-function createXapTestProject(sourceCodePath) {
+function isTestFileForSourceFile(testFilePath, sourceCodePath) {
+    const sourceFileName = path.basename(sourceCodePath, '.cs');
+    const testFileName = path.basename(testFilePath, '.cs');
+    // First check: test file name should match common test patterns
+    // Patterns: SourceFile + (Unit)? + (.)? + (Test|Tests)
+    // Examples: SourceFileTests, SourceFileTest, SourceFile.Tests, SourceFile.Test, SourceFileUnitTests, SourceFileUnit.Tests
+    const testPattern = getTestFileNamePattern(sourceFileName);
+    const matchesPattern = testPattern.test(testFileName);
+    if (!matchesPattern) {
+        return false;
+    }
+    try {
+        // Read both files content
+        const testContent = fs.readFileSync(testFilePath, 'utf-8');
+        const sourceContent = fs.readFileSync(sourceCodePath, 'utf-8');
+        // First check: Extract namespace from source file and verify test file references it
+        const sourceNamespaceMatch = sourceContent.match(/namespace\s+([\w.]+)/);
+        if (!sourceNamespaceMatch || !sourceNamespaceMatch[1]) {
+            // No namespace found in source file, fall back to name-based matching
+            return true;
+        }
+        const sourceNamespace = sourceNamespaceMatch[1];
+        // Check if test file has using statement for source namespace
+        const usingRegex = new RegExp(`using\\s+${sourceNamespace.replace(/\./g, '\\.')};`);
+        if (!usingRegex.test(testContent)) {
+            // Test file doesn't reference source namespace
+            return false;
+        }
+        // Second check: Extract the main type name from source file (public or internal)
+        // Supports: class, interface, struct, record (but not nested private/protected types)
+        // Priority: public > internal; match first public, fallback to first internal
+        // Handles modifiers: sealed, abstract, static, partial
+        const publicTypeMatch = sourceContent.match(new RegExp(`\\bpublic\\s+${MODIFIER_PATTERN}(?:class|interface|struct|record)\\s+(\\w+)`));
+        const internalTypeMatch = sourceContent.match(new RegExp(`\\binternal\\s+${MODIFIER_PATTERN}(?:class|interface|struct|record)\\s+(\\w+)`));
+        const sourceTypeMatch = publicTypeMatch || internalTypeMatch;
+        if (!sourceTypeMatch || !sourceTypeMatch[1]) {
+            // No public or internal type found - this file might be a utility/helper file
+            // without testable classes, so it shouldn't have a test file
+            return false;
+        }
+        const sourceTypeName = sourceTypeMatch[1];
+        // Check if test file references the source type name or its interface
+        // If source is an interface (direct interface definition), only match itself
+        // If source is a class/struct/record, also match interface (ITypeName)
+        const isSourceInterface = new RegExp(`\\b(?:public|internal)\\s+${MODIFIER_PATTERN}interface\\s+(?:\\w+)`).test(sourceContent);
+        let sourceCodeTypeReferenceRegex;
+        if (isSourceInterface) {
+            // Source is an interface, match only itself
+            sourceCodeTypeReferenceRegex = new RegExp(`\\b${sourceTypeName}\\b`, 'g');
+        }
+        else {
+            // Source is a class/struct/record, match both TypeName and ITypeName
+            sourceCodeTypeReferenceRegex = new RegExp(`\\b(I)?${sourceTypeName}\\b`, 'g');
+        }
+        if (sourceCodeTypeReferenceRegex.test(testContent)) {
+            return true;
+        }
+        // Namespace matches but class name not found in test file
+        return false;
+    }
+    catch (err) {
+        console.error(`Failed to read file content for matching: ${err}`);
+        // Strict mode: if we can't verify the content, treat as non-matching
+        return false;
+    }
 }
-function createTestFile(sourceCodePath) {
-    const testProjectPath = findTestProjectFromCsFile(sourceCodePath);
+/**
+ * Find an existing test file from sibling source files in the same or parent directories.
+ * This helps determine the best location for a new test file by looking at where
+ * existing test files are located for nearby source files.
+ *
+ * @param sourceCodePath - Path to the source file
+ * @param testCsprojPath - Path to the test project's csproj file
+ * @param sourceCsprojPath - Path to the source project's csproj file
+ * @returns Object with siblingTestFilePath and sourceRelativeDepth if found, otherwise null
+ */
+function findSiblingTestFile(sourceCodePath, testCsprojPath, sourceCsprojPath) {
+    const sourceProjectDir = path.dirname(sourceCsprojPath);
+    let currentDir = path.dirname(sourceCodePath);
+    let depth = 0;
+    // Search from current directory up to source project root
+    while (currentDir.toLowerCase().startsWith(sourceProjectDir.toLowerCase()) && currentDir.length >= sourceProjectDir.length) {
+        try {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            const csFiles = entries
+                .filter(e => e.isFile() && e.name.endsWith('.cs') && path.join(currentDir, e.name) !== sourceCodePath)
+                .map(e => path.join(currentDir, e.name));
+            for (const csFile of csFiles) {
+                // Try to find test file for this sibling source file
+                const result = findMatchingTestFileInProject(testCsprojPath, csFile, sourceCsprojPath);
+                if (result.testFilePath) {
+                    return { siblingTestFilePath: result.testFilePath, sourceRelativeDepth: depth };
+                }
+            }
+        }
+        catch (err) {
+            // Ignore errors for inaccessible directories
+        }
+        // Move to parent directory
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+        depth++;
+    }
+    return null;
+}
+/**
+ * Determine the best test file path for a source file.
+ * This function only calculates the path, it does not create any directories.
+ *
+ * @param sourceCodePath - Path to the source file
+ * @param testCsprojPath - Path to the test project's csproj file (optional)
+ * @returns Object with testFilePath, testProjectPath, and testFileExist flag
+ */
+function determineTestFilePath(sourceCodePath, testCsprojPath) {
+    let testProjectPath = testCsprojPath;
     if (!testProjectPath) {
         console.error(`No test project found for ${sourceCodePath}`);
         return { testFilePath: null, testProjectPath: null };
@@ -229,38 +662,278 @@ function createTestFile(sourceCodePath) {
     const sourceFileName = path.basename(sourceCodePath, '.cs');
     const testFileName = `${sourceFileName}Tests.cs`;
     const sourceFileProjectPath = (0, getCodeStructurePath_1.getSourceFileProjectDir)(sourceCodePath);
-    const sourceFileDir = path.dirname(sourceCodePath);
-    const testFileRelativePath = sourceFileDir.replace(sourceFileProjectPath, "");
-    const testProjecDir = path.dirname(testProjectPath);
-    const testFilePath = path.join(testProjecDir, testFileRelativePath, testFileName);
-    const testFileDir = path.dirname(testFilePath);
-    // Create all missing directories recursively
-    fs.mkdirSync(testFileDir, { recursive: true });
-    console.log(`Created test file dir at ${testFilePath}`);
-    return { testFilePath, testProjectPath };
+    const sourceCsprojPath = (0, getCodeStructurePath_1.getSourceFileCsprojFilePath)(sourceCodePath);
+    // Try to find sibling test file to determine the best location
+    const siblingResult = findSiblingTestFile(sourceCodePath, testProjectPath, sourceCsprojPath);
+    let testFilePath;
+    if (siblingResult) {
+        // Found sibling test file, calculate new test file path based on it
+        const siblingTestDir = path.dirname(siblingResult.siblingTestFilePath);
+        const sourceFileDir = path.dirname(sourceCodePath);
+        if (siblingResult.sourceRelativeDepth === 0) {
+            // Sibling is in the same directory, put test file in the same test directory
+            testFilePath = path.join(siblingTestDir, testFileName);
+        }
+        else {
+            // Sibling is in a parent directory, calculate the relative path from sibling source to current source
+            let relativeParts = [];
+            let tempDir = sourceFileDir;
+            for (let i = 0; i < siblingResult.sourceRelativeDepth; i++) {
+                relativeParts.unshift(path.basename(tempDir));
+                tempDir = path.dirname(tempDir);
+            }
+            // The relative path from the found sibling source dir to our source file
+            const relativePath = relativeParts.join(path.sep);
+            testFilePath = path.join(siblingTestDir, relativePath, testFileName);
+        }
+    }
+    else {
+        // No sibling test file found, use original logic
+        const sourceFileDir = path.dirname(sourceCodePath);
+        const testFileRelativePath = sourceFileDir.replace(sourceFileProjectPath, "");
+        const testProjecDir = path.dirname(testProjectPath);
+        testFilePath = path.join(testProjecDir, testFileRelativePath, testFileName);
+    }
+    // Check if the test file already exists
+    const testFileExist = fs.existsSync(testFilePath);
+    if (testFileExist) {
+        console.log(`Test file already exists at ${testFilePath}`);
+    }
+    return { testFilePath, testProjectPath, testFileExist };
+}
+/**
+ * Search for matching test file in a specific test project.
+ * Uses directory structure matching and file content analysis to find the best match.
+ *
+ * @param testCsprojPath - Path to the test project's csproj file
+ * @param sourceCodePath - Path to the source file
+ * @param sourceCsprojPath - Path to the source project's csproj file
+ * @returns Object with testFilePath and testProjectPath if found, otherwise both null
+ */
+function findMatchingTestFileInProject(testCsprojPath, sourceCodePath, sourceCsprojPath) {
+    const testProjectDir = path.dirname(testCsprojPath);
+    // Get source file's csproj directory
+    const sourceCsprojDir = path.dirname(sourceCsprojPath);
+    // Calculate relative path of source file from its csproj directory
+    const sourceRelativePath = path.relative(sourceCsprojDir, sourceCodePath);
+    // Get source file name for filtering
+    const sourceFileName = path.basename(sourceCodePath, '.cs');
+    // Find .cs files containing source file name (optimization to reduce file count)
+    const allTestFiles = findPossibleTestFiles(testProjectDir, sourceFileName);
+    // Filter by file name pattern first to reduce unnecessary file reads
+    const testPattern = getTestFileNamePattern(sourceFileName);
+    // Create list of candidates with their matching scores
+    const candidatesWithScores = allTestFiles
+        .filter(file => {
+        const testFileName = path.basename(file, '.cs');
+        return testPattern.test(testFileName);
+    })
+        .map(file => {
+        const testRelativePath = path.relative(testProjectDir, file);
+        const score = calculateMatchingScore(testRelativePath, sourceRelativePath);
+        return {
+            filePath: file,
+            relativePath: testRelativePath,
+            score: score
+        };
+    })
+        // Sort by continuous match first, then by total match
+        .sort((a, b) => {
+        if (b.score.continuous !== a.score.continuous) {
+            return b.score.continuous - a.score.continuous;
+        }
+        return b.score.total - a.score.total;
+    });
+    for (const candidate of candidatesWithScores) {
+        if (isTestFileForSourceFile(candidate.filePath, sourceCodePath)) {
+            return { testFilePath: candidate.filePath, testProjectPath: testCsprojPath };
+        }
+    }
+    return { testFilePath: null, testProjectPath: null };
+}
+function getTestFileFromChangedFiles(sourceCodePath, changedTestFiles) {
+    if (!changedTestFiles || changedTestFiles.length === 0) {
+        return { testFilePath: null, testProjectPath: null };
+    }
+    // Get the csproj of the source code
+    const sourceCsprojPath = (0, getCodeStructurePath_1.getSourceFileCsprojFilePath)(sourceCodePath);
+    if (!sourceCsprojPath) {
+        return { testFilePath: null, testProjectPath: null };
+    }
+    // Cache to store project references from csproj to avoid re-parsing
+    const csprojCache = new Map();
+    // Store test projects that reference the source project
+    const referencingTestProjects = new Set();
+    for (const testFilePath of changedTestFiles) {
+        if (!fs.existsSync(testFilePath)) {
+            continue;
+        }
+        // Get the csproj of the test file
+        const testCsprojPath = (0, getCodeStructurePath_1.getSourceFileCsprojFilePath)(testFilePath);
+        if (!testCsprojPath) {
+            continue;
+        }
+        // Check cache first
+        let projectReferences = csprojCache.get(testCsprojPath);
+        if (!projectReferences) {
+            projectReferences = getProjectReferencesFromCsproj(testCsprojPath);
+            csprojCache.set(testCsprojPath, projectReferences);
+        }
+        // Check if test project references the source project
+        const normalizedSourceCsprojPath = path.normalize(sourceCsprojPath);
+        if (checkTestProjectReferencesSourceProject(testCsprojPath, normalizedSourceCsprojPath, projectReferences)) {
+            referencingTestProjects.add(testCsprojPath);
+            // Check if this test file is for the source file
+            if (isTestFileForSourceFile(testFilePath, sourceCodePath)) {
+                return { testFilePath, testProjectPath: testCsprojPath };
+            }
+        }
+    }
+    // Fallback: search all test files in projects that reference the source project
+    for (const testCsprojPath of referencingTestProjects) {
+        const result = findMatchingTestFileInProject(testCsprojPath, sourceCodePath, sourceCsprojPath);
+        if (result.testFilePath) {
+            return result;
+        }
+    }
+    return { testFilePath: null, testProjectPath: null };
 }
-function getOrCreatTestFile(sourceCodePath, testFilePath, isXapCode) {
+function getOrCreatTestFile(sourceCodePath, testFilePath, changedTestFiles) {
     let finalTestFilePath = testFilePath;
     let finalTestProjectPath;
     let testFileExist = !!testFilePath && fs.existsSync(testFilePath);
+    // If testFilePath is provided, get its project path and return directly
+    if (testFilePath && testFilePath.trim() !== '') {
+        finalTestProjectPath = (0, getCodeStructurePath_1.getSourceFileCsprojFilePath)(testFilePath);
+        return { testFilePath: finalTestFilePath, testProjectPath: finalTestProjectPath, testFileExist };
+    }
     // if outputPath param is not provided, try to find an existing test file
     // if no existing test file found, create a new one in test project
-    if (!testFilePath || testFilePath.trim() === '') {
-        console.log(' Output path is missing. outputPath:', testFilePath, ', start looking for existing test project');
-        let result = getExistingTestFile(sourceCodePath);
+    console.log(' Output path is missing. outputPath:', testFilePath, ', start looking for existing test project');
+    // Try to find test file from changed files first
+    let resultFromChangedFiles = getTestFileFromChangedFiles(sourceCodePath, changedTestFiles);
+    if (resultFromChangedFiles.testFilePath) {
+        return { testFilePath: resultFromChangedFiles.testFilePath, testProjectPath: resultFromChangedFiles.testProjectPath, testFileExist: true };
+    }
+    // Fallback: try to find existing test file
+    const possibleCSProjPaths = findPossibleTestProjectsFromCsFile(sourceCodePath);
+    if (!possibleCSProjPaths || possibleCSProjPaths.length === 0) {
+        console.error(` No test project found for source code: ${sourceCodePath}`);
+        return { testFilePath: null, testProjectPath: null, testFileExist: false };
+    }
+    // Get the source csproj path for matching
+    const sourceCsprojPath = (0, getCodeStructurePath_1.getSourceFileCsprojFilePath)(sourceCodePath);
+    if (!sourceCsprojPath) {
+        console.error(` Cannot find source csproj for: ${sourceCodePath}`);
+        return { testFilePath: null, testProjectPath: null, testFileExist: false };
+    }
+    // Try to find existing test file in each possible test project
+    for (const testCsprojPath of possibleCSProjPaths) {
+        const result = findMatchingTestFileInProject(testCsprojPath, sourceCodePath, sourceCsprojPath);
         if (result.testFilePath) {
             testFileExist = true;
-            console.log(`Found existing test file: ${result.testFilePath}`);
-        }
-        else {
-            console.log('No existing test file found, creating a new one.');
-            result = createTestFile(sourceCodePath);
+            finalTestFilePath = result.testFilePath;
+            finalTestProjectPath = result.testProjectPath;
+            return { testFilePath: finalTestFilePath, testProjectPath: finalTestProjectPath, testFileExist };
         }
-        finalTestFilePath = result.testFilePath;
-        finalTestProjectPath = result.testProjectPath;
+    }
+    // No existing test file found, determine test file path (may find existing)
+    const result = determineTestFilePath(sourceCodePath, possibleCSProjPaths[0]);
+    if (!result.testFilePath || !result.testProjectPath) {
+        console.error(`Failed to determine test file path for ${sourceCodePath}`);
+        return { testFilePath: null, testProjectPath: null, testFileExist: false };
+    }
+    finalTestFilePath = result.testFilePath;
+    finalTestProjectPath = result.testProjectPath;
+    testFileExist = result.testFileExist ?? false;
+    // Create directory if test file doesn't exist
+    if (!testFileExist) {
+        (0, getOrCreateDir_1.getOrCreateDir)(path.dirname(finalTestFilePath));
     }
     return { testFilePath: finalTestFilePath, testProjectPath: finalTestProjectPath, testFileExist };
 }
+// // Verify test file paths for all projects
+// function verifyTestFilePaths(): void {
+//     const baseFolder = 'Q:\\src\\Microsoft.News.OneService';
+//     const outputFile = 'q:\\verifyTestFilePaths_results.txt';
+//     const results: string[] = [];
+//     try {
+//         // Recursively find all non  test csproj files 
+//         const getAllCsprojFiles = (dir: string): string[] => {
+//             const csprojFiles: string[] = [];
+//             try {
+//                 const entries = fs.readdirSync(dir, { withFileTypes: true });
+//                 for (const entry of entries) {
+//                     const fullPath = path.join(dir, entry.name);
+//                     if (entry.isDirectory() && entry.name !== 'bin' && entry.name !== 'obj' && entry.name !== '.vs') {
+//                         csprojFiles.push(...getAllCsprojFiles(fullPath));
+//                     } else if (entry.isFile() && entry.name.endsWith('.csproj')) {
+//                         // Filter by test project naming patterns
+//                         const rawName = path.basename(fullPath, '.csproj');
+//                         const words = rawName
+//                             .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+//                             .split(/[^a-zA-Z0-9]+/)
+//                             .filter(Boolean)
+//                             .map(w => w.toLowerCase());
+//                         if (words.every(w => !w.endsWith('test') && !w.endsWith('tests'))) {
+//                             csprojFiles.push(fullPath);
+//                         }
+//                     }
+//                 }
+//             } catch (err) {
+//                 // Skip inaccessible directories
+//             }
+//             return csprojFiles;
+//         };
+//         // Get first .cs file in a directory (recursive search)
+//         const getFirstCsFile = (dir: string): string | null => {
+//             try {
+//                 const entries = fs.readdirSync(dir, { withFileTypes: true });
+//                 // First pass: look for .cs files in current directory
+//                 for (const entry of entries) {
+//                     if (entry.isFile() && entry.name.endsWith('.cs')) {
+//                         return path.join(dir, entry.name);
+//                     }
+//                 }
+//                 // Second pass: recurse into subdirectories
+//                 for (const entry of entries) {
+//                     if (entry.isDirectory() && entry.name !== 'bin' && entry.name !== 'obj' && entry.name !== '.vs') {
+//                         const fullPath = path.join(dir, entry.name);
+//                         const result = getFirstCsFile(fullPath);
+//                         if (result) {
+//                             return result;
+//                         }
+//                     }
+//                 }
+//             } catch (err) {
+//                 // Skip if directory can't be read
+//             }
+//             return null;
+//         };
+//         // Find all csproj files
+//         const csprojFiles = getAllCsprojFiles(baseFolder);
+//         // Process each csproj
+//         for (const csprojPath of csprojFiles) {
+//             const csprojDir = path.dirname(csprojPath);
+//             const csFile = getFirstCsFile(csprojDir);
+//             if (csFile) {
+//                 const result = getOrCreatTestFile(csFile, undefined);
+//                 const testFilePath = result.testFilePath || 'NOT_FOUND';
+//                 const testProjectPath = result.testProjectPath || 'NOT_FOUND';
+//                 results.push(`${csprojPath}\t${csFile}\t${testFilePath}\t${testProjectPath}\t${result.testFileExist}`);
+//                 console.log(`Processed: ${csprojPath}`);
+//             }
+//         }
+//         // Write results to file
+//         fs.writeFileSync(outputFile, results.join('\n'), 'utf-8');
+//         console.log(`Results written to ${outputFile}`);
+//     } catch (err) {
+//         console.error(`Error during verification: ${err}`);
+//     }
+// }
+// // Uncomment to run verification
+// verifyTestFilePaths();
+// getOrCreatTestFile("Q:\\src\\Microsoft.News.OneService\\Libraries\\Tests\\MockStrategies\\MockDataException.cs", undefined);
 // Example usage
 // const csFilePath = "D:\\code\\CS.Service.Fundamental\\SharedSegments\\SharedSegments\\SharedSegments.Plugins\\Workflows\\LocationDetection\\AudienceResponseParser.cs";
 // const csFilePath = "D:\\code\\msnews-experiences\\experiences\\weather-right-rail\\src\\WeatherRightRail.connector.ts";