/test [action] [target]

/test generate src/utils.ts
/test coverage
/test run src/auth.test.ts
/test suggest src/api/users.ts

/test generate src/calculator.ts

## Coverage Report

| File | Lines | Functions | Branches |
|------|-------|-----------|----------|
| src/auth.ts | 85% | 90% | 75% |
| src/utils.ts | 95% | 100% | 90% |
| **Total** | **88%** | **92%** | **80%** |

### Uncovered Lines
- src/auth.ts:45-52 (error handling)
- src/api.ts:120-125 (edge case)

# Detect framework and run
npm test
pytest
dotnet test

## Suggested Test Cases for `src/auth.ts`

### `login(email, password)`
- [ ] Valid credentials → returns token
- [ ] Invalid email → throws AuthError
- [ ] Invalid password → throws AuthError
- [ ] Empty email → throws ValidationError
- [ ] Empty password → throws ValidationError
- [ ] Locked account → throws AccountLocked
- [ ] Rate limited → throws RateLimitError

### `logout(token)`
- [ ] Valid token → returns true
- [ ] Invalid token → throws InvalidToken
- [ ] Expired token → throws TokenExpired

import { functionName } from './module';

describe('functionName', () => {
  describe('happy path', () => {
    it('should return expected result', () => {
      expect(functionName(input)).toBe(expected);
    });
  });

  describe('edge cases', () => {
    it('should handle empty input', () => {
      expect(functionName('')).toBe(default);
    });

    it('should handle null', () => {
      expect(functionName(null)).toBeNull();
    });
  });

  describe('error cases', () => {
    it('should throw on invalid input', () => {
      expect(() => functionName(invalid)).toThrow(Error);
    });
  });
});

import pytest
from module import function_name

class TestFunctionName:
    """Tests for function_name."""

    def test_happy_path(self):
        """Should return expected result."""
        assert function_name(input) == expected

    def test_empty_input(self):
        """Should handle empty input."""
        assert function_name('') == default

    def test_invalid_input(self):
        """Should raise on invalid input."""
        with pytest.raises(ValueError):
            function_name(invalid)

    @pytest.mark.parametrize('input,expected', [
        ('a', 1),
        ('b', 2),
        ('c', 3),
    ])
    def test_multiple_cases(self, input, expected):
        """Should handle multiple cases."""
        assert function_name(input) == expected

public class FunctionNameTests
{
    [Fact]
    public void Should_ReturnExpected_WhenValidInput()
    {
        // Arrange
        var sut = new MyClass();

        // Act
        var result = sut.FunctionName(input);

        // Assert
        Assert.Equal(expected, result);
    }

    [Theory]
    [InlineData("a", 1)]
    [InlineData("b", 2)]
    public void Should_Handle_MultipleCases(string input, int expected)
    {
        var sut = new MyClass();
        Assert.Equal(expected, sut.FunctionName(input));
    }

    [Fact]
    public void Should_Throw_WhenInvalidInput()
    {
        var sut = new MyClass();
        Assert.Throws<ArgumentException>(() => sut.FunctionName(invalid));
    }
}

Grep: "jest|vitest|mocha" package.json
Grep: "pytest|unittest" requirements.txt
Grep: "xunit|nunit" *.csproj