codeplay/CodePlay.Tests/Converters/JavaToCSharpConverterTests.cs

using CodePlay.Core.Converters;
using CodePlay.Core.Models;
using CodePlay.Core.Common;
using CodePlay.Core.Parsers;
using Xunit;

namespace CodePlay.Tests.Converters;

public class JavaToCSharpConverterTests
{
    private readonly JavaToCSharpConverter _converter;
    private readonly JavaParser _parser;
    
    public JavaToCSharpConverterTests()
    {
        _converter = new JavaToCSharpConverter();
        _parser = new JavaParser();
    }
    
    #region 基础转换测试
    
    [Fact]
    public async Task ConvertAsync_SimpleClass_ShouldConvertSuccessfully()
    {
        var sourceCode = @"
package com.test;
public class Person {
    private String name;
}";
        
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.NotNull(result);
        Assert.True(result.Success);
        Assert.NotNull(result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_EmptyClass_ShouldConvertSuccessfully()
    {
        var sourceCode = "package test; public class Empty { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.NotNull(result.TransformedCode);
        Assert.Contains("namespace test", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_PublicClass_ShouldPreserveVisibility()
    {
        var sourceCode = "public class PublicTest { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("public class", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_WrongTargetLanguage_ShouldFail()
    {
        var sourceCode = "public class Test { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.NotNull(result);
        Assert.False(result.Success);
        Assert.NotNull(result.ErrorMessage);
    }
    
    #endregion
    
    #region 包和命名空间测试
    
    [Fact]
    public async Task ConvertAsync_Package_ShouldConvertToNamespace()
    {
        var sourceCode = "package com.example.test; public class MyClass { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("namespace com.example.test", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_Import_ShouldConvertToUsing()
    {
        var sourceCode = "import java.util.List; public class MyClass { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("using", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_MultipleImports_ShouldConvertAll()
    {
        var sourceCode = @"
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
public class MyClass { }";
        
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
    }
    
    #endregion
    
    #region 类型映射测试
    
    [Fact]
    public async Task ConvertAsync_JavaString_ShouldMapToCSharpString()
    {
        var sourceCode = "public class Test { private String name; }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.NotNull(result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_PrimitiveTypes_ShouldMapToCSharpPrimitives()
    {
        var sourceCode = "public class Test { private int count; private boolean active; }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
    }
    
    [Fact]
    public async Task ConvertAsync_CollectionTypes_ShouldMapToCSharp()
    {
        var sourceCode = "import java.util.*; public class Test { private ArrayList<String> items; }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("List<string>", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_MapTypes_ShouldConvertToDictionary()
    {
        var sourceCode = "import java.util.HashMap; public class Test { private HashMap<String, Integer> map; }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("Dictionary", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_DateTimeTypes_ShouldMapToCSharp()
    {
        var sourceCode = "import java.time.LocalDateTime; public class Test { private LocalDateTime date; }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("DateTime", result.TransformedCode);
    }
    
    #endregion
    
    #region 继承和接口测试
    
    [Fact]
    public async Task ConvertAsync_Extends_ShouldConvertToColon()
    {
        var sourceCode = "public class Derived extends Base { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains(": Base", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_Implements_ShouldConvertToComma()
    {
        var sourceCode = "public class Service implements Runnable { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("Runnable", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_ExtendsAndImplements_ShouldHandleBoth()
    {
        var sourceCode = "public class Service extends Base implements Runnable { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
    }
    
    #endregion
    
    #region 异常和 throws 测试
    
    [Fact]
    public async Task ConvertAsync_ThrowsDeclaration_ShouldBeRemoved()
    {
        var sourceCode = "public void method() throws Exception;";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.DoesNotContain("throws", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_MultipleThrows_ShouldBeRemoved()
    {
        var sourceCode = "public void method() throws IOException, Exception;";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.DoesNotContain("throws", result.TransformedCode);
    }
    
    #endregion
    
    #region 注解测试
    
    [Fact]
    public async Task ConvertAsync_Annotations_ShouldBeRemoved()
    {
        var sourceCode = "@Override public String toString();";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.DoesNotContain("@Override", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_DeprecatedAnnotation_ShouldBeRemoved()
    {
        var sourceCode = "@Deprecated public void oldMethod();";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.DoesNotContain("@Deprecated", result.TransformedCode);
    }
    
    #endregion
    
    #region final 修饰符测试
    
    [Fact]
    public async Task ConvertAsync_FinalClass_ShouldPreserveFinal()
    {
        var sourceCode = "public final class Test { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("final", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_FinalField_ShouldPreserveFinal()
    {
        var sourceCode = "public class Test { private final String name; }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("final", result.TransformedCode);
    }
    
    #endregion
    
    #region 字段和方法测试
    
    [Fact]
    public async Task ConvertAsync_Fields_ShouldConvertTypes()
    {
        var sourceCode = "public class Test { private String name; private int age; }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
    }
    
    [Fact]
    public async Task ConvertAsync_Methods_ShouldConvertSignatures()
    {
        var sourceCode = "public class Test { public String getName() { return null; } }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
    }
    
    [Fact]
    public async Task ConvertAsync_StaticMethod_ShouldPreserveStatic()
    {
        var sourceCode = "public class Test { public static void main(String[] args) { } }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.NotNull(result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_AbstractMethod_ShouldPreserveAbstract()
    {
        var sourceCode = "public abstract class Test { public abstract void doSomething(); }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.Contains("abstract", result.TransformedCode);
    }
    
    #endregion
    
    #region 综合测试
    
    [Fact]
    public async Task ConvertAsync_ComplexClass_ShouldConvertAllFeatures()
    {
        var sourceCode = @"
package com.example.service;
import java.util.ArrayList;
import java.util.List;
public class UserService extends BaseService implements IUserService {
    private ArrayList<String> users;
    public void addUser(String name) { users.add(name); }
}";
        
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
        Assert.NotNull(result.TransformedCode);
        Assert.Contains("namespace com.example.service", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_GenericClass_ShouldConvertGenerics()
    {
        var sourceCode = "public class Container<T> { private T value; }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
    }
    
    [Fact]
    public async Task ConvertAsync_Interface_ShouldConvertInterface()
    {
        var sourceCode = "public interface Service { void execute(); }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
    }
    
    [Fact]
    public async Task ConvertAsync_Enum_ShouldConvertEnum()
    {
        var sourceCode = "public enum Status { ACTIVE, INACTIVE }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.True(result.Success);
    }
    
    #endregion
}