diff --git a/.github/workflows/brazilian-to-european-portuguese.yml b/.github/workflows/brazilian-to-european-portuguese.yml new file mode 100644 index 00000000..0d4bc556 --- /dev/null +++ b/.github/workflows/brazilian-to-european-portuguese.yml @@ -0,0 +1,196 @@ +name: Build BrazilianToEuropeanPortuguese (SE5) + +on: + push: + branches: [main] + paths: + - 'se5/BrazilianToEuropeanPortuguese/**' + - 'se5/BrazilianToEuropeanPortuguese.Tests/**' + - 'se5/Plugin-Shared/**' + - '.github/workflows/brazilian-to-european-portuguese.yml' + pull_request: + paths: + - 'se5/BrazilianToEuropeanPortuguese/**' + - 'se5/BrazilianToEuropeanPortuguese.Tests/**' + - 'se5/Plugin-Shared/**' + - '.github/workflows/brazilian-to-european-portuguese.yml' + workflow_dispatch: + inputs: + release: + description: 'Publish a GitHub release. Bumps the minor in plugin.json and commits it back.' + type: boolean + default: false + version: + description: 'Optional explicit version (e.g. 1.2.0). Overrides the auto-minor-bump.' + required: false + type: string + +permissions: + contents: write + +jobs: + prepare: + runs-on: ubuntu-latest + outputs: + version: ${{ steps.set.outputs.version }} + tag: ${{ steps.set.outputs.tag }} + ref: ${{ steps.set.outputs.ref }} + release: ${{ steps.set.outputs.release }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Resolve version (and bump on release) + id: set + run: | + set -e + current=$(jq -r .version se5/BrazilianToEuropeanPortuguese/plugin.json) + release_flag="false" + ref="${{ github.sha }}" + version="$current" + tag="" + + if [ "${{ github.event_name }}" = "workflow_dispatch" ] && [ "${{ inputs.release }}" = "true" ]; then + release_flag="true" + if [ -n "${{ inputs.version }}" ]; then + version="${{ inputs.version }}" + else + IFS=. read -r major minor patch <<< "$current" + version="$major.$((minor + 1)).0" + fi + + tmp=$(mktemp) + jq --arg v "$version" '.version = $v' se5/BrazilianToEuropeanPortuguese/plugin.json > "$tmp" + mv "$tmp" se5/BrazilianToEuropeanPortuguese/plugin.json + + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + git add se5/BrazilianToEuropeanPortuguese/plugin.json + git commit -m "Bump BrazilianToEuropeanPortuguese to $version [skip ci]" + + # Retry-with-rebase: if a concurrent release dispatched for a different + # plugin won the push first, pull --rebase and try again. + attempts=0 + while ! git push 2>/tmp/push.err; do + attempts=$((attempts + 1)) + if [ "$attempts" -ge 5 ]; then + echo "Failed to push after $attempts attempts:" >&2 + cat /tmp/push.err >&2 + exit 1 + fi + echo "Push rejected (attempt $attempts), pulling --rebase and retrying..." + git pull --rebase --no-edit + done + ref=$(git rev-parse HEAD) + + IFS=. read -r major minor patch <<< "$version" + tag="se5-brazilian-to-european-portuguese-v$major.$minor" + fi + + echo "version=$version" >> "$GITHUB_OUTPUT" + echo "tag=$tag" >> "$GITHUB_OUTPUT" + echo "ref=$ref" >> "$GITHUB_OUTPUT" + echo "release=$release_flag" >> "$GITHUB_OUTPUT" + + test: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup .NET 8 + uses: actions/setup-dotnet@v4 + with: + dotnet-version: '8.0.x' + + - name: Test + run: dotnet test se5/BrazilianToEuropeanPortuguese.Tests/BrazilianToEuropeanPortuguese.Tests.csproj -c Release + + build: + needs: [prepare, test] + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + include: + - rid: win-x64 + os: windows + exe: BrazilianToEuropeanPortuguese.exe + - rid: win-arm64 + os: windows + exe: BrazilianToEuropeanPortuguese.exe + - rid: linux-x64 + os: linux + exe: BrazilianToEuropeanPortuguese + - rid: linux-arm64 + os: linux + exe: BrazilianToEuropeanPortuguese + - rid: osx-x64 + os: macos + exe: BrazilianToEuropeanPortuguese + - rid: osx-arm64 + os: macos + exe: BrazilianToEuropeanPortuguese + + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + ref: ${{ needs.prepare.outputs.ref }} + + - name: Setup .NET 8 + uses: actions/setup-dotnet@v4 + with: + dotnet-version: '8.0.x' + + - name: Publish self-contained (${{ matrix.rid }}) + working-directory: se5/BrazilianToEuropeanPortuguese + run: | + dotnet publish BrazilianToEuropeanPortuguese.csproj \ + -c Release \ + -r ${{ matrix.rid }} \ + --self-contained true \ + -p:DebugType=None \ + -p:DebugSymbols=false \ + -o staging/BrazilianToEuropeanPortuguese + + - name: Rewrite plugin.json for ${{ matrix.os }} + working-directory: se5/BrazilianToEuropeanPortuguese + run: | + jq ' + del(.runtime, .entry) | + .executables = { "${{ matrix.os }}": "${{ matrix.exe }}" } + ' plugin.json > staging/BrazilianToEuropeanPortuguese/plugin.json + + - name: Package zip + working-directory: se5/BrazilianToEuropeanPortuguese/staging + run: zip -r "$GITHUB_WORKSPACE/BrazilianToEuropeanPortuguese-${{ matrix.rid }}.zip" BrazilianToEuropeanPortuguese + + - name: Upload artifact + uses: actions/upload-artifact@v4 + with: + name: BrazilianToEuropeanPortuguese-${{ matrix.rid }} + path: BrazilianToEuropeanPortuguese-${{ matrix.rid }}.zip + + release: + name: Publish GitHub Release + needs: [prepare, build] + if: needs.prepare.outputs.release == 'true' + runs-on: ubuntu-latest + steps: + - name: Download all zips + uses: actions/download-artifact@v4 + with: + path: dist + pattern: BrazilianToEuropeanPortuguese-* + merge-multiple: true + + - name: Create release and upload zips + env: + GH_TOKEN: ${{ github.token }} + run: | + gh release create "${{ needs.prepare.outputs.tag }}" dist/BrazilianToEuropeanPortuguese-*.zip \ + --repo "${{ github.repository }}" \ + --target "${{ needs.prepare.outputs.ref }}" \ + --title "BrazilianToEuropeanPortuguese v${{ needs.prepare.outputs.version }}" \ + --notes "Self-contained BrazilianToEuropeanPortuguese plugin builds for win/linux/osx (x64 + arm64)." diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/AutomaticGrammarTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/AutomaticGrammarTests.cs new file mode 100644 index 00000000..b796c091 --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/AutomaticGrammarTests.cs @@ -0,0 +1,105 @@ +using System.Text.Json; +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; +using SubtitleEdit.Plugins.Shared; + +namespace BrazilianToEuropeanPortuguese.Tests; + +public sealed class AutomaticGrammarTests +{ + private static readonly PortugueseConverter Converter = new(); + + [Theory] + [InlineData("Já é o segunda de estupro\nque temos no campus hoje.", "Já é a segunda violação\nque temos no campus hoje.")] + [InlineData("Já é o segunda de violação.", "Já é a segunda violação.")] + [InlineData("Foi a terceiro de agressão.", "Foi a terceira agressão.")] + [InlineData("É a segunda crime.", "É o segundo crime.")] + [InlineData("São os primeiras de violações.", "São as primeiras violações.")] + [InlineData("Este é a quinto de homicídio.", "Este é o quinto homicídio.")] + [InlineData("É uma segundo tentativa.", "É uma segunda tentativa.")] + [InlineData("Foi a primeira visita.", "Foi a primeira visita.")] + [InlineData("JA É O SEGUNDA DE VIOLAÇÃO.", "JA É A SEGUNDA VIOLAÇÃO.")] + public void OrdinalEventAgreementAndStrayDe(string source, string expected) => Converts(source, expected); + + [Theory] + [InlineData("Nós está prontos.", "Nós estamos prontos.")] + [InlineData("Eles não pode sair.", "Eles não podem sair.")] + [InlineData("Elas sempre trabalha aqui.", "Elas trabalham sempre aqui.")] + [InlineData("Nós chegou cedo.", "Nós chegámos cedo.")] + [InlineData("Eles já aprendeu isso.", "Eles já aprenderam isso.")] + [InlineData("Nós falaria com ela.", "Nós falaríamos com ela.")] + [InlineData("Eles beberá água.", "Eles beberão água.")] + [InlineData("Gosto o filme.", "Gosto do filme.")] + [InlineData("Preciso uma equipa.", "Preciso de uma equipa.")] + [InlineData("Gosto um pouco.", "Gosto um pouco.")] + public void ReviewedGrammarWarningsBecomeCorrections(string source, string expected) + { + Converts(source, expected); + Assert.Null(GrammarReview.Note(expected)); + } + + [Theory] + [InlineData("Temos o retrato falado.", "Temos o retrato-robô.")] + [InlineData("São retratos falados.", "São retratos-robô.")] + [InlineData("Trabalho de meio período?", "Trabalho a tempo parcial?")] + [InlineData("Um emprego de tempo integral.", "Um emprego a tempo inteiro.")] + [InlineData("Obrigado, é tudo por hora.", "Obrigado, é tudo por agora.")] + [InlineData("O comissário está a frente.", "O comissário está à frente.")] + [InlineData("Estava na frente da casa.", "Estava à frente da casa.")] + [InlineData("Qualquer coisa que venha a mente.", "Qualquer coisa que venha à mente.")] + [InlineData("É difícil dizer que foi pelo o que aconteceu.", "É difícil dizer que foi pelo que aconteceu.")] + [InlineData("Tenho um ideia melhor.", "Tenho uma ideia melhor.")] + [InlineData("Faz todo sentido.", "Faz todo o sentido.")] + [InlineData("Dei a ela todo dinheiro.", "Dei a ela todo o dinheiro.")] + public void RepeatedMissedEpisodeFamiliesBecomeSelectableChanges(string source, string expected) => Converts(source, expected); + + [Theory] + [InlineData("É o segunda de manhã.")] + [InlineData("É a segunda de várias visitas.")] + [InlineData("É a segunda da lista.")] + [InlineData("Na segunda de manhã.")] + [InlineData("Ele refere-se a crimes.")] + [InlineData("Vou à reunião.")] + [InlineData("A polícia chegou.")] + [InlineData("Eles podem sair.")] + [InlineData("Nós trabalhamos aqui.")] + [InlineData("Nós, que chegámos cedo, estamos prontos.")] + [InlineData("Nós: está pronto.")] + [InlineData("Tenho fazer isso.")] + [InlineData("Cobra dez euros por hora.")] + [InlineData("É um pagamento por hora.")] + [InlineData("Ele perdeu meio período.")] + [InlineData("Todo homem sabe.")] + [InlineData("Toda mulher sabe.")] + [InlineData("Todos nós sabemos.")] + public void AmbiguousConstructionsAreNotGuessed(string source) => Assert.Equal(source, Converter.Convert(source)); + + [Fact] + public void SettingsDefaultToNoLayoutNoiseAndCanOptIn() + { + var text = "Esta linha comprida não é um problema de tradução."; + var cue = new SrtBlock { Text = text, StartMs = 0, EndMs = 1000 }; + Assert.Null(SubtitleLayout.Review(text, cue, ConversionOptions.Default)); + var options = new ConversionOptions(LayoutWarnings: true); + Assert.Contains("characters/second", SubtitleLayout.Review(text, cue, options)); + Assert.Equal(options, ConversionOptions.Load(new PluginRequest + { SettingsVersion = ConversionOptions.Version, Settings = options.ToJson() })); + Assert.Throws(() => ConversionOptions.Load(new PluginRequest + { SettingsVersion = ConversionOptions.Version, Settings = JsonSerializer.SerializeToElement(new { layoutWarnings = "yes" }) })); + Assert.NotNull(GrammarReview.Note("Tenho fazer isso.")); + } + + [Fact] + public void FixesRespectStageAndGroupSuppressionAndKeepMarkup() + { + var source = "Já é o segunda de violação."; + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(DisabledRules: "final-grammar")).Convert(source)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + Converts("Já é o segunda de estupro.", "Já é a segunda violação."); + } + + private static void Converts(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + } +} diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/BatchModeTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/BatchModeTests.cs new file mode 100644 index 00000000..a0a6cc0d --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/BatchModeTests.cs @@ -0,0 +1,428 @@ +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; +using SubtitleEdit.Plugins.Shared; +using System.Text.Json; + +namespace BrazilianToEuropeanPortuguese.Tests; + +/// Subtitle Edit Batch convert: "batch" converts every line headless, "configure" returns the settings. +public sealed class BatchModeTests : IDisposable +{ + private readonly string _folder = Path.Combine(Path.GetTempPath(), "BrazilianToEuropeanPortugueseTests-" + Guid.NewGuid().ToString("N")); + + public BatchModeTests() => Directory.CreateDirectory(_folder); + + public void Dispose() => Directory.Delete(_folder, true); + + private string WordListPath => Path.Combine(_folder, PortugueseLocalWordList.FileName); + + private static PluginRequest Request(params string[] texts) + { + var blocks = texts.Select((t, i) => new SrtBlock { StartMs = i * 1000, EndMs = i * 1000 + 900, Text = t }).ToList(); + return new PluginRequest + { + RequestType = PluginRequestType.Batch, + Subtitle = new PluginSubtitle { Format = "SubRip", SubRip = SubRipParser.Serialize(blocks) }, + }; + } + + private static List Texts(PluginResponse response) => + SubRipParser.Parse(response.Subtitle!.Native).Select(b => b.Text).ToList(); + + [Fact] + public void Batch_EnglishSportswearPreservesCueTimingAndReferenceSwitch() + { + var request = EpisodeRequest("Tira a fantasia.", true, "Ditch the leotard."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Tira o maillot." }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + request.SettingsVersion = ConversionOptions.Version; + request.Settings = new ConversionOptions(UseReference: false).ToJson(); + response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Null(response.Subtitle); + Assert.Contains("nothing to convert", response.Message); + } + + [Fact] + public void Batch_SharedResidenceUsesEnglishWithoutModels() + { + var request = EpisodeRequest("Você é meu vizinho de andar.", true, "Hey, we live on the same floor."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Vivemos no mesmo andar." }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + request.SettingsVersion = ConversionOptions.Version; + request.Settings = new ConversionOptions(UseReference: false).ToJson(); + response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "És meu vizinho de andar." }, Texts(response)); + } + + [Fact] + public void Batch_PhysicalDescriptionsPreserveMeasurementsAndCueTimings() + { + var request = Request("Suspeito de cerca de 1,80m, porte médio.", "Uma mulher de 60 kg.", + "Um muro de cerca de dois metros.", "Um suspeito de cerca de 30 anos."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Suspeito com cerca de 1,80m, porte médio.", "Uma mulher com 60 kg.", + "Um muro de cerca de dois metros.", "Um suspeito de cerca de 30 anos." }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + } + + [Fact] + public void Batch_VocabularyVerbWorkbookPreservesCuesAndQualifiedSenses() + { + var request = Request("Uma furadeira nova.", "As sacolas vazias.", "Ele rosqueou a tampa.", + "Ela subiu um arquivo.", "Ele engraxou os sapatos.", "Eu digitei o código."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Um berbequim novo.", "Os sacos vazios.", "Ele enroscou a tampa.", + "Ela carregou um ficheiro.", "Ele engraxou os sapatos.", "Eu introduzi o código." }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + } + + [Fact] + public void Batch_ExtractedQuestionsPreserveSubjectAndDistinguishObjects() + { + var request = EpisodeRequest("Ned, quem você acha que vê isso?", true, + "Ned, who do you think is actually watching this?"); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Ned, quem achas que vê isto?" }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + request = EpisodeRequest("Quem você acha que viu?", true, "Who do you think you saw?"); + response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Quem achas que viste?" }, Texts(response)); + } + + [Fact] + public void Batch_HabitualWordOrderAndProgressiveSubjectKeepCueTimings() + { + var request = EpisodeRequest("porque você sempre sabe\nquando eu tô mentindo.", true, + "Because you always know when I'm lying."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "porque sabes sempre\nquando estou a mentir." }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + } + + [Fact] + public void Batch_EnglishSlangResolvesPortugueseOnlyWithReference() + { + var request = EpisodeRequest("Estou quebrada.", true, "I'm skint."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Estou sem dinheiro." }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + request.Settings = (ConversionOptions.Default with { UseReference = false }).ToJson(); + request.SettingsVersion = ConversionOptions.Version; + response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Null(response.Subtitle); + Assert.Contains("nothing to convert.", response.Message); + } + + [Fact] + public void Batch_NewEnglishIdiomsProduceReviewHintsWithoutModels() + { + var request = EpisodeRequest("Ele estava no seu Tod.", true, "He was on his tod."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Contains("1 line(s) with an English idiom", response.Message); + Assert.Null(response.Subtitle); + } + + [Fact] + public void Batch_AdditionalWorkbookRulesPreserveCueTimings() + { + var request = Request("Recebi o holerite.", "Baixei um arquivo.", "Dei uma força.", + "Ela puxou\nassunto.", "Elas ficaram de saco cheio.", "Foi um escanteio.", "Contou uma parada cardíaca."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Recebi o recibo de vencimento.", "Descarreguei um ficheiro.", "Dei uma ajuda.", + "Ela meteu\nconversa.", "Elas ficaram fartas.", "Foi um canto.", "Contou uma paragem cardíaca." }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + } + + [Fact] + public void Batch_AdditionalWorkbookHelpOutNeedsEnglishConfirmation() + { + var request = EpisodeRequest("Ele quebrou um galho.", true, "He did me a favor."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Ele desenrascou." }, Texts(response)); + request.Settings = (ConversionOptions.Default with { UseReference = false }).ToJson(); + request.SettingsVersion = ConversionOptions.Version; + response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Ele partiu um galho." }, Texts(response)); + } + + [Fact] + public void Batch_VerifiedSpreadsheetExpressionsPreserveCueTimings() + { + var request = Request("Vou pegar um busão.", "Paguei mico.", "Dei um rolê.", "Tomei uma breja.", + "A meia-calça está rasgada.", "A mensalidade da faculdade."); + var response = BatchMode.BuildBatchResponse(request, WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Vou apanhar um autocarro.", "Passei vergonha.", "Dei uma volta.", "Bebi uma cerveja.", + "Os collants estão rasgados.", "A propina." }, Texts(response)); + Assert.Equal(SubRipParser.Parse(request.Subtitle.SubRip).Select(b => (b.StartMs, b.EndMs)), + SubRipParser.Parse(response.Subtitle!.Native).Select(b => (b.StartMs, b.EndMs))); + } + + [Fact] + public void Batch_VerifiedSpreadsheetSlangUsesEnglishConfirmation() + { + var response = BatchMode.BuildBatchResponse(EpisodeRequest("Ele é pão-duro.", true, "He's a cheapskate."), + WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Ele é forreta." }, Texts(response)); + } + + [Fact] + public void Batch_InclusiveContinuationUsesOriginalPreviousCue() + { + var response = BatchMode.BuildBatchResponse(Request("A gente sempre escuta,", "mas nunca acha que vai acontecer contigo."), + WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Escutamos sempre,", "mas nunca achamos que vá acontecer connosco." }, Texts(response)); + } + + [Fact] + public void Batch_FormalDialogueContextUsesEarlierAndLaterAddress() + { + var response = BatchMode.BuildBatchResponse(Request("Sr. diretor, um momento.", "Não sei.", "Certo, veja...", "Não fale comigo.", "O estoque acabou."), + WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Sr. diretor, um momento.", "Não sei.", "Certo, veja...", "Não fale comigo.", "O stock acabou." }, Texts(response)); + response = BatchMode.BuildBatchResponse(Request("Certo, veja...", "Não sei.", "Não concordo, detetive.", "O estoque acabou."), + WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Contains("Certo, veja...", Texts(response)); + } + + [Fact] + public void Batch_FormalAddressInDashedReplyKeepsCommandFormal() + { + var response = BatchMode.BuildBatchResponse( + Request("Aparentemente não.", "Certo, veja...", "Uma mulher foi espancada\ne violentada.", "E Sebastian dá com os ombros,", + "- e isso é \"aparentemente não\"?\n- Não gosto de seu tom, detetive."), + WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal("Certo, veja...", Texts(response)[1]); + } + + [Fact] + public void Batch_FormalAddressInLaterDashedCueKeepsCommandFormal() + { + var response = BatchMode.BuildBatchResponse( + Request("Bem, olhe um veículo parecido,", "em marca e modelo,\ncom uma placa semelhante", "envolveu-se numa série de\nestupros ontem à noite.", + "- Não seja ridículo.\n- Alguém mais teria", "- acesso ao veículo, madame?\n- Já chega disto."), + WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal("Bem, olhe um veículo parecido,", Texts(response)[0]); + } + + private PluginRequest EpisodeRequest(string text, bool withEnglish, string english = "So we got prints and his picture now.") + { + var request = Request(text); + request.Subtitle.FileName = Path.Combine(_folder, "Show.S01E01.720p.pt-br.srt"); + File.WriteAllText(request.Subtitle.FileName, request.Subtitle.SubRip); + if (withEnglish) + File.WriteAllText(Path.Combine(_folder, "Show.S01E01.720p.en.srt"), $"1\n00:00:00,000 --> 00:00:00,900\n{english}\n"); + return request; + } + + [Fact] + public void Batch_UsesTheEnglishSubtitleNextToTheFile() + { + var response = BatchMode.BuildBatchResponse(EpisodeRequest("Já temos digitais e sua foto.", true), WordListPath, new EmbeddingSettings()); + Assert.Equal(new[] { "Já temos impressões digitais e a sua foto." }, Texts(response)); + Assert.Contains("English reference Show.S01E01.720p.en.srt: Reference matched 1 of 1", response.Message); + } + + [Fact] + public void Batch_CausalQuestionUsesAlignedSubjectAndNegativeObject() + { + var response = BatchMode.BuildBatchResponse(EpisodeRequest("Por isso que nunca visitou nenhuma ilha?", true, + "Is that why you never visited any islands?"), WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Por isso é que nunca visitaste uma ilha?" }, Texts(response)); + } + + [Fact] + public void Batch_HearingStatementUsesEnglishMeaningAndPluralOrder() + { + var response = BatchMode.BuildBatchResponse(EpisodeRequest("A gente sempre escuta,", true, + "You just hear about this stuff."), WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Ouvimos sempre," }, Texts(response)); + response = BatchMode.BuildBatchResponse(Request("Vamos pegar este cara."), WordListPath, new EmbeddingSettings(CheckMeaning: false)); + Assert.Equal(new[] { "Vamos apanhar este tipo." }, Texts(response)); + } + + [Fact] + public void Batch_CountsLinesToReview() + { + var response = BatchMode.BuildBatchResponse(EpisodeRequest("Precisamos falar com seu marido. Ele está em casa?", true, + "We need to talk to your husband. Is he home?"), WordListPath, new EmbeddingSettings()); + Assert.Equal(new[] { "Precisamos de falar com o seu marido. Ele está em casa?" }, Texts(response)); + Assert.Contains("1 line(s) to review", response.Message); + } + + [Fact] + public void Batch_ReferenceCanBeSwitchedOffAndIsOptional() + { + var off = EpisodeRequest("Já temos digitais e sua foto.", true); + off.Settings = (ConversionOptions.Default with { UseReference = false }).ToJson(); + off.SettingsVersion = ConversionOptions.Version; + var response = BatchMode.BuildBatchResponse(off, WordListPath, new EmbeddingSettings()); + Assert.Equal(new[] { "Já temos impressões digitais e a tua foto." }, Texts(response)); + Assert.DoesNotContain("English reference", response.Message); + + File.Delete(Path.Combine(_folder, "Show.S01E01.720p.en.srt")); + response = BatchMode.BuildBatchResponse(EpisodeRequest("Já temos digitais e sua foto.", false), WordListPath, new EmbeddingSettings()); + Assert.Equal(new[] { "Já temos impressões digitais e a tua foto." }, Texts(response)); + Assert.DoesNotContain("English reference", response.Message); + } + + [Fact] + public void Configure_RemembersTheReferenceOption() + { + var json = (ConversionOptions.Default with { UseReference = false }).ToJson(); + var request = new PluginRequest { Settings = json, SettingsVersion = ConversionOptions.Version }; + Assert.False(ConversionOptions.Load(request).UseReference); + Assert.True(ConversionOptions.Load(new PluginRequest()).UseReference); + } + + [OptInFact("PTPT_TEST_VULKAN", "real MiniLM on a Vulkan GPU in Batch convert")] + public void Batch_RealEpisodeWithMiniLmOnVulkan() + { + // PTPT_SOURCE_SRT: a real PT-BR subtitle (its English .srt next to it is not needed here). + var source = Environment.GetEnvironmentVariable("PTPT_SOURCE_SRT") + ?? throw new InvalidOperationException("Set PTPT_SOURCE_SRT to a PT-BR .srt file."); + var folder = Environment.GetEnvironmentVariable("PTPT_EMBEDDING_DIR") ?? EmbeddingAssets.DirectoryPath; + var settings = new EmbeddingSettings(Directory.GetFiles(folder, "llama-server", SearchOption.AllDirectories).First(), + Path.Combine(folder, EmbeddingAssets.ModelFile), true, true, Environment.GetEnvironmentVariable("PTPT_VULKAN_DEVICE") ?? "Vulkan0"); + var request = new PluginRequest + { + RequestType = PluginRequestType.Batch, + Subtitle = new PluginSubtitle { Format = "SubRip", FileName = source, SubRip = ReferenceAligner.Decode(File.ReadAllBytes(source)) }, + }; + var response = BatchMode.BuildBatchResponse(request, WordListPath, settings); + Assert.Equal(PluginStatus.Ok, response.Status); + Assert.Contains("MiniLM ran on Vulkan", response.Message); + Assert.Contains("line(s) to review", response.Message); + Assert.Contains(Texts(response), t => t.Contains("o seu rapaz")); + } + + [Fact] + public void Batch_UsesOriginalPreviousCueForPossessives() + { + var response = BatchMode.BuildBatchResponse(Request( + "E me divorciando do cretino.", + "- Já até mandei suas coisas.\n- Para onde?", + "Precisamos falar com\nseu marido. Ele está em casa?"), WordListPath); + Assert.Equal(PluginStatus.Ok, response.Status); + Assert.Equal(new[] + { + "E a divorciar-me do cretino.", + "- Até, já lhe mandei as suas coisas.\n- Para onde?", + "Precisamos de falar com\no seu marido. Ele está em casa?", + }, Texts(response)); + } + + [Fact] + public void Batch_ConvertsAllLines() + { + var response = BatchMode.BuildBatchResponse(Request("O trem chegou.", "Bom dia.", "Estou fazendo o jantar."), WordListPath); + + Assert.Equal(PluginStatus.Ok, response.Status); + Assert.Equal(new[] { "O comboio chegou.", "Bom dia.", "Estou a fazer o jantar." }, Texts(response)); + Assert.Equal(ConversionOptions.Version, response.SettingsVersion); + } + + [Fact] + public void Batch_KeepsTimingsAndMultiLineText() + { + var response = BatchMode.BuildBatchResponse(Request("Bom dia.", "- Oi!\n- Tá bom."), WordListPath); + + var blocks = SubRipParser.Parse(response.Subtitle!.Native); + Assert.Equal(new long[] { 0, 1000 }, blocks.Select(b => b.StartMs)); + Assert.Equal(new long[] { 900, 1900 }, blocks.Select(b => b.EndMs)); + Assert.Equal("- Olá!\n- Está bem.", blocks[1].Text); + } + + [Fact] + public void Batch_NothingToConvert_ReturnsOkWithoutSubtitle() + { + var response = BatchMode.BuildBatchResponse(Request("Bom dia.", "Estou a ver."), WordListPath); + + Assert.Equal(PluginStatus.Ok, response.Status); + Assert.Null(response.Subtitle); + } + + [Fact] + public void Batch_UsesSavedSettings() + { + var request = Request("Estou fazendo um fato no trem."); + request.Settings = new ConversionOptions(Vocabulary: false, Progressive: false).ToJson(); + request.SettingsVersion = ConversionOptions.Version; + + var response = BatchMode.BuildBatchResponse(request, WordListPath); + + Assert.Equal(new[] { "Estou fazendo um facto no trem." }, Texts(response)); + Assert.False(response.Settings!.Value.GetProperty("vocabulary").GetBoolean()); + } + + [Fact] + public void Settings_WrongVersionFallsBackToDefaults() + { + var request = new PluginRequest + { + Settings = JsonSerializer.SerializeToElement(new { spelling = false }), + SettingsVersion = 99, + }; + + Assert.Equal(ConversionOptions.Default, ConversionOptions.Load(request)); + } + + [Fact] + public void Configure_ReturnsSettings() + { + var response = BatchMode.BuildConfigureResponse(new ConversionOptions(YouToTu: false)); + + Assert.Equal(PluginStatus.Ok, response.Status); + Assert.Equal(ConversionOptions.Version, response.SettingsVersion); + var request = new PluginRequest { Settings = response.Settings, SettingsVersion = response.SettingsVersion }; + Assert.Equal(new ConversionOptions(YouToTu: false), ConversionOptions.Load(request)); + } + + [Fact] + public void Batch_UsesLocalWordList() + { + File.WriteAllText(WordListPath, """ + + + + + + """); + + var response = BatchMode.BuildBatchResponse(Request("Vamos à balada de trem."), WordListPath); + + Assert.Equal(new[] { "Vamos à discoteca de trem." }, Texts(response)); + } + + [Fact] + public void Batch_UnreadableLocalWordList_IsError() + { + File.WriteAllText(WordListPath, " + + + net8.0 + enable + enable + false + + Major + + + + + + + + + + + + + + + + + diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ClothingTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ClothingTests.cs new file mode 100644 index 00000000..b9d32b3d --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/ClothingTests.cs @@ -0,0 +1,176 @@ +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; + +namespace BrazilianToEuropeanPortuguese.Tests; + +public sealed class ClothingTests +{ + private static readonly PortugueseConverter Converter = new(); + + [Theory] + [InlineData("Tira a fantasia.", "Ditch the leotard.", "Tira o maillot.")] + [InlineData("A fantasia vermelha.", "The red leotard.", "O maillot vermelho.")] + [InlineData("As fantasias estão novas.", "The leotards are new.", "Os maillots estão novos.")] + [InlineData("A minha fantasia está rasgada.", "My leotard is torn.", "O meu maillot está rasgado.")] + [InlineData("Tira a fantasia.", "Ditch the leotard.", "Tira o maillot.")] + [InlineData("TIRA A FANTASIA.", "Ditch the leotard.", "TIRA O MAILLOT.")] + [InlineData("O collant azul.", "The blue leotard.", "O maillot azul.")] + [InlineData("Os colants pretos.", "The black leotards.", "Os maillots pretos.")] + [InlineData("Veste o agasalho.", "Put on the tracksuit.", "Veste o fato de treino.")] + [InlineData("Os agasalhos novos.", "The new tracksuits.", "Os fatos de treino novos.")] + [InlineData("O macacão preto.", "The black wetsuit.", "O fato de mergulho preto.")] + [InlineData("Os macacões pretos.", "The black wetsuits.", "Os fatos de mergulho pretos.")] + [InlineData("A camisa branca.", "The white golf shirt.", "O polo branco.")] + [InlineData("As camisas novas.", "The new polo shirts.", "Os polos novos.")] + [InlineData("A camiseta branca.", "The white golf shirt.", "O polo branco.")] + [InlineData("A camisa vermelha.", "The red cycling jersey.", "A camisola de ciclismo vermelha.")] + [InlineData("A camiseta vermelha.", "The red cycling jersey.", "A camisola de ciclismo vermelha.")] + [InlineData("Os culotes brancos.", "The white riding breeches.", "As calças de equitação brancas.")] + [InlineData("Os culotes brancos.", "The white jodhpurs.", "As calças de equitação brancas.")] + public void EnglishSportswearResolvesAmbiguousBrazilianGarments(string source, string english, string expected) + { + var reference = ReferenceHint.FromText(english); + var trace = new List(); + Assert.Equal(expected, Converter.Convert(source, null, reference, trace)); + Assert.Contains(trace, r => r.Id == "sports-clothing"); + Assert.Equal(expected, Converter.Convert(expected, null, reference)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false, YouToTu: false)) + .Convert(source, null, reference)); + var disabledTrace = new List(); + new PortugueseConverter(new ConversionOptions(DisabledRules: "sports-clothing")) + .Convert(source, null, reference, disabledTrace); + Assert.DoesNotContain(disabledTrace, r => r.Id == "sports-clothing"); + } + + [Theory] + [InlineData("Tira a fantasia.", null)] + [InlineData("Tira a fantasia.", "Take off the costume.")] + [InlineData("Tira a fantasia.", "Take off the dress.")] + [InlineData("Tira a fantasia.", "Take off the leotard and the costume.")] + [InlineData("Tira a fantasia.", "Take off the leotards.")] + [InlineData("As fantasias.", "The leotard.")] + [InlineData("Uma fantasia e outra fantasia.", "A leotard.")] + [InlineData("Os collants de ballet.", "The ballet tights.")] + [InlineData("Os collants de ballet.", null)] + [InlineData("O agasalho.", "The warm coat.")] + [InlineData("O macacão.", "The mechanic's overalls.")] + [InlineData("Os culotes.", null)] + [InlineData("Os culotes.", "His historical breeches.")] + [InlineData("Tira a fantasia.", "Not the leotard, the swimsuit.")] + [InlineData("As polainas.", "The riding gaiters.")] + [InlineData("As chuteiras e as caneleiras.", "The football boots and shin guards.")] + public void AmbiguousSportswearAndSharedTermsArePreserved(string source, string? english) => + Assert.Equal(source, Converter.Convert(source, null, ReferenceHint.FromText(english))); + + [Theory] + [InlineData("Um leotard preto.", "Um maillot preto.")] + [InlineData("Os leotards novos.", "Os maillots novos.")] + [InlineData("O maiô de ginástica.", "O maillot de ginástica.")] + [InlineData("Os maiôs de ginástica.", "Os maillots de ginástica.")] + [InlineData("O maiô de balé.", "O maillot de ballet.")] + [InlineData("Os maiôs de balé.", "Os maillots de ballet.")] + [InlineData("A camisa polo branca.", "O polo branco.")] + [InlineData("As camisas polo brancas.", "Os polos brancos.")] + [InlineData("A camiseta polo nova.", "O polo novo.")] + [InlineData("As camisetas polo novas.", "Os polos novos.")] + [InlineData("A camisa de golfe.", "O polo de golfe.")] + [InlineData("As camisas de golfe.", "Os polos de golfe.")] + [InlineData("As calças de hipismo.", "As calças de equitação.")] + [InlineData("As botas de hipismo.", "As botas de equitação.")] + [InlineData("O capacete de hipismo.", "O toque de equitação.")] + [InlineData("Os capacetes de hipismo.", "Os toques de equitação.")] + [InlineData("A casaca de hipismo.", "A casaca de equitação.")] + [InlineData("As casacas de hipismo.", "As casacas de equitação.")] + [InlineData("A camisa de ciclismo.", "A camisola de ciclismo.")] + [InlineData("As camisas de ciclismo.", "As camisolas de ciclismo.")] + [InlineData("As bermudas de ciclismo pretas.", "Os calções de ciclismo pretos.")] + [InlineData("O macacão de mergulho.", "O fato de mergulho.")] + [InlineData("Os macacões de mergulho.", "Os fatos de mergulho.")] + [InlineData("O sutiã esportivo.", "O soutien desportivo.")] + [InlineData("Os sutiãs esportivos.", "Os soutiens desportivos.")] + public void QualifiedSportswearWorksWithoutEnglish(string source, string expected) + { + Converts(source, expected); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + } + + [Theory] + [InlineData("a calcinha", "as cuecas")] + [InlineData("a cueca", "as cuecas")] + [InlineData("na minha cueca", "nas minhas cuecas")] + [InlineData("uma cueca limpa", "umas cuecas limpas")] + [InlineData("Arrancou a calcinha.", "Arrancou as cuecas.")] + [InlineData("A sua calcinha branca.", "As tuas cuecas brancas.")] + [InlineData("As cuecas estão limpas.", "As cuecas estão limpas.")] + [InlineData("Cueca boxer.", "Boxers.")] + [InlineData("A cueca está limpa.", "As cuecas estão limpas.")] + [InlineData("A cueca estava suja.", "As cuecas estavam sujas.")] + [InlineData("A cueca é branca.", "As cuecas são brancas.")] + [InlineData("A cueca ficou molhada.", "As cuecas ficaram molhadas.")] + public void UnderwearUsesPluralWithAgreement(string source, string expected) => Converts(source, expected); + + [Theory] + [InlineData("Ele jogou ela no chão.", "Ele mandou-a para o chão.")] + [InlineData("Ela jogou ele no chão.", "Ela mandou-o para o chão.")] + [InlineData("Eles jogaram elas no chão.", "Eles mandaram-nas para o chão.")] + [InlineData("Não jogou ela no chão.", "Não a mandou para o chão.")] + [InlineData("Tirou a camisa dela.", "Tirou-lhe a camisa.")] + [InlineData("Arrancou o casaco dele.", "Arrancou-lhe o casaco.")] + [InlineData("Tirou os sapatos deles.", "Tirou-lhes os sapatos.")] + [InlineData("Tirou minha camisa.", "Tirou-me a camisa.")] + [InlineData("Não tirou a camisa dela.", "Não lhe tirou a camisa.")] + public void PersonAndExplicitClothingOwner(string source, string expected) => Converts(source, expected); + + [Fact] + public void SportswearRespectsLocalOverridesAndIgnores() + { + var local = new PortugueseLocalWordList(); + local.Words.Add(("fantasia", "roupa")); + local.Words.Add(("camiseta", "t-shirt")); + local.Ignored.Add("agasalho"); + var converter = new PortugueseConverter(localWordList: local); + Assert.Equal("Tira a roupa.", converter.Convert("Tira a fantasia.", null, ReferenceHint.FromText("Ditch the leotard."))); + Assert.Equal("Veste o agasalho.", converter.Convert("Veste o agasalho.", null, ReferenceHint.FromText("Put on the tracksuit."))); + Assert.Equal("A t-shirt.", converter.Convert("A camiseta.", null, ReferenceHint.FromText("The golf shirt."))); + } + + [Fact] + public void EpisodeSentenceUsesReferenceConfirmedOwner() + { + var reference = ReferenceHint.FromText("She was on her way home from the library. Next thing she knows, perp's got her on the ground, yanks her jeans, rips her underwear."); + const string source = "Depois, ele a jogou no chão tirou\nseu jeans e arrancou a calcinha."; + const string expected = "Depois, ele mandou-a para o chão, tirou-lhe\nos jeans e arrancou-lhe as cuecas."; + Assert.Equal(expected, Converter.Convert(source, null, reference)); + Assert.Equal(expected, Converter.Convert(expected, null, reference)); + } + + [Theory] + [InlineData("Tirou o seu casaco.")] + [InlineData("Ele mandou-a para o chão.")] + [InlineData("Tirou-lhe a camisa.")] + [InlineData("Arrancou a porta.")] + [InlineData("Ele jogou-o no chão.")] + public void AmbiguousOwnersAndValidOutputsStayUnchanged(string source) + { + var formal = new ReferenceHint(false, false, true, true) { FormalAddress = true }; + Assert.Equal(source, Converter.Convert(source, null, formal)); + } + + [Fact] + public void ThrowsObjectsWithoutChangingTheirMeaning() + { + Assert.Equal("Ele jogou a bola no chão.", Converter.Convert("Ele jogou a bola no chão.")); + } + + [Fact] + public void VocabularyAndPronounGroupsRemainIndependent() + { + Assert.Equal("Arrancou a calcinha.", new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert("Arrancou a calcinha.")); + Assert.Equal("Tirou as cuecas dela.", new PortugueseConverter(new ConversionOptions(Pronouns: false)).Convert("Tirou a calcinha dela.")); + } + + private static void Converts(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + } +} diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ConstructionTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ConstructionTests.cs new file mode 100644 index 00000000..909bffe4 --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/ConstructionTests.cs @@ -0,0 +1,346 @@ +using System.Text.Json; +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; +using SubtitleEdit.Plugins.Shared; + +namespace BrazilianToEuropeanPortuguese.Tests; + +public sealed class ConstructionTests +{ + private static readonly PortugueseConverter Converter = new(); + + [Theory] + [InlineData("Você é meu vizinho de andar.", "Hey, we live on the same floor.", "Vivemos no mesmo andar.")] + [InlineData("És meu vizinho de andar.", "We live on the same floor.", "Vivemos no mesmo andar.")] + [InlineData("Tu és o meu vizinho do mesmo andar.", "We live on the same floor.", "Vivemos no mesmo andar.")] + [InlineData("Sou tua vizinha de andar.", "We live on the same floor.", "Vivemos no mesmo andar.")] + [InlineData("Somos vizinhos do mesmo prédio.", "We live in the same building.", "Vivemos no mesmo edifício.")] + [InlineData("Você é meu vizinho da mesma rua.", "We live on the same street.", "Vivemos na mesma rua.")] + [InlineData("Sou teu vizinho do mesmo bairro.", "We live in the same neighborhood.", "Vivemos no mesmo bairro.")] + [InlineData("Nós somos vizinhos do mesmo quarteirão.", "We live on the same block.", "Vivemos no mesmo quarteirão.")] + [InlineData("Éramos vizinhos do mesmo edifício.", "We lived in the same building.", "Vivíamos no mesmo edifício.")] + [InlineData("Eras meu vizinho de andar.", "We lived on the same floor.", "Vivíamos no mesmo andar.")] + [InlineData("VOCÊ É MEU VIZINHO DE ANDAR.", "We live on the same floor.", "VIVEMOS NO MESMO ANDAR.")] + [InlineData("Você é meu vizinho de andar.", "Hey, we live on the same floor.", "Vivemos no mesmo andar.")] + [InlineData("Ei, somos vizinhos da mesma rua!", "Hey, we live on the same street!", "Olha, vivemos na mesma rua!")] + public void SharedResidenceRequiresMatchingEnglishMeaning(string source, string english, string expected) + { + var reference = ReferenceHint.FromText(english); + var trace = new List(); + Assert.Equal(expected, Converter.Convert(source, null, reference, trace)); + Assert.Contains(trace, r => r.Id == "shared-residence"); + Assert.Equal(expected, Converter.Convert(expected, null, reference)); + foreach (var options in new[] { new ConversionOptions(Colloquial: false), + new ConversionOptions(Vocabulary: false), new ConversionOptions(DisabledRules: "shared-residence") }) + { + var disabledTrace = new List(); + new PortugueseConverter(options).Convert(source, null, reference, disabledTrace); + Assert.DoesNotContain(disabledTrace, r => r.Id == "shared-residence"); + Assert.Equal(source, ConversionConstructions.SharedResidence(source, null)); + } + } + + [Theory] + [InlineData("Somos vizinhos do mesmo prédio.", null)] + [InlineData("Somos vizinhos do mesmo prédio.", "We don't live in the same building.")] + [InlineData("Somos vizinhos do mesmo prédio.", "They live in the same building.")] + [InlineData("Somos vizinhos do mesmo prédio.", "We live on the same street.")] + [InlineData("Somos vizinhos do mesmo prédio.", "We lived in the same building.")] + [InlineData("Somos vizinhos do mesmo prédio.", "Do we live in the same building?")] + [InlineData("Somos vizinhos do mesmo prédio.", "We live in the same building, but not anymore.")] + [InlineData("Somos vizinhos do mesmo prédio?", "We live in the same building.")] + [InlineData("Não somos vizinhos do mesmo prédio.", "We live in the same building.")] + [InlineData("Somos vizinhos do mesmo prédio, mas não nos conhecemos.", "We live in the same building.")] + public void SharedResidencePreservesMissingConflictingAndComplexEvidence(string source, string? english) + { + var reference = ReferenceHint.FromText(english); + Assert.Equal(source, ConversionConstructions.SharedResidence(source, reference)); + var trace = new List(); + var result = Converter.Convert(source, null, reference, trace); + Assert.Equal(new PortugueseConverter(new ConversionOptions(DisabledRules: "shared-residence")) + .Convert(source, null, reference), result); + Assert.DoesNotContain(trace, r => r.Id == "shared-residence"); + } + + [Theory] + [InlineData("Suspeito de cerca de 1,80m, porte médio.", "Suspeito com cerca de 1,80m, porte médio.")] + [InlineData("Uma mulher de aproximadamente 1,65 m.", "Uma mulher com aproximadamente 1,65 m.")] + [InlineData("Um homem de 1,80 metros de altura.", "Um homem com 1,80 metros de altura.")] + [InlineData("Um homem alto de dois metros.", "Um homem alto com dois metros.")] + [InlineData("O indivíduo de mais de 180 cm.", "O indivíduo com mais de 180 cm.")] + [InlineData("Uma pessoa de menos de 70 kg.", "Uma pessoa com menos de 70 kg.")] + [InlineData("Um rapaz de cerca de oitenta quilos.", "Um rapaz com cerca de oitenta quilos.")] + [InlineData("Uma criança de vinte e dois quilogramas de peso.", "Uma criança com vinte e dois quilogramas de peso.")] + [InlineData("Uma rapariga de 170 centímetros.", "Uma rapariga com 170 centímetros.")] + [InlineData("Os suspeitos de cerca de 1,80m.", "Os suspeitos com cerca de 1,80m.")] + [InlineData("SUSPEITA DE CERCA DE 1,70M.", "SUSPEITA COM CERCA DE 1,70M.")] + [InlineData("Suspeito de cerca de\n1,80m, porte médio.", "Suspeito com cerca de\n1,80m, porte médio.")] + [InlineData("Homem de 1,80m e 80 kg.", "Homem com 1,80m e 80 kg.")] + [InlineData("Mulher de cerca de 60 kg, cabelo castanho.", "Mulher com cerca de 60 kg, cabelo castanho.")] + public void PhysicalDescriptionsUseComForMeasurements(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Colloquial: false)).Convert(source)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(DisabledRules: "physical-descriptions")).Convert(source)); + var trace = new List(); + Assert.Equal(expected, Converter.Convert(source, trace: trace)); + Assert.Contains(trace, r => r.Id == "physical-descriptions"); + } + + [Theory] + [InlineData("Um muro de cerca de dois metros.")] + [InlineData("Uma mesa de 1,80m.")] + [InlineData("Um suspeito de cerca de 30 anos.")] + [InlineData("Uma mulher de cabelos castanhos.")] + [InlineData("Um homem de palavra.")] + [InlineData("Suspeito de tráfico de droga.")] + [InlineData("O homem de cerca de dois milhões.")] + [InlineData("O homem de 1,80 milhões de euros.")] + [InlineData("Uma pessoa de 70 kg de carga.")] + [InlineData("Um homem com cerca de 1,80m.")] + [InlineData("Um homem de uma família de quatro pessoas.")] + [InlineData("Uma mulher de cerca de 1,70 milhas de distância.")] + [InlineData("Uma dose de 80 mg.")] + public void PhysicalDescriptionsPreserveOtherDeComplements(string source) => + Assert.Equal(source, Converter.Convert(source)); + + [Theory] + [InlineData("Você lembra o que aconteceu?", "Lembras-te do que aconteceu?")] + [InlineData("Eu lembro o nome.", "Eu lembro-me do nome.")] + [InlineData("Ela lembra aquilo que disse.", "Ela lembra-se daquilo que disse.")] + [InlineData("Não lembro isso.", "Não me lembro disso.")] + [InlineData("Nós lembramos a data.", "Nós lembramo-nos da data.")] + [InlineData("Esqueci de te ligar.", "Esqueci-me de te ligar.")] + [InlineData("Ela está namorando ele.", "Ela está a namorar com ele.")] + [InlineData("Eu namorei ela.", "Eu namorei com ela.")] + [InlineData("Você namora ela?", "Namoras com ela?")] + [InlineData("Ela namorava um médico.", "Ela namorava um médico.")] + [InlineData("Ele namora a minha colega.", "Ele namora a minha colega.")] + [InlineData("Eu lembrarei do nome.", "Eu lembrar-me-ei do nome.")] + [InlineData("Não esqueceremos da reunião.", "Não nos esqueceremos da reunião.")] + [InlineData("Vamos lembrar de ligar.", "Vamos lembrar-nos de ligar.")] + [InlineData("Para lembrar o que aconteceu.", "Para lembrar-se do que aconteceu.")] + public void GovernmentComplements(string source, string expected) => Converts(source, expected); + + [Theory] + [InlineData("Você acha que pode resolver isso?", "Achas que podes resolver isso?")] + [InlineData("Você pensa que consegue ajudar?", "Pensas que consegues ajudar?")] + [InlineData("Você acha que não pode entrar?", "Achas que não podes entrar?")] + [InlineData("Se você soubesse, teria contado.", "Se soubesses, terias contado.")] + [InlineData("Se você pudesse, não faria isso.", "Se pudesses, não farias isso.")] + public void SubjectContinuity(string source, string expected) => Converts(source, expected); + + [Theory] + [InlineData("Você disse que estava cansado.", "You said you were tired.", "Disseste que estavas cansado.")] + [InlineData("Você disse que não queria sair.", "You said you didn't want to leave.", "Disseste que não querias sair.")] + [InlineData("Você acha que pode resolver isso?", "You think you can fix it?", "Achas que podes resolver isso?")] + [InlineData("Você disse que queria isso.", "You said you wanted it.", "Disseste que querias isso.")] + public void RepeatedEnglishSubjectConfirmsEmbeddedSubject(string source, string english, string expected) + { + var reference = ReferenceHint.FromText(english); + Assert.Equal(expected, Converter.Convert(source, null, reference)); + Assert.Equal(expected, Converter.Convert(expected, null, reference)); + } + + [Theory] + [InlineData("Ele virou médico.", "Ele tornou-se médico.")] + [InlineData("Eu virei advogado.", "Eu tornei-me advogado.")] + [InlineData("Nós viramos amigos.", "Nós tornamo-nos amigos.")] + [InlineData("Ela nunca virou professora.", "Ela nunca se tornou professora.")] + [InlineData("Ele está virando um problema.", "Ele está a tornar-se um problema.")] + [InlineData("Vou pegar você na estação.", "Vou buscar-te à estação.")] + [InlineData("Vou pegar ela no aeroporto.", "Vou buscá-la ao aeroporto.")] + [InlineData("Ela está encarando você.", "Ela está a olhar fixamente para ti.")] + [InlineData("Precisamos encarar o problema.", "Precisamos de enfrentar o problema.")] + [InlineData("Ele encarou a verdade.", "Ele enfrentou a verdade.")] + [InlineData("Não, é para você acertar a cabeça do outro cara.", "Não, é para acertares na cabeça do outro tipo.")] + [InlineData("A bala acertou a cabeça dele.", "A bala acertou na cabeça dele.")] + [InlineData("Atingiram os olhos do suspeito.", "Atingiram os olhos do suspeito.")] + [InlineData("Eu curti o filme.", "Eu gostei do filme.")] + [InlineData("Ela curte esta música.", "Ela gosta desta música.")] + [InlineData("Ele reclama do trabalho.", "Ele queixa-se do trabalho.")] + [InlineData("Eu não reclamo disso.", "Eu não me queixo disso.")] + [InlineData("Esta sopa está gostosa.", "Esta sopa está saborosa.")] + [InlineData("O bolo ficou muito gostoso.", "O bolo ficou muito saboroso.")] + [InlineData("Você virou médico.", "Tornaste-te médico.")] + [InlineData("Eu virarei médico.", "Eu tornar-me-ei médico.")] + [InlineData("Eu reclamaria do trabalho.", "Eu queixar-me-ia do trabalho.")] + [InlineData("Nós reclamamos do trabalho.", "Nós queixamo-nos do trabalho.")] + [InlineData("Ela chega em casa e já reclama de tudo.", "Ela chegou a casa e já está a queixar-se de tudo.")] + [InlineData("Vou virar médico.", "Vou tornar-me médico.")] + [InlineData("Vamos reclamar do trabalho.", "Vamos queixar-nos do trabalho.")] + [InlineData("Você reclama do trabalho.", "Queixas-te do trabalho.")] + public void ComplementAwareVocabulary(string source, string expected) => Converts(source, expected); + + [Theory] + [InlineData("Isso é para você fazer amanhã.", "Isso é para fazeres amanhã.")] + [InlineData("Antes de você sair, me avise.", "Antes de saíres, avisa-me.")] + [InlineData("É melhor você não contar.", "É melhor não contares.")] + [InlineData("Depois de você se vestir, pode sair.", "Depois de te vestires, podes sair.")] + [InlineData("Sem vocês perceber, ele saiu.", "Sem perceberem, ele saiu.")] + [InlineData("Para nós fazer isso, precisamos de tempo.", "Para fazermos isso, precisamos de tempo.")] + [InlineData("Antes de eles sair, fala comigo.", "Antes de eles saírem, fala comigo.")] + [InlineData("É importante você não me esquecer.", "É importante não me esqueceres.")] + [InlineData("É melhor você pôr isto aqui.", "É melhor pores isto aqui.")] + [InlineData("Sem você cair.", "Sem caíres.")] + [InlineData("Para vocês construir a casa.", "Para construírem a casa.")] + [InlineData("Para nós sair.", "Para sairmos.")] + [InlineData("Antes de você sair, não me avise.", "Antes de saíres, não me avises.")] + public void PersonalInfinitiveSubjectsAndInterveningWords(string source, string expected) => Converts(source, expected); + + [Theory] + [InlineData("Manter-te-ei informado.", "Vou manter-te informado.")] + [InlineData("Dar-te-emos notícias.", "Vamos dar-te notícias.")] + [InlineData("Fá-lo-ei amanhã.", "Vou fazê-lo amanhã.")] + [InlineData("Trá-lo-ão amanhã.", "Vão trazê-lo amanhã.")] + [InlineData("Dir-te-á tudo.", "Vai dizer-te tudo.")] + [InlineData("Eu estou pronto.", "Estou pronto.")] + [InlineData("Nós vamos sair.", "Vamos sair.")] + [InlineData("Eu não quero sair.", "Não quero sair.")] + [InlineData("Eu amo-te.", "Amo-te.")] + public void OptionalConversationalStyle(string source, string expected) + { + var converter = new PortugueseConverter(new ConversionOptions(Conversational: true)); + Assert.Equal(expected, converter.Convert(source)); + Assert.Equal(expected, converter.Convert(expected)); + } + + [Theory] + [InlineData("Manter-te-ei informado.")] + [InlineData("Eu estou pronto.")] + [InlineData("Nós vamos sair.")] + public void ConversationalStyleIsOffByDefault(string source) => Assert.Equal(source, Converter.Convert(source)); + + [Theory] + [InlineData("Eu faria isso.")] + [InlineData("Eu estava pronto.")] + [InlineData("Eu sou médico, mas ele é advogado.")] + [InlineData("Só eu sei.")] + [InlineData("Eu também quero.")] + [InlineData("Eu e a Maria vamos sair.")] + [InlineData("Senhor, manter-lhe-ei a porta aberta.")] + [InlineData("Eu disse que viria.")] + public void ConversationalStyleProtectsContrastFormalityAndConditional(string source) + { + var normal = Converter.Convert(source); + Assert.Equal(normal, new PortugueseConverter(new ConversionOptions(Conversational: true)).Convert(source)); + } + + [Theory] + [InlineData("Isso me custa um braço e uma perna.", "It costs me an arm and a leg.", "Isso custa-me os olhos da cara.")] + [InlineData("Estou todo ouvidos.", "I'm all ears.", "Sou todo ouvidos.")] + [InlineData("Estamos todos ouvidos.", "We're all ears.", "Somos todos ouvidos.")] + [InlineData("É por conta da casa.", "It's on the house.", "É oferta da casa.")] + [InlineData("Ele derramou os feijões.", "He spilled the beans.", "Ele contou tudo.")] + [InlineData("Ela aparece uma vez numa lua azul.", "She appears once in a blue moon.", "Ela aparece muito de vez em quando.")] + public void IdiomsNeedBothPortugueseConstructionAndEnglishEvidence(string source, string english, string expected) + { + var reference = ReferenceHint.FromText(english); + Assert.Equal(expected, Converter.Convert(source, null, reference)); + Assert.Equal(expected, Converter.Convert(expected, null, reference)); + Assert.NotEqual(expected, Converter.Convert(source)); + } + + [Theory] + [InlineData("Pode confiar em mim.")] + [InlineData("Esqueci o nome.")] + [InlineData("Ele lembra o pai.")] + [InlineData("Vira à esquerda.")] + [InlineData("Ele virou a página.")] + [InlineData("Ele virou o rosto.")] + [InlineData("O couro precisa de curtir.")] + [InlineData("Ele reclama a herança.")] + [InlineData("Ela é gostosa.")] + [InlineData("Isso é para eu fazer amanhã.")] + [InlineData("É melhor ele não contar.")] + [InlineData("Ele namora com ela.")] + [InlineData("Ela está a namorar com um médico.")] + [InlineData("Ela está a reclamar a herança.")] + [InlineData("Não sei se ele é médico.")] + [InlineData("Vamos acertar a cabeça do parafuso.")] + [InlineData("Virava médico.")] + [InlineData("Reclamaria do trabalho.")] + public void ValidOrAmbiguousSensesStayUnchanged(string source) => Assert.Equal(source, Converter.Convert(source)); + + [Theory] + [InlineData("Você acha que ele pode resolver isso?", "Achas que ele pode resolver isso?")] + [InlineData("Você acha que pode chover?", "Achas que pode chover?")] + [InlineData("Você disse que estava cansado.", "Disseste que estava cansado.")] + [InlineData("Se você soubesse que ele estava aqui, teria contado.", "Se soubesses que ele estava aqui, teria contado.")] + [InlineData("Você acha que se pode trabalhar aqui?", "Achas que se pode trabalhar aqui?")] + public void DifferentOrUnclearClauseSubjectIsProtected(string source, string expected) => Converts(source, expected); + + [Fact] + public void ReferenceDoesNotSupplyAnAbsentPortugueseIdiom() + { + Assert.Equal("Há feijões na mesa.", Converter.Convert("Há feijões na mesa.", null, ReferenceHint.FromText("He spilled the beans."))); + Assert.Equal("Ele derramou os feijões.", Converter.Convert("Ele derramou os feijões.", null, ReferenceHint.FromText("He spilled beans on the floor."))); + Assert.Equal("Ele derramou os feijões no chão.", Converter.Convert("Ele derramou os feijões no chão.", null, ReferenceHint.FromText("He spilled the beans on the floor."))); + } + + [Fact] + public void FormalReferenceBlocksNewSecondPersonContinuityAndStyle() + { + var reference = new ReferenceHint(true, false, false, false) { FormalAddress = true }; + var converter = new PortugueseConverter(new ConversionOptions(Conversational: true)); + Assert.Equal("Acha que pode resolver isso?", converter.Convert("Você acha que pode resolver isso?", null, reference)); + Assert.Equal("É melhor não contar.", converter.Convert("É melhor você não contar.", null, reference)); + Assert.Equal("Manter-lhe-ei a porta aberta.", converter.Convert("Manter-lhe-ei a porta aberta.", null, reference)); + } + + [Fact] + public void NewStagesCanBeDisabledAndHaveTrace() + { + var trace = new List(); + Assert.Equal("Ele tornou-se médico.", Converter.Convert("Ele virou médico.", null, null, trace)); + Assert.Contains(trace, rule => rule.Id == "construction-vocabulary"); + Assert.Equal("Ele virou médico.", new PortugueseConverter( + new ConversionOptions(DisabledRules: "construction-vocabulary")).Convert("Ele virou médico.")); + Assert.Equal("Manter-te-ei informado.", new PortugueseConverter( + new ConversionOptions(Conversational: true, DisabledRules: "conversational-style")).Convert("Manter-te-ei informado.")); + } + + [Fact] + public void ConversationalSettingRoundTripsAndRejectsInvalidShapes() + { + var options = new ConversionOptions(Conversational: true); + Assert.Equal(options, ConversionOptions.Load(new PluginRequest + { SettingsVersion = ConversionOptions.Version, Settings = options.ToJson() })); + Assert.False(ConversionOptions.Load(new PluginRequest + { SettingsVersion = ConversionOptions.Version, Settings = JsonSerializer.SerializeToElement(new { }) }).Conversational); + Assert.Throws(() => ConversionOptions.Load(new PluginRequest + { SettingsVersion = ConversionOptions.Version, Settings = JsonSerializer.SerializeToElement(new { conversational = "yes" }) })); + } + + [Fact] + public void TagsAndLineBreaksRemainIntact() + { + var converted = Converter.Convert("Ele virou\nmédico."); + Assert.Equal("Ele tornou-se\nmédico.", converted); + Assert.Equal(converted, Converter.Convert(converted)); + } + + [Fact] + public void NewConstructionsRespectDisabledGroups() + { + Assert.Equal("Ele virou médico.", new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert("Ele virou médico.")); + Assert.Equal("Ele reclama do trabalho.", new PortugueseConverter(new ConversionOptions(Pronouns: false)).Convert("Ele reclama do trabalho.")); + Assert.Equal("É melhor você não contar.", new PortugueseConverter(new ConversionOptions(YouToTu: false)).Convert("É melhor você não contar.")); + var reference = ReferenceHint.FromText("It's on the house."); + Assert.Equal("É por conta da casa.", new PortugueseConverter(new ConversionOptions(Colloquial: false)).Convert("É por conta da casa.", null, reference)); + } + + [Fact] + public void SharedCuePipelineUsesSavedConversationalSetting() + { + var cue = new SrtBlock { Text = "Eu estou pronto.", StartMs = 1000, EndMs = 4000 }; + Assert.Equal("Eu estou pronto.", SubtitleConversion.Convert(new[] { cue }, new ConversionOptions())[0].Text); + Assert.Equal("Estou pronto.", SubtitleConversion.Convert(new[] { cue }, new ConversionOptions(Conversational: true))[0].Text); + } + + private static void Converts(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + } +} diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ConverterTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ConverterTests.cs new file mode 100644 index 00000000..6d88912a --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/ConverterTests.cs @@ -0,0 +1,2248 @@ +using System.Text.RegularExpressions; +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; + +namespace BrazilianToEuropeanPortuguese.Tests; + +public sealed class ConverterTests +{ + private static readonly PortugueseConverter Converter = new(); + + private static void AssertConverts(string br, string pt) => Assert.Equal(pt, Converter.Convert(br)); + + [Theory] + [InlineData("Uma sacola nova.", "Um saco novo.")] + [InlineData("As sacolas vazias.", "Os sacos vazios.")] + [InlineData("Os shorts novos.", "Os calções novos.")] + [InlineData("O aipim cozido.", "A mandioca cozida.")] + [InlineData("Um misto-quente.", "Uma tosta mista.")] + [InlineData("Os mistos-quentes.", "As tostas mistas.")] + [InlineData("Uma chave de fenda.", "Uma chave de fendas.")] + [InlineData("As chaves de fenda.", "As chaves de fendas.")] + [InlineData("A arruela está gasta.", "A anilha está gasta.")] + [InlineData("As arruelas novas.", "As anilhas novas.")] + [InlineData("Uma furadeira nova.", "Um berbequim novo.")] + [InlineData("As furadeiras novas.", "Os berbequins novos.")] + [InlineData("A embreagem.", "A embraiagem.")] + [InlineData("As embreagens.", "As embraiagens.")] + [InlineData("Uma porca borboleta.", "Uma porca de orelhas.")] + [InlineData("As porcas borboleta.", "As porcas de orelhas.")] + [InlineData("As porcas borboletas.", "As porcas de orelhas.")] + [InlineData("O torque de aperto.", "O binário de aperto.")] + [InlineData("Os torques de aperto.", "Os binários de aperto.")] + [InlineData("Eu rosqueei a tampa.", "Eu enrosquei a tampa.")] + [InlineData("Ela rosqueava a tampa.", "Ela enroscava a tampa.")] + [InlineData("Para rosquear a tampa.", "Para enroscar a tampa.")] + [InlineData("Ele parafusou a peça.", "Ele aparafusou a peça.")] + [InlineData("Ela desparafusou a tampa.", "Ela desaparafusou a tampa.")] + [InlineData("Vou parafusá-lo.", "Vou aparafusá-lo.")] + [InlineData("Ele desengraxou a superfície.", "Ele desengordurou a superfície.")] + [InlineData("Ela destravou a porta.", "Ela desbloqueou a porta.")] + [InlineData("Ele afrouxou a porca.", "Ele desapertou a porca.")] + [InlineData("Ela engraxou o mecanismo.", "Ela lubrificou o mecanismo.")] + [InlineData("Eu digitei o código.", "Eu introduzi o código.")] + [InlineData("Eu digito o código.", "Eu introduzo o código.")] + [InlineData("Tu digitas o código.", "Tu introduzes o código.")] + [InlineData("Eles digitam dados.", "Eles introduzem dados.")] + [InlineData("Para digitar a palavra-passe.", "Para introduzir a palavra-passe.")] + [InlineData("Ele digita a senha.", "Ele introduz a palavra-passe.")] + [InlineData("Eu subi um arquivo.", "Eu carreguei um ficheiro.")] + [InlineData("Eu subo o arquivo.", "Eu carrego o ficheiro.")] + [InlineData("Ela sobe os arquivos.", "Ela carrega os ficheiros.")] + [InlineData("Eles sobem documentos para a plataforma.", "Eles carregam documentos para a plataforma.")] + [InlineData("Tu sobes o ficheiro.", "Tu carregas o ficheiro.")] + [InlineData("Ela subiu o documento para o servidor.", "Ela carregou o documento para o servidor.")] + [InlineData("Vou subir o ficheiro.", "Vou carregar o ficheiro.")] + [InlineData("Ela estava subindo o arquivo.", "Ela estava a carregar o ficheiro.")] + [InlineData("Vou baixar o documento.", "Vou descarregar o documento.")] + [InlineData("Ela salvou o ficheiro.", "Ela guardou o ficheiro.")] + [InlineData("Ela subiu\num arquivo.", "Ela carregou\num ficheiro.")] + public void VocabularyVerbWorkbookAddsReviewedMissingSenses(string source, string expected) + { + AssertConverts(source, expected); + AssertConverts(expected, expected); + } + + [Theory] + [InlineData("Ele engraxou os sapatos.")] + [InlineData("Ela afrouxou a vigilância.")] + [InlineData("Ele subiu a escada.")] + [InlineData("Ele subiu os documentos para o sótão.")] + [InlineData("Ela subiu o documento.")] + [InlineData("Ela sobe ao palco.")] + [InlineData("Os preços sobem.")] + [InlineData("Ele salvou a criança.")] + [InlineData("Ela baixou a cabeça.")] + [InlineData("O grampo de cabelo.")] + [InlineData("Uma prova de amor.")] + [InlineData("O boleto.")] + [InlineData("A vedação do terreno.")] + [InlineData("Ela confere autoridade.")] + [InlineData("Ele travou a batalha.")] + [InlineData("A fila está longa.")] + [InlineData("A matéria.")] + [InlineData("A mira telescópica.")] + [InlineData("A matriz de mira.")] + [InlineData("A torreta de ajuste.")] + [InlineData("O torquímetro.")] + [InlineData("Ela digita cartas.")] + [InlineData("A pressão de calibragem dos pneus.")] + public void VocabularyVerbWorkbookPreservesOtherSensesAndSharedPortuguese(string text) => AssertConverts(text, text); + + [Theory] + [InlineData("Uma sacola nova.")] + [InlineData("Ela destravou a porta.")] + [InlineData("Ela engraxou o mecanismo.")] + [InlineData("Eu digitei o código.")] + [InlineData("Ela subiu um ficheiro.")] + public void VocabularyVerbWorkbookRespectsVocabularySwitch(string source) => + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + + [Fact] + public void UploadVerbRespectsConstructionStageAndReportsTrace() + { + const string source = "Ela subiu o ficheiro."; + var trace = new List(); + Assert.Equal("Ela carregou o ficheiro.", Converter.Convert(source, trace: trace)); + Assert.Contains(trace, r => r.Id == "construction-vocabulary"); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(DisabledRules: "construction-vocabulary")).Convert(source)); + } + + [Theory] + [InlineData("porque você sempre sabe\nquando eu tô mentindo.", "porque sabes sempre\nquando estou a mentir.")] + [InlineData("porque você sempre sabe\nquando eu tô mentindo.", "porque sabes sempre\nquando estou a mentir.")] + [InlineData("Tu sempre sabes quando eu estou mentindo.", "Tu sabes sempre quando estou a mentir.")] + [InlineData("Ela sempre chega cedo.", "Ela chega sempre cedo.")] + [InlineData("Eles sempre trabalham aqui.", "Eles trabalham sempre aqui.")] + [InlineData("Sempre encontro uma solução.", "Encontro sempre uma solução.")] + [InlineData("Porque sempre soubeste.", "Porque soubeste sempre.")] + [InlineData("SEMPRE CHEGO CEDO.", "CHEGO SEMPRE CEDO.")] + [InlineData("porque SEMPRE SABES.", "porque SABES SEMPRE.")] + [InlineData("Porque sempre chegavam cedo.", "Porque chegavam sempre cedo.")] + [InlineData("Eles sempre trabalharão aqui.", "Eles trabalharão sempre aqui.")] + [InlineData("Quando eu estou a trabalhar.", "Quando estou a trabalhar.")] + [InlineData("Se eu estou a mentir.", "Se estou a mentir.")] + [InlineData("Ele sabe quando eu estou a estudar.", "Ele sabe quando estou a estudar.")] + public void NaturalHabitualWordOrderAndRecoverableProgressiveSubjects(string source, string expected) + { + AssertConverts(source, expected); + AssertConverts(expected, expected); + } + + [Theory] + [InlineData("Nem sempre sabes.")] + [InlineData("Quase sempre trabalho.")] + [InlineData("Para sempre trabalho.")] + [InlineData("Como sempre digo.")] + [InlineData("Sempre que chego.")] + [InlineData("Sempre posso ajudar.")] + [InlineData("Sempre estou a trabalhar.")] + [InlineData("Sempre me dizem isso.")] + [InlineData("Sempre fazer o melhor.")] + [InlineData("Quando eu estava a trabalhar.")] + [InlineData("Quando eu também estou a trabalhar.")] + [InlineData("Quando só eu estou a trabalhar.")] + [InlineData("Quando eu estou a trabalhar e tu estás a dormir.")] + public void NaturalWordOrderPreservesScopeCliticsAndSubjectContrast(string text) => AssertConverts(text, text); + + [Fact] + public void NaturalWordOrderRespectsColloquialAndStageSwitches() + { + const string text = "porque sempre sabes quando eu estou a mentir."; + Assert.Equal(text, new PortugueseConverter(new ConversionOptions(Colloquial: false)).Convert(text)); + Assert.Equal(text, new PortugueseConverter(new ConversionOptions(DisabledRules: "natural-word-order")).Convert(text)); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ScreenshotTellThingConvertsWithBothOrthographies(bool postAgreement) + { + const string source = "Você não lembra de mim,\nmas vou te contar uma parada"; + const string english = "You don't remember me, but I have something to tell you"; + var converter = new PortugueseConverter(new ConversionOptions(PostAgreement: postAgreement, ValidateSpelling: true)); + var rules = new List(); + var result = converter.Convert(source, null, ReferenceHint.FromText(english), rules); + Assert.Equal("Não te lembras de mim,\nmas vou contar-te uma coisa", result); + Assert.Contains(rules, r => r.Id == "reference-idioms"); + Assert.Contains(rules, r => r.Id == "pronouns"); + } + + [Theory] + [InlineData("Vou te contar uma parada.", "Vou contar-te uma coisa.")] + [InlineData("Vou contar-te uma parada.", "Vou contar-te uma coisa.")] + [InlineData("Vou-te contar uma parada.", "Vou-te contar uma coisa.")] + [InlineData("Mas vou contar uma parada.", "Mas vou contar uma coisa.")] + [InlineData("Não vou te contar uma parada.", "Não vou contar-te uma coisa.")] + [InlineData("Contar-lhe uma parada.", "Contar-lhe uma coisa.")] + public void TellThingComposesWithCliticPlacement(string source, string expected) => AssertConverts(source, expected); + + [Theory] + [InlineData("O holerite chegou.", "O recibo de vencimento chegou.")] + [InlineData("Os holerites chegaram.", "Os recibos de vencimento chegaram.")] + [InlineData("Um trem-bala novo.", "Um comboio de alta velocidade novo.")] + [InlineData("Os trens-bala.", "Os comboios de alta velocidade.")] + [InlineData("Os trens-balas.", "Os comboios de alta velocidade.")] + [InlineData("Um suco de caixinha.", "Um sumo de pacote.")] + [InlineData("Os sucos de caixinha.", "Os sumos de pacote.")] + [InlineData("O computador de mesa.", "O computador de secretária.")] + [InlineData("Os computadores de mesa.", "Os computadores de secretária.")] + [InlineData("Uma mensagem inbox.", "Uma mensagem privada.")] + [InlineData("As mensagens inbox.", "As mensagens privadas.")] + [InlineData("Uma captura de tela.", "Uma captura de ecrã.")] + [InlineData("As capturas de tela.", "As capturas de ecrã.")] + [InlineData("Um pão francês.", "Um papo-seco.")] + [InlineData("Os pães franceses.", "Os papos-secos.")] + [InlineData("Um escanteio.", "Um canto.")] + [InlineData("Os escanteios.", "Os cantos.")] + [InlineData("O zagueiro chegou.", "O defesa-central chegou.")] + [InlineData("Os zagueiros chegaram.", "Os defesas-centrais chegaram.")] + [InlineData("A zagueira chegou.", "A defesa-central chegou.")] + [InlineData("As zagueiras chegaram.", "As defesas-centrais chegaram.")] + [InlineData("Uma mexerica madura.", "Uma tangerina madura.")] + [InlineData("As mexericas maduras.", "As tangerinas maduras.")] + [InlineData("Um suco de mamão.", "Um sumo de papaia.")] + public void AdditionalWorkbookVocabulary(string source, string expected) + { + AssertConverts(source, expected); + Assert.Equal(expected, Converter.Convert(expected)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + } + + [Theory] + [InlineData("Me conta uma parada.", "Conta-me uma coisa.")] + [InlineData("Ela contou uma parada.", "Ela contou uma coisa.")] + [InlineData("Contaram umas paradas.", "Contaram umas coisas.")] + [InlineData("Ela puxou assunto.", "Ela meteu conversa.")] + [InlineData("Eles puxavam assunto.", "Eles metiam conversa.")] + [InlineData("Vou puxar assunto.", "Vou meter conversa.")] + [InlineData("Ela estava puxando assunto.", "Ela estava a meter conversa.")] + [InlineData("Eles jogaram conversa fora.", "Eles falaram.")] + [InlineData("Vou jogar conversa fora.", "Vou falar.")] + [InlineData("Ele está enchendo linguiça.", "Ele está a encher chouriços.")] + [InlineData("Ela encheu linguiça.", "Ela encheu chouriços.")] + [InlineData("Dá uma força!", "Dá uma ajuda!")] + [InlineData("Ele deu uma força.", "Ele deu uma ajuda.")] + [InlineData("Dei uma escapada.", "Dei uma escapadela.")] + [InlineData("Vou dar rolê.", "Vou dar uma volta.")] + [InlineData("Vou dar uns rolês.", "Vou dar umas voltas.")] + [InlineData("Estou de saco cheio.", "Estou farto.")] + [InlineData("Ela ficou de saco cheio.", "Ela ficou farta.")] + [InlineData("Elas ficaram de saco cheio.", "Elas ficaram fartas.")] + [InlineData("Nós estamos de saco cheio.", "Nós estamos fartos.")] + [InlineData("Ela não ficou de saco cheio.", "Ela não ficou farta.")] + [InlineData("Ela já está de saco cheio.", "Ela já está farta.")] + [InlineData("Ele falou pra caramba.", "Ele falou imenso.")] + [InlineData("Falar para caramba.", "Falar imenso.")] + [InlineData("PUXEI ASSUNTO.", "METI CONVERSA.")] + [InlineData("Ela puxou\nassunto.", "Ela meteu\nconversa.")] + [InlineData("Ela puxou assunto.", "Ela meteu conversa.")] + public void AdditionalWorkbookExpressions(string source, string expected) + { + AssertConverts(source, expected); + Assert.Equal(expected, Converter.Convert(expected)); + } + + [Theory] + [InlineData("Baixei um arquivo.", "Descarreguei um ficheiro.", "Baixei um arquivo.")] + [InlineData("Ela salvou os arquivos.", "Ela guardou os ficheiros.", "Ela salvou os arquivos.")] + [InlineData("Vou salvar o arquivo.", "Vou guardar o ficheiro.", "Vou salvar o arquivo.")] + [InlineData("Ela está baixando o arquivo.", "Ela está a descarregar o ficheiro.", "Ela está a baixar o arquivo.")] + [InlineData("Não salve este arquivo.", "Não guardes este ficheiro.", "Não salves este arquivo.")] + [InlineData("BAIXEI O ARQUIVO.", "DESCARREGUEI O FICHEIRO.", "BAIXEI O ARQUIVO.")] + [InlineData("Baixei um\narquivo.", "Descarreguei um\nficheiro.", "Baixei um\narquivo.")] + public void AdditionalWorkbookDigitalFiles(string source, string expected, string withoutVocabulary) + { + AssertConverts(source, expected); + Assert.Equal(expected, Converter.Convert(expected)); + Assert.Equal(withoutVocabulary, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + } + + [Theory] + [InlineData("Ele quebrou um galho.", "He did me a favor.", "Ele desenrascou.")] + [InlineData("Ele quebrou o galho.", "He broke the branch.", "Ele quebrou o galho.")] + [InlineData("Ele quebrou um galho.", "He helped cut a branch.", "Ele partiu um galho.")] + public void AdditionalWorkbookLiteralBranchesNeedReference(string source, string english, string expected) + { + var hint = ReferenceHint.FromText(english); + Assert.Equal(expected, Converter.Convert(source, null, hint)); + Assert.Equal(expected, Converter.Convert(expected, null, hint)); + } + + [Theory] + [InlineData("Ele salvou a criança.")] + [InlineData("Ela baixou a cabeça.")] + [InlineData("O arquivo histórico.")] + [InlineData("A segurança rodoviária.")] + [InlineData("A balada é uma canção.")] + [InlineData("A matéria está na mesa.")] + [InlineData("Uma prova do crime.")] + [InlineData("Boleto e atestado médico.")] + [InlineData("SUS e SNS.")] + [InlineData("Ficar a ver navios.")] + [InlineData("Dar o braço a torcer.")] + [InlineData("Ela mexerica sobre todos.")] + [InlineData("Puxou o assunto da reunião.")] + [InlineData("Eu escanteio o jogador.")] + [InlineData("O motor deu uma força de 30 newtons.")] + [InlineData("Ele é bonito para caramba.")] + public void AdditionalWorkbooksPreserveAmbiguousAndSharedTerms(string source) => + AssertConverts(source, source); + + [Fact] + public void AdditionalWorkbookMedicalParadaKeepsExistingTranslation() + { + AssertConverts("Contou uma parada cardíaca.", "Contou uma paragem cardíaca."); + AssertConverts("Contou umas paradas cardíacas.", "Contou umas paradas cardíacas."); + } + + [Fact] + public void AdditionalWorkbookLiteralSausageIsNotPluralized() + { + AssertConverts("Encheu linguiça com carne.", "Encheu chouriço com carne."); + var hint = ReferenceHint.FromText("He stuffed a sausage."); + Assert.Equal("Ele encheu chouriço.", Converter.Convert("Ele encheu linguiça.", null, hint)); + } + + [Fact] + public void AdditionalWorkbookDigitalFilesRespectStageSuppression() + { + Assert.Equal("Baixei um arquivo.", new PortugueseConverter( + new ConversionOptions(DisabledRules: "construction-vocabulary")).Convert("Baixei um arquivo.")); + } + + [Theory] + [InlineData("Ela puxou assunto.")] + [InlineData("Dei uma força.")] + [InlineData("Estou de saco cheio.")] + public void AdditionalWorkbookExpressionsRespectToggles(string source) + { + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Colloquial: false)).Convert(source)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(DisabledRules: "reference-idioms")).Convert(source)); + } + + [Theory] + [InlineData("Uma breja gelada.", "Uma cerveja gelada.")] + [InlineData("Duas brejas.", "Duas cervejas.")] + [InlineData("A bufunfa acabou.", "A massa acabou.")] + [InlineData("Vou pegar um busão.", "Vou apanhar um autocarro.")] + [InlineData("Os busões chegaram.", "Os autocarros chegaram.")] + [InlineData("Ela pegou um busão.", "Ela apanhou um autocarro.")] + [InlineData("Uma fita adesiva nova.", "Uma fita-cola nova.")] + [InlineData("As fitas adesivas.", "As fitas-cola.")] + [InlineData("O flanelinha chegou.", "O arrumador de carros chegou.")] + [InlineData("Os flanelinhas chegaram.", "Os arrumadores de carros chegaram.")] + [InlineData("Uma sunga nova.", "Um slip de banho novo.")] + [InlineData("As sungas novas.", "Os slips de banho novos.")] + [InlineData("Ele paquerou a Ana.", "Ele engatou a Ana.")] + [InlineData("Elas paqueravam.", "Elas engatavam.")] + [InlineData("Não paqueres.", "Não engates.")] + [InlineData("Uma meia-calça nova.", "Uns collants novos.")] + [InlineData("A meia-calça está rasgada.", "Os collants estão rasgados.")] + [InlineData("As meias-calças novas.", "Os collants novos.")] + [InlineData("Minha meia-calça está azul.", "Os meus collants estão azuis.")] + [InlineData("Aquela meia-calça velha.", "Aqueles collants velhos.")] + [InlineData("A meia-calça vermelha.", "Os collants vermelhos.")] + [InlineData("UMA FITA ADESIVA.", "UMA FITA-COLA.")] + public void VerifiedSpreadsheetVocabulary(string source, string expected) + { + AssertConverts(source, expected); + Assert.Equal(expected, Converter.Convert(expected)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + } + + [Theory] + [InlineData("A mensalidade da faculdade.", "A propina.")] + [InlineData("As mensalidades da faculdade.", "As propinas.")] + public void UniversityFeesAreNotConvertedToBribesInTheSameRun(string source, string expected) => + AssertConverts(source, expected); + + [Theory] + [InlineData("Vou dar um rolê.", "Vou dar uma volta.")] + [InlineData("Dei um rolezinho.", "Dei uma voltinha.")] + [InlineData("Demos uns rolês.", "Demos umas voltas.")] + [InlineData("DÁ UM ROLÊ!", "DÁ UMA VOLTA!")] + [InlineData("Vou dar um\nrolê.", "Vou dar uma\nvolta.")] + [InlineData("Ela trocou uma ideia com a Ana.", "Ela falou com a Ana.")] + [InlineData("Eles trocaram uma ideia.", "Eles falaram.")] + [InlineData("Vou trocar uma ideia.", "Vou falar.")] + [InlineData("Ela bateu um papo com a Ana.", "Ela falou com a Ana.")] + [InlineData("Nós batíamos papo.", "Nós conversávamos.")] + [InlineData("Paguei mico.", "Passei vergonha.")] + [InlineData("Ela pagou um mico.", "Ela passou vergonha.")] + [InlineData("Elas pagaram mico.", "Elas passaram vergonha.")] + [InlineData("Vou pagar mico.", "Vou passar vergonha.")] + [InlineData("PAGUEI MICO!", "PASSEI VERGONHA!")] + [InlineData("Ela pagou mico.", "Ela passou vergonha.")] + [InlineData("Ela estava pagando mico.", "Ela estava a passar vergonha.")] + [InlineData("Ela ficou de bobeira.", "Ela ficou sem fazer nada.")] + [InlineData("Elas ficaram de bobeira.", "Elas ficaram sem fazer nada.")] + [InlineData("Ele fala abobrinha.", "Ele fala disparates.")] + [InlineData("Eles falavam abobrinhas.", "Eles falavam disparates.")] + [InlineData("Tomei uma breja.", "Bebi uma cerveja.")] + [InlineData("Tomamos brejas.", "Bebemos cervejas.")] + [InlineData("Ele estava tomando uma breja.", "Ele estava a beber uma cerveja.")] + [InlineData("Ela tinha tomado uma breja.", "Ela tinha bebido uma cerveja.")] + [InlineData("Ela tinha pagado mico.", "Ela tinha passado vergonha.")] + [InlineData("Ele tinha dado um rolê.", "Ele tinha dado uma volta.")] + [InlineData("Ela estava trocando uma ideia.", "Ela estava a falar.")] + public void VerifiedSpreadsheetExpressions(string source, string expected) + { + AssertConverts(source, expected); + Assert.Equal(expected, Converter.Convert(expected)); + } + + [Theory] + [InlineData("Troquei uma ideia por outra.")] + [InlineData("Paguei o bilhete.")] + [InlineData("O mico subiu à árvore.")] + [InlineData("O bife rolê está pronto.")] + [InlineData("Errei de bobeira.")] + [InlineData("Falar de abobrinha.")] + [InlineData("Gatinho, mala, descarga, vitamina, grampo.")] + [InlineData("Uma flanelinha macia.")] + [InlineData("O pão-duro está na cozinha.")] + [InlineData("Estou com pressa.")] + [InlineData("Fazer uma vaquinha.")] + [InlineData("A água com gás.")] + [InlineData("A injeção e o preservativo.")] + public void SpreadsheetDoesNotIntroduceUnsafeLiteralReplacements(string source) => + AssertConverts(source, source); + + [Theory] + [InlineData("Vou dar um rolê.")] + [InlineData("Ela trocou uma ideia.")] + [InlineData("Paguei mico.")] + public void SpreadsheetExpressionsRespectDisabledGroups(string source) + { + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Colloquial: false)).Convert(source)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + } + + [Theory] + [InlineData("Ele é pão-duro.", "He's stingy.", "Ele é forreta.")] + [InlineData("São pães-duros.", "They're cheapskates.", "São forretas.")] + [InlineData("Um pão-duro.", "A kitchen spatula.", "Um pão-duro.")] + [InlineData("O pão está duro.", "The bread is hard.", "O pão está duro.")] + public void SpreadsheetAmbiguousSlangRequiresReference(string source, string english, string expected) + { + var hint = ReferenceHint.FromText(english); + Assert.Equal(expected, Converter.Convert(source, null, hint)); + Assert.Equal(expected, Converter.Convert(expected, null, hint)); + Assert.Equal(source, Converter.Convert(source)); + } + + [Fact] + public void SpreadsheetExpressionsRespectStageSuppressionAndTrace() + { + var trace = new List(); + Assert.Equal("Passei vergonha.", Converter.Convert("Paguei mico.", trace: trace)); + Assert.Contains(trace, r => r.Id == "reference-idioms"); + Assert.Equal("Paguei mico.", new PortugueseConverter( + new ConversionOptions(DisabledRules: "reference-idioms")).Convert("Paguei mico.")); + } + + [Theory] + [InlineData("Ned, quem você acha que vê isso?", "Ned, who do you think is actually watching this?", "Ned, quem achas que vê isto?")] + [InlineData("Quem você pensa que trabalha aqui?", "Who do you think works here?", "Quem pensas que trabalha aqui?")] + [InlineData("Quem você achava que ganhou?", "Who did you think won?", "Quem achavas que ganhou?")] + [InlineData("O que você acha que mudou?", "What do you think changed?", "O que achas que mudou?")] + [InlineData("Qual equipa você acha que ganha?", "Which team do you think wins?", "Qual equipa achas que ganha?")] + [InlineData("Quem tu imaginas que sabe?", "Who do you imagine knows?", "Quem tu imaginas que sabe?")] + [InlineData("Quem achas\nque vê isso?", "Who do you think sees this?", "Quem achas\nque vê isto?")] + [InlineData("QUEM VOCÊ ACHA QUE VÊ ISSO?", "Who do you think sees this?", "QUEM ACHAS QUE VÊ ISTO?")] + [InlineData("Quem você acha que chegou?", "Who do you think arrived?", "Quem achas que chegou?")] + [InlineData("Quem você acha que pode ajudar?", "Who do you think can help?", "Quem achas que pode ajudar?")] + [InlineData("Quem você acha que vai ganhar?", "Who do you think will win?", "Quem achas que vai ganhar?")] + [InlineData("Quem você acha que vê? Você sabe que chegou.", "Who do you think sees? You know you arrived.", "Quem achas que vê? Sabes que chegaste.")] + [InlineData("Quem você acredita que chegou?", "Who do you believe arrived?", "Quem acreditas que chegou?")] + [InlineData("Quem você disse que viu isso?", "Who did you say saw this?", "Quem disseste que viu isto?")] + [InlineData("Quem você acha que realmente vê isso?", "Who do you think actually sees this?", "Quem achas que realmente vê isto?")] + public void ExtractedQuestionDoesNotMakeEmbeddedSubjectSecondPerson(string source, string english, string expected) + { + var hint = ReferenceHint.FromText(english); + Assert.Equal(expected, Converter.Convert(source, null, hint)); + Assert.Equal(expected, Converter.Convert(expected, null, hint)); + } + + [Theory] + [InlineData("Quem você acha que viu?", "Who do you think you saw?", "Quem achas que viste?")] + [InlineData("O que você pensa que fez?", "What do you think you did?", "O que pensas que fizeste?")] + [InlineData("Quem você acha que pode ajudar?", "Who do you think you can help?", "Quem achas que podes ajudar?")] + [InlineData("Quem você acha que você vê?", "Who do you think you see?", "Quem achas que vês?")] + [InlineData("Quem você disse que viu?", "Who did you say you saw?", "Quem disseste que viste?")] + [InlineData("Onde você acha que trabalhou?", "Where do you think you worked?", "Onde achas que trabalhaste?")] + [InlineData("Por que você acha que fez isso?", "Why do you think you did this?", "Porque achas que fizeste isto?")] + public void ExtractedObjectsKeepConfirmedSecondPersonSubject(string source, string english, string expected) + { + var hint = ReferenceHint.FromText(english); + Assert.Equal(expected, Converter.Convert(source, null, hint)); + Assert.Equal(expected, Converter.Convert(expected, null, hint)); + } + + [Theory] + [InlineData("Quem você acha que pode ajudar?", "Quem achas que pode ajudar?")] + [InlineData("Quem você pensa que consegue ganhar?", "Quem pensas que consegue ganhar?")] + public void AmbiguousExtractedQuestionsDoNotAssumeSubjectContinuity(string source, string expected) => + AssertConverts(source, expected); + + [Fact] + public void ExtractedQuestionGuardRespectsAddressOptionsWithoutDependingOnColloquial() + { + const string source = "Ned, quem você acha que vê isso?"; + var hint = ReferenceHint.FromText("Ned, who do you think is actually watching this?"); + Assert.Equal("Ned, quem achas que vê isto?", + new PortugueseConverter(new ConversionOptions(Colloquial: false)).Convert(source, null, hint)); + Assert.Equal("Ned, quem acha que vê isto?", + Converter.Convert(source, null, hint! with { FormalAddress = true })); + Assert.Equal("Ned, quem você acha que vê isto?", + new PortugueseConverter(new ConversionOptions(YouToTu: false)).Convert(source, null, hint)); + } + + [Theory] + [InlineData("Sabe o que aconteceu ontem?", "You know what happened yesterday?", "Sabes o que aconteceu ontem?")] + [InlineData("Sabe o que é aquilo?", "You know what that is?", "Sabes o que é aquilo?")] + [InlineData("Sabe o que era aquilo?", "You know what that was?", "Sabes o que era aquilo?")] + [InlineData("Sabe o que está acontecendo?", "You know what's happening?", "Sabes o que está a acontecer?")] + [InlineData("O que está acontecendo?", "What are you doing?", "O que está a acontecer?")] + [InlineData("O que é isso?", "What are you doing?", "O que é isso?")] + [InlineData("Acha que sabe o que aconteceu?", "You think you know what happened?", "Achas que sabes o que aconteceu?")] + [InlineData("Sabe o\nque aconteceu ontem?", "You know what happened yesterday?", "Sabes o\nque aconteceu ontem?")] + [InlineData("SABE O QUE ACONTECEU ONTEM?", "You know what happened yesterday?", "SABES O QUE ACONTECEU ONTEM?")] + public void ReferenceDoesNotTreatEmbeddedWhatAsYou(string source, string english, string expected) + { + var hint = ReferenceHint.FromText(english); + Assert.Equal(expected, Converter.Convert(source, null, hint)); + Assert.Equal(expected, Converter.Convert(expected, null, hint)); + var noYou = new PortugueseConverter(new ConversionOptions(YouToTu: false)); + Assert.Equal(noYou.Convert(source), noYou.Convert(source, null, hint)); + } + + [Theory] + [InlineData("Se isso me preocupa, eu paro.")] + [InlineData("Se isto te assusta, espera.")] + [InlineData("Quando aquilo me preocupa, eu paro.")] + [InlineData("Não sei aonde isso me leva.")] + [InlineData("Se isso\nme preocupa, eu paro.")] + [InlineData("Se isso me preocupa, eu paro. Isso preocupa-me.")] + public void DemonstrativeSubjectsPreserveSubordinateProclisis(string text) => + Assert.Equal(text, Converter.Convert(text)); + + [Theory] + [InlineData("Isso me preocupa.", "Isso preocupa-me.")] + [InlineData("Isto me assusta.", "Isto assusta-me.")] + [InlineData("Eu sei que isso me preocupa.", "Eu sei que isso me preocupa.")] + public void DemonstrativeSubjectsStillUseMainClauseEnclisis(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Pronouns: false)).Convert(source)); + } + + [Theory] + [InlineData("Nos últimos quatro dias.")] + [InlineData("Nos próximos meses.")] + [InlineData("Nos péssimos resultados.")] + [InlineData("NOS ÚLTIMOS QUATRO DIAS.")] + [InlineData("Nos\núltimos quatro dias.")] + public void ContractedNosBeforeAdjectivesIsNotAClitic(string text) + { + Assert.Equal(text, Converter.Convert(text)); + } + + [Theory] + [InlineData("Nos vemos amanhã.", "Vemo-nos amanhã.")] + [InlineData("Nos encontramos amanhã.", "Encontramo-nos amanhã.")] + [InlineData("Nos diga a verdade.", "Diz-nos a verdade.")] + public void LeadingNosStillAttachesToRecognizedVerbs(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + } + + [Theory] + [InlineData("Que doideira!", "Que loucura!")] + [InlineData("São doideiras.", "São loucuras.")] + [InlineData("Vambora!", "Vamos embora!")] + [InlineData("VAMBORA!", "VAMOS EMBORA!")] + [InlineData("Bora lá!", "Bora lá!")] + public void AdditionalBrazilianSlangUsesEuropeanEquivalents(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + Assert.Equal(source, new PortugueseConverter(new ConversionOptions(Vocabulary: false)).Convert(source)); + } + + [Theory] + [InlineData("Este é o detetive que falei para vocês.", "Este é o detetive de que vos falei.")] + [InlineData("Esta é a professora que falei para ela.", "Esta é a professora de que lhe falei.")] + [InlineData("Esse é o livro que falei para nós.", "Esse é o livro de que nos falei.")] + [InlineData("Este é o detetive que\nfalei para vocês.", "Este é o detetive de que\nvos falei.")] + public void RelativeFalarUsesPrepositionAndDative(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + } + + [Theory] + [InlineData("Eu alcanço vocês depois.", "I'll catch you guys later.", "Eu depois apanho-vos.")] + [InlineData("Alcanço você mais tarde.", "I'll catch you later.", "Depois apanho-te.")] + [InlineData("Eu alcanço vocês depois.", "I reach you later.", "Eu alcanço vocês depois.")] + public void CatchUpLaterUsesReferenceIdiom(string source, string english, string expected) => + Assert.Equal(expected, Converter.Convert(source, null, ReferenceHint.FromText(english))); + + [Theory] + [InlineData("Vamos pegar este cara.", "Vamos apanhar este tipo.")] + [InlineData("Pegou o suspeito.", "Apanhou o suspeito.")] + [InlineData("Peguem esses criminosos.", "Apanhem esses criminosos.")] + [InlineData("Pegaremos aquela fugitiva.", "Apanharemos aquela fugitiva.")] + [InlineData("Não peguei nenhum suspeito.", "Não apanhei nenhum suspeito.")] + [InlineData("Vamos pegar este tipo de arma.", "Vamos pegar neste tipo de arma.")] + [InlineData("Pega a arma.", "Pega na arma.")] + [InlineData("Vou pegar uma bebida.", "Vou buscar uma bebida.")] + [InlineData("Vamos pegar\neste cara.", "Vamos apanhar\neste tipo.")] + public void CatchPeopleKeepsObjectAndVerbInflection(string source, string expected) + { + Assert.Equal(expected, Converter.Convert(source)); + Assert.Equal(expected, Converter.Convert(expected)); + } + + [Theory] + [InlineData("A gente sempre escuta,", "You just hear about this stuff.", "Ouvimos sempre,")] + [InlineData("A gente sempre escuta sobre estas coisas.", null, "Ouvimos sempre sobre estas coisas.")] + [InlineData("Nós escutamos sempre sobre estas coisas.", null, "Nós ouvimos sempre sobre estas coisas.")] + [InlineData("Ela escutou sobre o acidente.", null, "Ela ouviu sobre o acidente.")] + [InlineData("Escutarei sobre isso.", null, "Ouvirei sobre isso.")] + [InlineData("A gente sempre escutava.", "We always heard about it.", "Ouvíamos sempre.")] + [InlineData("A gente sempre escuta música.", "We always listen to music.", "Escutamos sempre música.")] + [InlineData("Escute com atenção.", "Listen carefully.", "Escuta com atenção.")] + [InlineData("A gente nunca escuta.", "We never listen.", "Nunca escutamos.")] + [InlineData("A gente sempre se lembra.", null, "Sempre nos lembramos.")] + [InlineData("A gente sempre escuta,", null, "Escutamos sempre,")] + public void HearingAboutDiffersFromDeliberateListening(string source, string? english, string expected) + { + var hint = ReferenceHint.FromText(english); + Assert.Equal(expected, Converter.Convert(source, null, hint)); + Assert.Equal(expected, Converter.Convert(expected, null, hint)); + } + + [Theory] + [InlineData("e o síndico lhe disse que", "e o encarregado do edifício disse-lhe que")] + [InlineData("Nossa força-tarefa\nvai responder cada ligação,", "A nossa equipa especial\nvai responder cada chamada,")] + [InlineData("Me coloque na\nespera, que espero.", "Põe-me em\nespera, que espero.")] + [InlineData("Me coloque na espera.", "Põe-me em espera.")] + [InlineData("Coloca-me na espera.", "Põe-me em espera.")] + [InlineData("Ponha-o na espera.", "Põe-no em espera.")] + [InlineData("Ficou na espera do autocarro.", "Ficou na espera do autocarro.")] + [InlineData("Ele usa um terno.", "Ele usa um fato.")] + [InlineData("Os maiôs.", "Os fatos de banho.")] + [InlineData("Qual é o seu sobrenome?", "Qual é o teu apelido?")] + [InlineData("Vamos ao shopping.", "Vamos ao centro comercial.")] + [InlineData("Chega de papos.", "Chega de conversas.")] + [InlineData("A síndica chegou.", "A encarregada do edifício chegou.")] + public void SinglePassReachesFinalResult(string br, string pt) => AssertConverts(br, pt); + + // Re-running cannot distinguish PT-PT fato/apelido/propina from their different Brazilian senses. + private static readonly Regex AmbiguousOnRerun = new( + @"(? AssertConverts(br, pt); + + [Theory] + [InlineData("e o síndico lhe disse que")] + [InlineData("Nossa força-tarefa\nvai responder cada ligação,")] + [InlineData("Me coloque na\nespera, que espero.")] + public void ReportedCuesAreStableWhenConvertedAgain(string br) + { + var once = Converter.Convert(br); + Assert.Equal(once, Converter.Convert(once)); + } + + [Fact] + public void ConvertingAgainChangesNothingForAllRegressionExamples() + { + var unstable = new List(); + foreach (var method in typeof(ConverterTests).GetMethods()) + { + foreach (var data in method.GetCustomAttributes(typeof(InlineDataAttribute), false).Cast()) + { + var args = data.GetData(method).Single(); + if (args.Length < 1 || args[0] is not string input) + { + continue; + } + + var once = Converter.Convert(input); + if (AmbiguousOnRerun.IsMatch(once)) + { + continue; + } + + var twice = Converter.Convert(once); + if (once != twice) + { + unstable.Add($"{method.Name}: \"{input}\" → \"{once}\" → \"{twice}\""); + } + } + } + + Assert.True(unstable.Count == 0, string.Join(Environment.NewLine, unstable)); + } + + [Theory] + [InlineData("- Como posso ajudá-lo?\n- Estamos entrando. Se afaste.", + "- Como posso ajudá-lo?\n- Estamos a entrar. Afasta-te.")] + [InlineData("Se afaste.", "Afasta-te.")] + [InlineData("Se afastem da porta!", "Afastem-se da porta!")] + [InlineData("Se aproxime.", "Aproxima-te.")] + [InlineData("Se sente.", "Sente-se.")] + [InlineData("Se levante!", "Levanta-te!")] + [InlineData("Se prepare para sair.", "Prepara-te para sair.")] + [InlineData("Se proteja.", "Protege-te.")] + [InlineData("Se esconda.", "Esconde-te.")] + [InlineData("Se acalme.", "Acalma-te.")] + [InlineData("SE AFASTE!", "AFASTA-TE!")] + [InlineData("Se afaste.", "Afasta-te.")] + [InlineData("Afaste-se.", "Afasta-te.")] + [InlineData("Não se afaste.", "Não te afastes.")] + [InlineData("Espero que se afaste.", "Espero que se afaste.")] + [InlineData("Talvez se afaste.", "Talvez se afaste.")] + [InlineData("Se afaste o perigo, ficamos aqui.", "Se afaste o perigo, ficamos aqui.")] + [InlineData("Se afaste ele, esperamos.", "Se afaste ele, esperamos.")] + [InlineData("Se sente dor, fale.", "Se sente dor, fale.")] + [InlineData("Se sente dor.", "Se sente dor.")] + public void ReflexiveImperativePlacement(string br, string pt) => AssertConverts(br, pt); + + [Fact] + public void ReflexiveImperativesRespectOptionsAndIgnoredPhrases() + { + Assert.Equal("Se afaste.", new PortugueseConverter(new ConversionOptions(Pronouns: false)).Convert("Se afaste.")); + var local = new PortugueseLocalWordList(); + local.Ignored.Add("Se afaste"); + Assert.Equal("Se afaste.", new PortugueseConverter(localWordList: local).Convert("Se afaste.")); + } + + [Theory] + [InlineData("Precisamos falar com\nseu marido. Ele está em casa?", "Precisamos de falar com\no seu marido. Ele está em casa?")] + [InlineData("Sua mulher. Ela está em casa?", "A sua mulher. Ela está em casa?")] + [InlineData("Já lhe mandei suas coisas.", "Já lhe mandei as suas coisas.")] + [InlineData("Já lhes entreguei seus livros.", "Já lhes entreguei os seus livros.")] + [InlineData("Preciso do seu contato.", "Preciso do teu contacto.")] + [InlineData("Você esqueceu suas coisas.", "Esqueceste as tuas coisas.")] + public void CueLevelPossessiveContext(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("- Já até mandei suas coisas.\n- Para onde?", "- Até, já lhe mandei as suas coisas.\n- Para onde?")] + [InlineData("Já até enviei suas coisas.", "Até, já lhe enviei as suas coisas.")] + [InlineData("Já devolvi seus livros.", "Já devolvi os seus livros.")] + [InlineData("Já mandei suas roupas.", "Já mandei as suas roupas.")] + public void PreviousCuePossessiveContext(string br, string pt) + { + Assert.Equal(pt, Converter.Convert(br, "E me divorciando do cretino.")); + } + + [Fact] + public void PreviousContextDoesNotMutateConverterState() + { + const string text = "Já mandei suas roupas."; + Assert.Equal("Já mandei as suas roupas.", Converter.Convert(text, "E me divorciando do cretino.")); + Assert.Equal("Já mandei as tuas roupas.", Converter.Convert(text)); + Assert.Equal("Esqueceste as tuas coisas.", Converter.Convert("Você esqueceu suas coisas.", "E me divorciando do cretino.")); + } + + [Theory] + [InlineData("E me divorciando do cretino.", "E a divorciar-me do cretino.")] + [InlineData("E me preparando.", "E a preparar-me.")] + [InlineData("Ou me escondendo.", "Ou a esconder-me.")] + [InlineData("E trabalhando em casa.", "E a trabalhar em casa.")] + [InlineData("E pensando nisso.", "E pensando nisso.")] + [InlineData("Por que está me olhando?\nEntra no carro, vai.", + "Porque estás a olhar para mim?\nEntra no carro, vá.")] + [InlineData("Por que está trabalhando?", "Porque estás a trabalhar?")] + [InlineData("Como consegue fazer isso?", "Como consegues fazer isso?")] + [InlineData("Por que ela está me olhando?", "Porque ela está a olhar para mim?")] + [InlineData("Estou te olhando.", "Estou a olhar para ti.")] + [InlineData("Estão nos olhando.", "Estão a olhar para nós.")] + [InlineData("Estou me olhando.", "Estou a olhar para mim.")] + [InlineData("Entra no carro, vai.", "Entra no carro, vá.")] + [InlineData("Anda, vai!", "Anda, vá!")] + [InlineData("Ele vai.", "Ele vai.")] + [InlineData("Entra no carro, vai buscar ajuda.", "Entra no carro, vai buscar ajuda.")] + [InlineData("Ele entra no carro, vai.", "Ele entra no carro, vai.")] + public void CoordinatedGerundsAndLookAtQuestions(string br, string pt) => AssertConverts(br, pt); + + [Fact] + public void NewProgressivePatternsRespectOptions() + { + var converter = new PortugueseConverter(new ConversionOptions(Progressive: false)); + Assert.Equal("E me divorciando do cretino.", converter.Convert("E me divorciando do cretino.")); + converter = new PortugueseConverter(new ConversionOptions(YouToTu: false)); + Assert.Equal("Porque está a olhar para mim?", converter.Convert("Por que está me olhando?")); + converter = new PortugueseConverter(new ConversionOptions(Colloquial: false)); + Assert.Equal("Entra no carro, vai.", converter.Convert("Entra no carro, vai.")); + } + + [Theory] + [InlineData("Agora, seu irmão Tiago,\npor outro lado...", "Agora, o teu irmão Tiago,\npor outro lado...")] + [InlineData("Agora, sua irmã Maria,", "Agora, a tua irmã Maria,")] + [InlineData("Entretanto, seus irmãos,", "Entretanto, os teus irmãos,")] + [InlineData("No entanto, suas irmãs,", "No entanto, as tuas irmãs,")] + [InlineData("Por outro lado, meu carro...", "Por outro lado, o meu carro...")] + [InlineData("Agora, nossa casa,", "Agora, a nossa casa,")] + [InlineData("Agora, nossos carros,", "Agora, os nossos carros,")] + [InlineData("- Agora, seu irmão Tiago,", "- Agora, o teu irmão Tiago,")] + [InlineData("Agora, seu irmão Tiago,", "Agora, o teu irmão Tiago,")] + [InlineData("AGORA, SEU IRMÃO TIAGO,", "AGORA, O TEU IRMÃO TIAGO,")] + [InlineData("Agora, o teu irmão Tiago,", "Agora, o teu irmão Tiago,")] + [InlineData("Agora, meu amigo, ouve.", "Agora, meu amigo, ouve.")] + [InlineData("Agora, meu Deus!", "Agora, meu Deus!")] + [InlineData("Doutor, agora, seu irmão Tiago,", "Doutor, agora, seu irmão Tiago,")] + public void IntroductoryPossessiveArticles(string br, string pt) => AssertConverts(br, pt); + + [Fact] + public void IntroductoryPossessiveArticlesRespectDisabledPronouns() + { + var converter = new PortugueseConverter(new ConversionOptions(Pronouns: false)); + Assert.Equal("Agora, teu irmão Tiago,", converter.Convert("Agora, seu irmão Tiago,")); + } + + [Theory] + [InlineData("Lembra quando me perguntou", "Lembras-te quando me perguntaste")] + [InlineData("Lembra quando me perguntou?", "Lembras-te quando me perguntaste?")] + [InlineData("Lembra quando me disse isso?", "Lembras-te quando me disseste isso?")] + [InlineData("Lembra quando me ajudou?", "Lembras-te quando me ajudaste?")] + [InlineData("Lembra quando me viu?", "Lembras-te quando me viste?")] + [InlineData("Lembra quando nos trouxe comida?", "Lembras-te quando nos trouxeste comida?")] + [InlineData("Lembra quando me telefonou?", "Lembras-te quando me telefonaste?")] + [InlineData("Lembras-te quando me perguntou?", "Lembras-te quando me perguntaste?")] + [InlineData("- Lembra quando me perguntou\nse eu estava vendo alguém?", + "- Lembras-te quando me perguntaste\nse eu estava a ver alguém?")] + [InlineData("Lembra quando me perguntou?", "Lembras-te quando me perguntaste?")] + [InlineData("LEMBRA QUANDO ME PERGUNTOU?", "LEMBRAS-TE QUANDO ME PERGUNTASTE?")] + [InlineData("Ele lembra quando me perguntou.", "Ele lembra quando me perguntou.")] + [InlineData("Lembra quando ela me perguntou?", "Lembras-te quando ela me perguntou?")] + [InlineData("Lembra quando me perguntou ela?", "Lembras-te quando me perguntou ela?")] + [InlineData("Doutor, lembra quando me perguntou?", "Doutor, lembra quando me perguntou?")] + [InlineData("Lembras-te quando me perguntaste?", "Lembras-te quando me perguntaste?")] + public void RememberWhenAgreement(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("É a gente.", "Somos nós.")] + [InlineData("Não é a gente.", "Não somos nós.")] + [InlineData("Foi a gente!", "Fomos nós!")] + [InlineData("Era a gente.", "Éramos nós.")] + [InlineData("Será a gente?", "Seremos nós?")] + [InlineData("Seria a gente.", "Seríamos nós.")] + [InlineData("Espero que seja a gente.", "Espero que sejamos nós.")] + [InlineData("Se fosse a gente.", "Se fôssemos nós.")] + [InlineData("Se for a gente.", "Se formos nós.")] + [InlineData("- É a gente.", "- Somos nós.")] + [InlineData("É a gente.", "Somos nós.")] + [InlineData("É A GENTE!", "SOMOS NÓS!")] + [InlineData("É\na gente.", "Somos\nnós.")] + [InlineData("É a gente da aldeia.", "É a gente da aldeia.")] + [InlineData("É a gente que vive aqui.", "É a gente que vive aqui.")] + [InlineData("É toda a gente.", "É toda a gente.")] + [InlineData("Somos nós.", "Somos nós.")] + public void WeIdentityAgreement(string br, string pt) => AssertConverts(br, pt); + + [Fact] + public void NewAgreementRulesRespectOptionsAndIgnoredPhrases() + { + var converter = new PortugueseConverter(new ConversionOptions(Colloquial: false, YouToTu: false)); + Assert.Equal("É a gente.", converter.Convert("É a gente.")); + Assert.Equal("Lembra quando me perguntou?", converter.Convert("Lembra quando me perguntou?")); + var local = new PortugueseLocalWordList(); + local.Ignored.Add("É a gente"); + local.Ignored.Add("Lembra quando me perguntou"); + converter = new PortugueseConverter(localWordList: local); + Assert.Equal("É a gente.", converter.Convert("É a gente.")); + Assert.Equal("Lembra quando me perguntou?", converter.Convert("Lembra quando me perguntou?")); + } + + [Theory] + [InlineData("Parabéns a suas famílias,", "Parabéns às vossas famílias,")] + [InlineData("Parabéns às suas famílias!", "Parabéns às vossas famílias!")] + [InlineData("PARABÉNS A SUAS FAMÍLIAS!", "PARABÉNS ÀS VOSSAS FAMÍLIAS!")] + [InlineData("Parabéns a sua família.", "Parabéns a tua família.")] + [InlineData("As suas famílias estão bem.", "As tuas famílias estão bem.")] + [InlineData("- Sabe como é a ponte a essa hora.\n- Sei, estou indo.", + "- Sabes como é a ponte a esta hora.\n- Sei, estou a ir.")] + [InlineData("Sabe como é a ponte a esta hora.", "Sabes como é a ponte a esta hora.")] + [InlineData("Sabe como é.", "Sabes como é.")] + [InlineData("SABE COMO É.", "SABES COMO É.")] + [InlineData("Ele sabe como é a ponte.", "Ele sabe como é a ponte.")] + [InlineData("A mãe sabe como é a ponte.", "A mãe sabe como é a ponte.")] + [InlineData("Sabe ela como é a ponte?", "Sabe ela como é a ponte?")] + [InlineData("Doutor, sabe como é a ponte.", "Doutor, sabe como é a ponte.")] + public void FamilyCongratulationsAndKnowHow(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("Tu sabe como é.", "Tu sabes como é.")] + [InlineData("Tu tem razão.", "Tu tens razão.")] + [InlineData("Tu fez isso.", "Tu fizeste isso.")] + [InlineData("Tu não se lembra.", "Tu não te lembras.")] + [InlineData("Tu fala português.", "Tu falas português.")] + [InlineData("Tu já comeu.", "Tu já comeste.")] + [InlineData("Tu sabe e ele sabe.", "Tu sabes e ele sabe.")] + [InlineData("Tu programou isso.", "Tu programaste isso.")] + [InlineData("Tu programaste isso.", "Tu programaste isso.")] + [InlineData("Tu sabes como é.", "Tu sabes como é.")] + [InlineData("Tu és doente.", "Tu és doente.")] + [InlineData("TU SABE.", "TU SABES.")] + [InlineData("Você mantém a calma.", "Manténs a calma.")] + [InlineData("Você deteve o homem.", "Detiveste o homem.")] + [InlineData("Você obtiver ajuda.", "Obtiveres ajuda.")] + [InlineData("Você prevê problemas.", "Prevês problemas.")] + [InlineData("Você previu problemas.", "Previste problemas.")] + [InlineData("Você refaz o trabalho.", "Refazes o trabalho.")] + [InlineData("Você desfez isso.", "Desfizeste isso.")] + [InlineData("Você satisfaz o cliente.", "Satisfazes o cliente.")] + public void BroaderSecondPersonAgreement(string br, string pt) => AssertConverts(br, pt); + + [Fact] + public void AddressCorrectionsRespectDisabledOption() + { + var converter = new PortugueseConverter(new ConversionOptions(YouToTu: false)); + Assert.Equal("Parabéns a suas famílias.", converter.Convert("Parabéns a suas famílias.")); + Assert.Equal("Sabe como é.", converter.Convert("Sabe como é.")); + Assert.Equal("Tu sabe como é.", converter.Convert("Tu sabe como é.")); + } + + [Theory] + [InlineData("programou", "programaste")] + [InlineData("programava", "programavas")] + [InlineData("programasse", "programasses")] + [InlineData("programará", "programarás")] + [InlineData("programaria", "programarias")] + [InlineData("programar", "programares")] + [InlineData("traduziu", "traduziste")] + public void DictionaryValidatedInflections(string third, string second) + { + Assert.True(PortugueseVerbs.TryGuessThirdToSecond(third, out var result)); + Assert.Equal(second, result); + } + + [Fact] + public void UnknownInflectionsAreNotInvented() + { + Assert.False(PortugueseVerbs.TryGuessThirdToSecond("zzzzou", out _)); + Assert.Equal("Você zzzzou.", Converter.Convert("Você zzzzou.")); + } + + [Theory] + [InlineData("Enfiou minha cabeça na privada!", "Enfiou a minha cabeça na sanita!")] + [InlineData("A privada está suja.", "A sanita está suja.")] + [InlineData("As privadas estão entupidas.", "As sanitas estão entupidas.")] + [InlineData("NA PRIVADA!", "NA SANITA!")] + [InlineData("A vida privada.", "A vida privada.")] + [InlineData("Uma empresa privada.", "Uma empresa privada.")] + [InlineData("Foi privada de liberdade.", "Foi privada de liberdade.")] + [InlineData("A privada empresa fechou.", "A privada empresa fechou.")] + [InlineData("O vaso sanitário.", "A sanita.")] + [InlineData("Os vasos sanitários.", "As sanitas.")] + [InlineData("Água sanitária.", "Lixívia.")] + [InlineData("O botijão de gás.", "A botija de gás.")] + [InlineData("Os botijões de gás.", "As botijas de gás.")] + [InlineData("A pia da cozinha.", "O lava-loiça da cozinha.")] + [InlineData("A pia do banheiro.", "O lavatório da casa de banho.")] + [InlineData("Dar descarga.", "Puxar o autoclismo.")] + [InlineData("Uma máquina de lavar louças.", "Uma máquina de lavar loiça.")] + [InlineData("A cômoda.", "A cómoda.")] + [InlineData("Os grampos de papel.", "Os agrafos.")] + [InlineData("Os grampos de cabelo.", "Os ganchos de cabelo.")] + [InlineData("Os maiôs.", "Os fatos de banho.")] + [InlineData("Cadarços e zíperes.", "Atacadores e fechos-éclair.")] + [InlineData("Esmalte de unhas.", "Verniz das unhas.")] + [InlineData("Revistas em quadrinhos.", "Revistas de banda desenhada.")] + [InlineData("Dubladores e dubladoras.", "Atores de dobragem e atrizes de dobragem.")] + [InlineData("Academia de ginástica.", "Ginásio.")] + [InlineData("A academia de ciências.", "A academia de ciências.")] + [InlineData("O acostamento.", "A berma.")] + [InlineData("Os acostamentos.", "As bermas.")] + [InlineData("Rotatórias e conversíveis.", "Rotundas e descapotáveis.")] + [InlineData("Um misto quente.", "Uma tosta mista.")] + [InlineData("Os mistos quentes.", "As tostas mistas.")] + [InlineData("O boteco.", "A tasca.")] + [InlineData("Os caquis e as berinjelas.", "Os dióspiros e as beringelas.")] + [InlineData("Calças caqui.", "Calças caqui.")] + [InlineData("Abobrinha grelhada.", "Curgete grelhada.")] + [InlineData("Falar abobrinha.", "Falar disparates.")] + [InlineData("A farinha de rosca.", "O pão ralado.")] + [InlineData("Leite integral.", "Leite gordo.")] + [InlineData("As balas de menta.", "Os rebuçados de menta.")] + [InlineData("Uma bala de goma.", "Uma goma.")] + [InlineData("A bala atingiu a parede.", "A bala atingiu a parede.")] + [InlineData("O canudo de plástico.", "A palhinha de plástico.")] + [InlineData("O canudo do diploma.", "O canudo do diploma.")] + [InlineData("Um resfriado.", "Uma constipação.")] + [InlineData("O motor resfriado.", "O motor resfriado.")] + [InlineData("Os ônibus escolares.", "Os autocarros escolares.")] + [InlineData("Absorventes higiênicos.", "Pensos higiénicos.")] + [InlineData("Esparadrapos e bandeides.", "Adesivos e pensos rápidos.")] + public void ExpandedVocabulary(string br, string pt) => AssertConverts(br, pt); + + [Fact] + public void ExpandedVocabulary_RespectsDisabledVocabulary() + { + var converter = new PortugueseConverter(new ConversionOptions(Vocabulary: false)); + Assert.Equal("Na privada. Água sanitária. Cadarços.", converter.Convert("Na privada. Água sanitária. Cadarços.")); + } + + [Theory] + [InlineData("É um fato.", "É um facto.")] + [InlineData("Os fatos são claros.", "Os factos são claros.")] + [InlineData("Ele é muito econômico.", "Ele é muito económico.")] + [InlineData("Qual é o gênero do filme?", "Qual é o género do filme?")] + [InlineData("O fenômeno é anônimo.", "O fenómeno é anónimo.")] + [InlineData("Uma atitude acadêmica.", "Uma atitude académica.")] + [InlineData("O bebê está dormindo.", "O bebé está a dormir.")] + [InlineData("Venha conosco.", "Vem connosco.")] + [InlineData("Ele tem dezesseis anos.", "Ele tem dezasseis anos.")] + [InlineData("Preciso do seu contato.", "Preciso do teu contacto.")] + [InlineData("Faça o registro.", "Faz o registo.")] + [InlineData("Estamos planejando a viagem.", "Estamos a planear a viagem.")] + [InlineData("Ele tem uma conseqüência.", "Ele tem uma consequência.")] + [InlineData("Uma idéia heróica.", "Uma ideia heroica.")] + [InlineData("ECONÔMICO", "ECONÓMICO")] + [InlineData("Ele está no estômago.", "Ele está no estômago.")] + [InlineData("Eles têm ciência disso.", "Eles têm ciência disso.")] + [InlineData("O cônjuge dele.", "O cônjuge dele.")] + public void Spelling(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("Vamos pegar o ônibus.", "Vamos apanhar o autocarro.")] + [InlineData("Os ônibus estão atrasados.", "Os autocarros estão atrasados.")] + [InlineData("O trem chegou.", "O comboio chegou.")] + [InlineData("Me liga no celular.", "Liga-me no telemóvel.")] + [InlineData("Onde fica o banheiro?", "Onde fica a casa de banho?")] + [InlineData("A geladeira está vazia.", "O frigorífico está vazio.")] + [InlineData("Uma geladeira nova.", "Um frigorífico novo.")] + [InlineData("O nosso time ganhou.", "A nossa equipa ganhou.")] + [InlineData("Não tenho tempo.", "Não tenho tempo.")] + [InlineData("Olha a tela.", "Olha o ecrã.")] + [InlineData("Ele pegou o trem.", "Ele apanhou o comboio.")] + [InlineData("Pegue o próximo ônibus.", "Apanha o próximo autocarro.")] + [InlineData("Pega a caneta.", "Pega na caneta.")] + [InlineData("Ônibus", "Autocarro")] + [InlineData("Comi um cachorro-quente.", "Comi um cachorro-quente.")] + public void Vocabulary(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("E essa saia? Sério?", "E essa saia? A sério?")] + [InlineData("Sério mesmo?", "A sério?")] + [InlineData("Sério, eu juro.", "A sério, eu juro.")] + [InlineData("Isso é sério.", "Isso é sério.")] + [InlineData("Falando sério, vamos embora.", "A sério, vamos embora.")] + [InlineData("Tchau, mãe.", "Adeus, mãe.")] + [InlineData("Que saco!", "Que seca!")] + [InlineData("Fica frio.", "Tem calma.")] + [InlineData("De jeito nenhum!", "De maneira nenhuma!")] + [InlineData("- Detetive, posso falar com você?", "- Detetive, posso falar consigo?")] + [InlineData("Senhor, isto é para você.", "Senhor, isto é para si.")] + [InlineData("Doutor, você está bem?", "Doutor, está bem?")] + [InlineData("Senhora, você se lembra?", "Senhora, lembra-se?")] + [InlineData("Posso falar com você?", "Posso falar contigo?")] + [InlineData("e o síndico disse-lhe que", "e o encarregado do edifício disse-lhe que")] + [InlineData("viu alguns miúdos pegarem", "viu alguns miúdos a pegar")] + [InlineData("Vi o homem correndo.", "Vi o homem a correr.")] + [InlineData("Eles querem que vocês vejam.", "Eles querem que vocês vejam.")] + [InlineData("Ele saiu correndo.", "Ele saiu a correr.")] + [InlineData("Passei o dia trabalhando.", "Passei o dia a trabalhar.")] + [InlineData("Ele acabou ficando.", "Ele acabou por ficar.")] + [InlineData("Pega o meu casaco.", "Pega no meu casaco.")] + [InlineData("A polícia pegou-o.", "A polícia apanhou-o.")] + [InlineData("Ele foi pego.", "Ele foi apanhado.")] + [InlineData("Ela pegou uma gripe.", "Ela apanhou uma gripe.")] + [InlineData("A casa vai pegar fogo.", "A casa vai pegar fogo.")] + [InlineData("Chama o encanador.", "Chama o canalizador.")] + [InlineData("Que bagunça!", "Que confusão!")] + [InlineData("Ele usa um terno.", "Ele usa um fato.")] + [InlineData("Isso é fofoca.", "Isso é mexerico.")] + [InlineData("Ele pega a estrada todo dia.", "Ele apanha a estrada todo dia.")] + [InlineData("Passou correndo por mim.", "Passou a correr por mim.")] + [InlineData("E aí, beleza?", "Então, tudo bem?")] + [InlineData("A beleza dela?", "A beleza dela?")] + [InlineData("Ouvi eles cantando.", "Ouvi-os a cantar.")] + [InlineData("O senhor quer café? Você quer?", "O senhor quer café? Quer?")] + [InlineData("- Meu bebé!\n- Tudo bem!", "- O meu bebé!\n- Está tudo bem!")] + [InlineData("Minha casa!", "A minha casa!")] + [InlineData("Meu Deus!", "Meu Deus!")] + [InlineData("Meu amor!", "Meu amor!")] + [InlineData("Tudo bem?", "Tudo bem?")] + [InlineData("Tudo bem, tudo bem.", "Está tudo bem, está tudo bem.")] + [InlineData("É você quem precisa de um advogado, Tiago.", "És tu que precisas de um advogado, Tiago.")] + [InlineData("Foi você que fez isto?", "Foste tu que fizeste isto?")] + [InlineData("É você quem não sabe.", "És tu que não sabes.")] + [InlineData("O quê, está me controlando?", "O quê, estás a controlar-me?")] + [InlineData("a mamãe e o papai estarão lá\nesperando você.", "a mãe e o pai estarão lá\nà tua espera.")] + [InlineData("Estou esperando você.", "Estou à tua espera.")] + [InlineData("Esse policial aqui\ntentou me afogar.", "Este polícia aqui\ntentou afogar-me.")] + [InlineData("Ele tentou me ajudar.", "Ele tentou ajudar-me.")] + [InlineData("Ele tentou me ver.", "Ele tentou ver-me.")] + [InlineData("Ele tentou me ouvir.", "Ele tentou ouvir-me.")] + [InlineData("Ela tentava nos convencer.", "Ela tentava convencer-nos.")] + [InlineData("- Cadê a mamãe?\n- Veremos ela já, já.", "- Onde está a mãe?\n- Vamos vê-la já, já.")] + [InlineData("Veremos ele amanhã.", "Vamos vê-lo amanhã.")] + [InlineData("Veremos elas amanhã.", "Vamos vê-las amanhã.")] + [InlineData("Não veremos ela amanhã.", "Não a vamos ver amanhã.")] + [InlineData("Veremos ela quando chegar.", "Vamos vê-la quando chegar.")] + [InlineData("ou está procurando novidades, pai?", "ou está à procura de novidades, pai?")] + [InlineData("Estou procurando o meu livro.", "Estou à procura do meu livro.")] + [InlineData("Estamos procurando por ele.", "Estamos à procura dele.")] + [InlineData("Ele está procurando um emprego.", "Ele está à procura de um emprego.")] + [InlineData("Estava procurando a chave.", "Estava à procura da chave.")] + [InlineData("Estou procurando entender.", "Estou a procurar perceber.")] + [InlineData("O que está procurando?", "O que está a procurar?")] + [InlineData("Estou procurando-o.", "Estou a procurá-lo.")] + public void Improvements(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("A gente se conheceu na terapia.", "Conhecemo-nos na terapia.")] + [InlineData("A gente não se fala há anos.", "Não nos falamos há anos.")] + [InlineData("A gente é amigo.", "Somos amigos.")] + [InlineData("Todo mundo se amava.", "Toda a gente se amava.")] + [InlineData("-A gente consegue.", "-Conseguimos.")] + [InlineData("Ele chamou a gente.", "Ele chamou-nos.")] + [InlineData("Vem com a gente.", "Vem connosco.")] + [InlineData("E se a gente deixar isso só entre nós?", "E se deixarmos isso só entre nós?")] + [InlineData("Acha que ela vem?", "Achas que ela vem?")] + [InlineData("Lembra do meu pai?", "Lembras-te do meu pai?")] + [InlineData("Ele perdeu seu emprego.", "Ele perdeu o seu emprego.")] + [InlineData("Seu idiota!", "Seu idiota!")] + [InlineData("Isso é ruim.", "Isso é mau.")] + [InlineData("Uma notícia ruim.", "Uma notícia má.")] + [InlineData("É bom demais!", "É muito bom!")] + [InlineData("Vou assistir o filme.", "Vou ver o filme.")] + [InlineData("Escuta, cara.", "Ouve, meu.")] + [InlineData("Isso te dá medo.", "Isso dá-te medo.")] + [InlineData("Me desculpa.", "Desculpa.")] + [InlineData("Valeu por vir.", "Obrigado por vir.")] + [InlineData("Valeu a pena.", "Valeu a pena.")] + [InlineData("Vim pegar minhas coisas.", "Vim buscar as minhas coisas.")] + [InlineData("É o jeito certo de fazer.", "É a forma certa de fazer.")] + [InlineData("Pesquisei seu namorado.", "Pesquisei o teu namorado.")] + [InlineData("Queria que sua primeira vez fosse boa.", "Queria que a tua primeira vez fosse boa.")] + [InlineData("Te vejo lá.", "Vemo-nos lá.")] + [InlineData("Não fala.", "Não fales.")] + [InlineData("Não se preocupa.", "Não te preocupes.")] + [InlineData("Não faz mal.", "Não faz mal.")] + [InlineData("Não vai acontecer de novo.", "Não vai acontecer de novo.")] + [InlineData("Ele não fala português.", "Ele não fala português.")] + [InlineData("Precisa de foco total.", "Precisas de foco total.")] + [InlineData("Alguém precisa de dar um toque.", "Alguém precisa de dar um toque.")] + [InlineData("Vivemos junto.", "Vivemos juntos.")] + [InlineData("Não consigo achar o negócio.", "Não consigo encontrar o negócio.")] + [InlineData("Vou achar que estás louca.", "Vou achar que estás louca.")] + [InlineData("Falando nisso, liguei para a tua mãe.", "Por falar nisso, liguei para a tua mãe.")] + [InlineData("- Obrigada, amiga. - Imagina.", "- Obrigada, amiga. - De nada.")] + public void CorpusImprovements(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("A barca sai em dez minutos, pai.", "O barco sai em dez minutos, pai.")] + [InlineData("A barca sai em\ndez minutos, pai.", "O barco sai em\ndez minutos, pai.")] + [InlineData("A barca parte amanhã.", "O barco parte amanhã.")] + [InlineData("As barcas partem amanhã.", "Os barcos partem amanhã.")] + [InlineData("A barca é pequena.", "A barca é pequena.")] + [InlineData("A barca chegou ontem.", "A barca chegou ontem.")] + public void BarcaChangesToBarcoInDepartureContext(string br, string pt) => AssertConverts(br, pt); + + [Fact] + public void BarcaDepartureConversionRespectsVocabularyOption() + { + var converter = new PortugueseConverter(new ConversionOptions(Vocabulary: false)); + Assert.Equal("A barca sai em dez minutos, pai.", converter.Convert("A barca sai em dez minutos, pai.")); + } + + [Theory] + [InlineData("O que está rolando aqui?", "O que está a acontecer aqui?")] + [InlineData("Todos vão acabar me odiando.", "Todos vão acabar por me odiar.")] + [InlineData("Passou anos me irritando.", "Passou anos a irritar-me.")] + [InlineData("Estou me abrindo aqui e tentando ser otimista.", "Estou a abrir-me aqui e a tentar ser otimista.")] + [InlineData("Estava ocupada criando o site.", "Estava ocupada a criar o site.")] + [InlineData("Tem gente vivendo aqui.", "Há gente a viver aqui.")] + [InlineData("Acho que tem alguém me seguindo.", "Acho que há alguém a seguir-me.")] + [InlineData("Mandei mensagem dizendo que ia.", "Mandei mensagem a dizer que ia.")] + [InlineData("- Recarregando!", "- A recarregar!")] + [InlineData("Só conferindo.", "Só a verificar.")] + [InlineData("Entendo.", "Percebo.")] + [InlineData("Tendo dito isso, vamos.", "Tendo dito isso, vamos.")] + [InlineData("Imaginei você fazendo sexo.", "Imaginei-te a fazer sexo.")] + [InlineData("- Como? - Enterrando elas.", "- Como? - A enterrá-las.")] + [InlineData("É bom ter você aqui.", "É bom ter-te aqui.")] + [InlineData("Não tem ninguém aqui.", "Não há ninguém aqui.")] + [InlineData("Ele tem alguém em casa.", "Ele tem alguém em casa.")] + [InlineData("Não dá.", "Não dá.")] + [InlineData("Ele atirou em mim!", "Ele disparou contra mim!")] + [InlineData("Atirem!", "Disparem!")] + [InlineData("Ele atirou a bola.", "Ele atirou a bola.")] + [InlineData("Ok. E onde ele está?", "Está bem. E onde está ele?")] + [InlineData("E o que ele quer?", "E o que ele quer?")] + [InlineData("Podes vir comigo, hein?", "Podes vir comigo, não?")] + [InlineData("Que puta humilhação.", "Que grande humilhação.")] + [InlineData("Puta que o pariu.", "Merda.")] + [InlineData("Filho da puta!", "Filho da puta!")] + [InlineData("Vou checar o endereço no laptop.", "Vou verificar a morada no portátil.")] + [InlineData("O prédio sumiu.", "O edifício desapareceu.")] + [InlineData("Estou com saudade.", "Tenho saudades.")] + [InlineData("Está bem, levante-se. Pegue.", "Está bem, levanta-te. Toma.")] + [InlineData("Para de pegar no pé do Noah.", "Para de implicar com o Noah.")] + [InlineData("- Vou pegar chá. - Está bem.", "- Vou buscar chá. - Está bem.")] + [InlineData("Se você pedir comida, tudo bem.", "Se pedires comida, tudo bem.")] + [InlineData("Ele quer enfraquecer você.", "Ele quer enfraquecer-te.")] + [InlineData("É melhor você e o Rui irem primeiro.", "É melhor tu e o Rui irem primeiro.")] + [InlineData("Achei que ele podia ser você.", "Achei que ele podia ser tu.")] + [InlineData("Não é assim que obriga eles.", "Não é assim que os obriga.")] + [InlineData("Vai se foder.", "Vai-te foder.")] + [InlineData("Se não quer, beleza.", "Se não quer, tudo bem.")] + [InlineData("Mano, valeu!", "Mano, obrigado!")] + [InlineData("Tá, cai fora!", "Está bem, sai daqui!")] + [InlineData("Ele ia te dopar e depois te afogar.", "Ele ia dopar-te e depois afogar-te.")] + [InlineData("Tá.", "Está bem.")] + [InlineData("Uns 42 minutos, seu tarado.", "Uns 42 minutos, seu tarado.")] + [InlineData("Ontem eu a deixei puta da vida.", "Ontem eu a deixei furiosa.")] + [InlineData("É, estou vendo dobrado, Pereira.", "É, estou a ver a dobrar, Pereira.")] + [InlineData("Estou vendo tudo dobrado.", "Estou a ver tudo a dobrar.")] + [InlineData("Ele via dobrado.", "Ele via a dobrar.")] + [InlineData("Coloque-me na espera, que eu espero.", "Põe-me em espera, que eu espero.")] + [InlineData("Tens dúvidas sobre ser policial?", "Tens dúvidas sobre ser polícia?")] + [InlineData("Pegam muitos peixes aqui.", "Apanham muitos peixes aqui.")] + [InlineData("Pegam muitas coisas aqui.", "Apanham muitas coisas aqui.")] + [InlineData("Peguei várias moedas ali.", "Apanhei várias moedas ali.")] + [InlineData("Pegam muitos objetos aqui.", "Apanham muitos objetos aqui.")] + [InlineData("Pegue as flores.", "Apanha as flores.")] + [InlineData("Pegaremos cogumelos amanhã.", "Apanharemos cogumelos amanhã.")] + [InlineData("Pegam muitas\ncoisas aqui.", "Apanham muitas\ncoisas aqui.")] + [InlineData("PEGUEM MUITAS COISAS AQUI.", "APANHEM MUITAS COISAS AQUI.")] + [InlineData("Pega a arma.", "Pega na arma.")] + [InlineData("Pega em muitas coisas aqui.", "Pega em muitas coisas aqui.")] + [InlineData("Mas não hoje.", "Mas hoje não.")] + [InlineData("Ser os restos da miúda num contêiner.", "Ser os restos da miúda num contentor.")] + [InlineData("O teu irmão não foi morto numa batida que deu errado.", "O teu irmão não foi morto numa pancada que correu mal.")] + [InlineData("E não é esse pestinha aqui.", "E não é este pestinha aqui.")] + [InlineData("O assado vai esfriar.", "O assado vai arrefecer.")] + [InlineData("Miúda católica, mesma idade da Teresa, desaparecida.", "Miúda católica, da mesma idade da Teresa, desaparecida.")] + [InlineData("Porque não acordas um dia aos 50 e vira um pervertido.", "Porque não acordas um dia aos 50 e tornas-te um pervertido.")] + [InlineData("Pare de drama, só me diga.", "Deixa-te de dramas, diz-me só.")] + [InlineData("Dê uma olhada nos jornais.", "Dá uma vista de olhos aos jornais.")] + [InlineData("Não dá para dar uma olhada?", "Não dá para dar uma vista de olhos?")] + [InlineData("Vou dar uma olhada na Capstone.", "Vou dar uma vista de olhos à Capstone.")] + [InlineData("Está tudo sob controle.", "Está tudo sob controlo.")] + [InlineData("Atenção, Controle.", "Atenção, Controlo.")] + public void SecondCorpusImprovements(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("Não acho meu iPod.", "Não encontro o meu iPod.")] + [InlineData("Nunca acharam o corpo.", "Nunca encontraram o corpo.")] + [InlineData("Achei o corpo.", "Encontrei o corpo.")] + [InlineData("A boneca foi achada.", "A boneca foi encontrada.")] + [InlineData("Ele foi achado culpado.", "Ele foi achado culpado.")] + [InlineData("Acharam a carrinha.", "Encontraram a carrinha.")] + [InlineData("Acho que ele vem.", "Acho que ele vem.")] + [InlineData("Acho o carro bonito.", "Acho o carro bonito.")] + [InlineData("Acho a faca estranha.", "Acho a faca estranha.")] + [InlineData("Achei o carro desconfortável.", "Achei o carro desconfortável.")] + [InlineData("Acho o carro muito velho.", "Acho o carro muito velho.")] + [InlineData("Dei sorte de chegar.", "Tive sorte de chegar.")] + [InlineData("Ele deu sorte.", "Ele teve sorte.")] + [InlineData("Isso dá sorte.", "Isso dá sorte.")] + [InlineData("Esqueci de carregá-lo.", "Esqueci-me de carregá-lo.")] + [InlineData("Esqueci que temos uma reunião.", "Esqueci-me de que temos uma reunião.")] + [InlineData("ESQUECI QUE TEMOS UMA REUNIÃO.", "ESQUECI-ME DE QUE TEMOS UMA REUNIÃO.")] + [InlineData("Esqueci disso.", "Esqueci-me disso.")] + [InlineData("Esqueci-me disso.", "Esqueci-me disso.")] + [InlineData("Nunca me esqueci de nenhum.", "Nunca me esqueci de nenhum.")] + [InlineData("Nunca esqueci disso.", "Nunca me esqueci disso.")] + [InlineData("Serem policiais antigos.", "Serem polícias antigos.")] + [InlineData("Sem digitais.", "Sem impressões digitais.")] + [InlineData("Temos digitais e uma foto.", "Temos impressões digitais e uma foto.")] + [InlineData("Análise de digitais e sangue.", "Análise de impressões digitais e sangue.")] + [InlineData("Temos impressões digitais.", "Temos impressões digitais.")] + [InlineData("Fotografias digitais.", "Fotografias digitais.")] + [InlineData("Cheque os vídeos.", "Verifica os vídeos.")] + [InlineData("O cheque está na mesa.", "O cheque está na mesa.")] + [InlineData("Seres policial.", "Seres polícia.")] + [InlineData("Precisamos de policiais.", "Precisamos de polícias.")] + [InlineData("Brutalidade policial.", "Brutalidade policial.")] + [InlineData("Uma investigação policial.", "Uma investigação policial.")] + [InlineData("Van branca.", "Carrinha branca.")] + [InlineData("Van Morrison.", "Van Morrison.")] + [InlineData("Vi a entrevista coletiva.", "Vi a conferência de imprensa.")] + [InlineData("Conheces a mídia.", "Conheces a comunicação social.")] + [InlineData("As enquetes.", "As sondagens.")] + [InlineData("A louça dela.", "A loiça dela.")] + [InlineData("Senso de humor.", "Sentido de humor.")] + [InlineData("Senso comum.", "Senso comum.")] + [InlineData("Vamos fazer tudo que pudermos.", "Vamos fazer tudo o que pudermos.")] + [InlineData("Francis, esta é a Oficial Romano.", "Francis, esta é a Oficial Romano.")] + public void SubtitleReviewImprovements(string br, string pt) => AssertConverts(br, pt); + + + [Theory] + [InlineData("Estou fazendo o jantar.", "Estou a fazer o jantar.")] + [InlineData("Ele está dizendo a verdade.", "Ele está a dizer a verdade.")] + [InlineData("Estávamos saindo.", "Estávamos a sair.")] + [InlineData("O que você está pondo aí?", "O que estás a pôr aí?")] + [InlineData("Estou te dizendo.", "Estou a dizer-te.")] + [InlineData("Ela está se vestindo.", "Ela está a vestir-se.")] + [InlineData("Continua chovendo.", "Continua a chover.")] + [InlineData("Está lindo.", "Está lindo.")] + [InlineData("Estou só olhando.", "Estou só a olhar.")] + [InlineData("Ele está no fundo.", "Ele está no fundo.")] + public void Progressive(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("Me diga a verdade.", "Diz-me a verdade.")] + [InlineData("Te amo.", "Amo-te.")] + [InlineData("Eu te amo.", "Eu amo-te.")] + [InlineData("Ele se chama João.", "Ele chama-se João.")] + [InlineData("Vou te matar!", "Vou matar-te!")] + [InlineData("Posso te ajudar?", "Posso ajudar-te?")] + [InlineData("Eu vi ele ontem.", "Eu vi-o ontem.")] + [InlineData("Não vi ele.", "Não o vi.")] + [InlineData("Nos vemos amanhã.", "Vemo-nos amanhã.")] + [InlineData("Eu não te conheço.", "Eu não te conheço.")] + [InlineData("Ele disse ele mesmo.", "Ele disse ele mesmo.")] + [InlineData("Ela o viu.", "Ela viu-o.")] + [InlineData("Um cara me seguiu.", "Um tipo seguiu-me.")] + [InlineData("O homem que me seguiu.", "O homem que me seguiu.")] + [InlineData("Meu pai não gosta disso.", "O meu pai não gosta disso.")] + [InlineData("Meu Deus, o que foi isso?", "Meu Deus, o que foi isso?")] + public void Pronouns(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("Tá bom.", "Está bem.")] + [InlineData("Tô cansado.", "Estou cansado.")] + [InlineData("Vou pra casa.", "Vou para casa.")] + [InlineData("Cadê o Pedro?", "Onde está o Pedro?")] + [InlineData("Cadê os meninos?", "Onde estão os meninos?")] + [InlineData("Tenho que ir.", "Tenho de ir.")] + [InlineData("Isso não tem que ver com isso.", "Isso não tem a ver com isso.")] + [InlineData("Oi, tudo bem?", "Olá, tudo bem?")] + [InlineData("Deixa eu ver.", "Deixa-me ver.")] + [InlineData("Ele ficou bravo.", "Ele ficou zangado.")] + [InlineData("Legal!", "Fixe!")] + [InlineData("Fica calmo, tá?", "Fica calmo, está bem?")] + [InlineData("Onde tá o meu celular?", "Onde está o meu telemóvel?")] + [InlineData("Tenho certeza disso.", "Tenho a certeza disso.")] + [InlineData("Preciso ir ao banheiro.", "Preciso de ir à casa de banho.")] + [InlineData("Preciso te ver.", "Preciso de te ver.")] + [InlineData("Me desculpa, eu não queria te machucar.", "Desculpa, eu não queria magoar-te.")] + [InlineData("Ele se machucou.", "Ele magoou-se.")] + [InlineData("Ele dirige muito mal.", "Ele conduz muito mal.")] + [InlineData("Ela vai dirigir o filme.", "Ela vai dirigir o filme.")] + public void Colloquial(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("Você tem razão.", "Tens razão.")] + [InlineData("Você está bem?", "Estás bem?")] + [InlineData("Você quer ir?", "Queres ir?")] + [InlineData("Você falou com ele?", "Falaste com ele?")] + [InlineData("Vou com você.", "Vou contigo.")] + [InlineData("Isto é para você.", "Isto é para ti.")] + [InlineData("Eu amo você.", "Eu amo-te.")] + [InlineData("Obrigado, e você?", "Obrigado, e tu?")] + [InlineData("Você se lembra?", "Lembras-te?")] + [InlineData("Você não se lembra?", "Não te lembras?")] + [InlineData("Vocês estão bem?", "Vocês estão bem?")] + [InlineData("Se você quiser, eu vou.", "Se quiseres, eu vou.")] + [InlineData("Foi você?", "Foste tu?")] + [InlineData("O que você fez?", "O que fizeste?")] + [InlineData("Eu sei que você me ama.", "Eu sei que me amas.")] + [InlineData("VOCÊ TEM RAZÃO", "TENS RAZÃO")] + [InlineData("Você zarpou?", "Zarpaste?")] + [InlineData("Você cansada?", "Você cansada?")] + [InlineData("Eu sei que você se importa.", "Eu sei que te importas.")] + public void YouToTu(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("Então soube que chegou cedo.", "Then I found out you arrived early.", "Então soube que chegaste cedo.")] + [InlineData("Sabe que fui um oficial.", "You know I was an officer.", "Sabes que fui um oficial.")] + [InlineData("Pensa que trabalhou muito.", "You think you worked hard.", "Pensas que trabalhaste muito.")] + [InlineData("Sabe o que fez ontem?", "You know what you did yesterday?", "Sabes o que fizeste ontem?")] + [InlineData("Sabe o que era?", "You know what you were?", "Sabes o que eras?")] + [InlineData("O que está fazendo aqui?", "What are you doing here?", "O que estás a fazer aqui?")] + [InlineData("O que pode fazer?", "What can you do?", "O que podes fazer?")] + [InlineData("Sei o que quer dizer.", "I know what you mean.", "Sei o que queres dizer.")] + [InlineData("Ele sabe que foi para casa.", "He knows he went home.", "Ele sabe que foi para casa.")] + [InlineData("Então soube que chegou cedo.", "Then I found out he arrived early.", "Então soube que chegou cedo.")] + [InlineData("O que aconteceu?", "What happened to you?", "O que aconteceu?")] + public void ReferenceGuidesDroppedSecondPersonSubjects(string br, string english, string pt) => + Assert.Equal(pt, Converter.Convert(br, null, ReferenceHint.FromText(english))); + + [Fact] + public void DroppedSecondPersonWithoutReferenceIsNotGuessed() + { + Assert.Equal("Sabe que fui um oficial.", Converter.Convert("Sabe que fui um oficial.")); + } + + [Theory] + [InlineData("Por isso que nunca namorou nenhum tira?", "Is that why you never dated any cops?", "Por isso é que nunca namoraste um polícia?")] + [InlineData("Por isso que nunca visitou nenhuma ilha?", "Is that why you never visited any islands?", "Por isso é que nunca visitaste uma ilha?")] + [InlineData("Por isso que já chegou?", "Is that why you already arrived?", "Por isso é que já chegaste?")] + [InlineData("Por isso que não quer sair?", "Is that why you don't want to leave?", "Por isso é que não queres sair?")] + [InlineData("É por isso que nunca trabalhou aqui?", "Is that why you never worked here?", "É por isso que nunca trabalhaste aqui?")] + [InlineData("Foi por isso que nunca veio?", "Was that why you never came?", "Foi por isso que nunca vieste?")] + [InlineData("Por isso que nunca\nnamorou nenhum tira?", "Is that why you never dated any cops?", "Por isso é que nunca\nnamoraste um polícia?")] + [InlineData("POR ISSO QUE NUNCA FALOU?", "Is that why you never spoke?", "POR ISSO É QUE NUNCA FALASTE?")] + [InlineData("Por isso que nunca falou?", "Is that why you never spoke?", "Por isso é que nunca falaste?")] + [InlineData("Por isto que não veio?", "Is this why you didn't come?", "Por isto é que não vieste?")] + public void CausalClausesUseReferenceSubjectAcrossVerbs(string source, string english, string expected) + { + var hint = ReferenceHint.FromText(english); + Assert.True(hint!.SecondPersonSubject); + Assert.Equal(expected, Converter.Convert(source, null, hint)); + Assert.Equal(expected, Converter.Convert(expected, null, hint)); + } + + [Theory] + [InlineData("Por isso que nunca namorou?", "Is that why he never dated?", "Por isso é que nunca namorou?")] + [InlineData("Por isso que ele nunca namorou?", "Is that why he never dated?", "Por isso é que ele nunca namorou?")] + [InlineData("Por isso que eu nunca namorei?", "Is that why I never dated?", "Por isso é que eu nunca namorei?")] + [InlineData("Por isso que a Ana nunca namorou?", "Is that why you think Ana never dated?", "Por isso é que a Ana nunca namorou?")] + [InlineData("Por isso que nunca falou de você?", "Is that why he never spoke about you?", "Por isso é que nunca falou de ti?")] + [InlineData("Por isso que nunca namorou?", null, "Por isso é que nunca namorou?")] + [InlineData("Por isso vim.", "That's why I came.", "Por isso vim.")] + [InlineData("Eu lutei por isso que mencionou.", null, "Eu lutei por isso que mencionou.")] + [InlineData("Por isso é que nunca namoraste?", "Is that why you never dated?", "Por isso é que nunca namoraste?")] + public void CausalClausesDoNotGuessSubjectsOrDuplicateFocus(string source, string? english, string expected) => + Assert.Equal(expected, Converter.Convert(source, null, ReferenceHint.FromText(english))); + + [Fact] + public void CausalClausePreservesFormalReferenceContext() + { + var hint = ReferenceHint.FromText("Is that why you never dated any officers?")! with { FormalAddress = true }; + Assert.Equal("Por isso é que nunca namorou um agente?", + Converter.Convert("Por isso que nunca namorou nenhum polícia?", null, hint)); + var off = new PortugueseConverter(ConversionOptions.Default with { Colloquial = false }); + Assert.Equal("Por isso que nunca namoraste nenhum polícia?", + off.Convert("Por isso que nunca namorou nenhum polícia?", null, ReferenceHint.FromText("Is that why you never dated any officers?"))); + } + + [Theory] + [InlineData("Nunca vi nenhum castelo.", "I never saw any castles.", "Nunca vi um castelo.")] + [InlineData("Nunca visitou nenhuma ilha.", "She never visited any islands.", "Nunca visitou uma ilha.")] + [InlineData("Nunca vi nenhum castelo.", "I never saw a castle.", "Nunca vi nenhum castelo.")] + [InlineData("Não vi nenhum castelo.", "I didn't see any castles.", "Não vi nenhum castelo.")] + [InlineData("Nunca nenhum polícia entrou.", "No cop ever entered.", "Nunca nenhum polícia entrou.")] + [InlineData("Nunca foi nenhum problema.", "It was never any trouble.", "Nunca foi nenhum problema.")] + public void NeverAnyObjectUsesReferenceAndKeepsNegation(string source, string english, string expected) => + Assert.Equal(expected, Converter.Convert(source, null, ReferenceHint.FromText(english))); + + [Theory] + [InlineData("Não pense que porque seu velho é o chefe.", "Não penses que porque o teu velho é o chefe.")] + [InlineData("que vou facilitar pra você.", "que te vou facilitar.")] + [InlineData("que eu vou facilitar para você.", "que eu te vou facilitar.")] + public void AddressedCommandsAndDativeInfinitives(string br, string pt) => AssertConverts(br, pt); + + [Theory] + [InlineData("Estou fazendo isso.", "Estou a fazer isso.")] + [InlineData("{\\an8}O trem chegou.", "{\\an8}O comboio chegou.")] + [InlineData("tela", "ecrã")] + [InlineData("- Oi!\n- Tá bom.", "- Olá!\n- Está bem.")] + public void KeepsTagsAndLines(string br, string pt) => AssertConverts(br, pt); + + [Fact] + public void Options_DisableGroups() + { + var converter = new PortugueseConverter(new ConversionOptions(Spelling: false, Vocabulary: false, Progressive: false, Pronouns: false, Colloquial: false, YouToTu: false)); + const string text = "Você tá fazendo um fato no trem, me diga."; + Assert.False(converter.TryConvert(text, out _)); + } + + [Fact] + public void Options_OnlySpelling() + { + var converter = new PortugueseConverter(new ConversionOptions(Vocabulary: false, Progressive: false, Pronouns: false, Colloquial: false, YouToTu: false)); + Assert.Equal("Estou fazendo um facto no trem.", converter.Convert("Estou fazendo um fato no trem.")); + } + + [Fact] + public void LocalWordList_AddsAndIgnores() + { + var list = new PortugueseLocalWordList(); + list.Words.Add(("parada", "coisa")); + list.Ignored.Add("trem"); + var converter = new PortugueseConverter(null, list); + Assert.Equal("Que coisa é essa no trem?", converter.Convert("Que parada é essa no trem?")); + } + + [Fact] + public void BuiltInList_HasNoDuplicateOrIdentityEntries() + { + var words = PortugueseConverter.BuiltInWords; + var duplicates = words.GroupBy(w => w.Br, StringComparer.OrdinalIgnoreCase).Where(g => g.Count() > 1).Select(g => g.Key).ToList(); + Assert.Empty(duplicates); + Assert.DoesNotContain(words, w => string.Equals(w.Br, w.Pt, StringComparison.Ordinal)); + } +} + +public sealed class VerbVocabularyTests +{ + private static readonly PortugueseConverter Converter = new(ConversionOptions.Default); + + [Theory] + [InlineData("Botei o meu carro na garagem.", "Meti o meu carro na garagem.")] + [InlineData("Bota isso aí.", "Mete isso aí.")] + [InlineData("Me bota no carro.", "Mete-me no carro.")] + [InlineData("Vou botá-lo na cela.", "Vou metê-lo na cela.")] + [InlineData("Estou botando as coisas no lugar.", "Estou a meter as coisas no lugar.")] + [InlineData("Ele a botou no carro.", "Ele meteu-a no carro.")] + [InlineData("Você bota tudo.", "Metes tudo.")] + [InlineData("Se você botar o carro aí...", "Se meteres o carro aí...")] + [InlineData("Eles xingaram muito.", "Eles insultaram muito.")] + [InlineData("Checaremos o resto.", "Verificaremos o resto.")] + [InlineData("Esquente a sopa.", "Aquece a sopa.")] + [InlineData("Ele pulou da janela.", "Ele saltou da janela.")] + [InlineData("Jogue o lixo fora.", "Deita o lixo fora.")] + [InlineData("Jogou tudo fora?", "Deitou tudo fora?")] + [InlineData("Ele arrumou um emprego.", "Ele arranjou um emprego.")] + [InlineData("Não quero arrumar problemas.", "Não quero arranjar problemas.")] + [InlineData("Estão estressados.", "Estão stressados.")] + [InlineData("Fomos flagrados.", "Fomos apanhados.")] + [InlineData("O avião aterrissou.", "O avião aterrou.")] + [InlineData("Eles moravam juntos.", "Eles viviam juntos.")] + [InlineData("A gente deletou tudo.", "Apagámos tudo.")] + [InlineData("Ela posta fotos.", "Ela publica fotos.")] + [InlineData("Quem bagunçou o quarto?", "Quem desarrumou o quarto?")] + [InlineData("Achei que ela entenderia.", "Achei que ela perceberia.")] + public void BrazilianVerbsBecomeEuropean(string text, string expected) => Assert.Equal(expected, Converter.Convert(text)); + + [Theory] + [InlineData("Calcei as botas.")] + [InlineData("Comprei botas novas.")] + [InlineData("botas de trabalho e um cinto.")] + [InlineData("A bota dela.")] + [InlineData("Há 330 mil postes na cidade.")] + [InlineData("Dá um pulo lá.")] + [InlineData("Ela ficou de tromba.")] + [InlineData("O cheque voltou.")] + [InlineData("Ele jogou futebol.")] + [InlineData("Arruma o quarto.")] + [InlineData("Entendido.")] + [InlineData("Ele botou fogo na casa.")] + [InlineData("Ele esquentou a cabeça.")] + public void NounsAndOtherMeaningsAreKept(string text) => Assert.Equal(text, Converter.Convert(text)); + + [Fact] + public void OwnWordListEntryWinsOverGeneratedForms() + { + var local = new PortugueseLocalWordList(); + local.Words.Add(("botar", "pôr")); + var converter = new PortugueseConverter(ConversionOptions.Default, local); + Assert.Equal("Vou pôr aqui. Botei ali.", converter.Convert("Vou botar aqui. Botei ali.")); + } + + [Fact] + public void ConjugatorKeepsTheConsonantSound() + { + Assert.True(VerbConjugator.TryConjugate("xingar", out var xingar)); + Assert.Contains("xinguei", xingar); + Assert.Contains("xingue", xingar); + Assert.True(VerbConjugator.TryConjugate("aquecer", out var aquecer)); + Assert.Contains("aqueço", aquecer); + Assert.Contains("aquece", aquecer); + Assert.Contains("aqueça", aquecer); + Assert.Equal("metê", VerbConjugator.CliticInfinitive("meter")); + } +} + +public sealed class PlanearTests +{ + private static readonly PortugueseConverter Converter = new(ConversionOptions.Default); + + [Theory] + [InlineData("Eu planejo tudo.", "Eu planeio tudo.")] + [InlineData("Você planeja demais.", "Planeias demais.")] + [InlineData("Ele planejou o assalto.", "Ele planeou o assalto.")] + [InlineData("Eles planejaram tudo.", "Eles planearam tudo.")] + [InlineData("Estou planejando uma festa.", "Estou a planear uma festa.")] + [InlineData("Foi planejado.", "Foi planeado.")] + [InlineData("Não planeje nada.", "Não planeie nada.")] + [InlineData("Não planejes nada.", "Não planeies nada.")] + [InlineData("Planejem bem.", "Planeiem bem.")] + [InlineData("Vamos planejá-lo.", "Vamos planeá-lo.")] + [InlineData("O planejamento falhou.", "O planeamento falhou.")] + [InlineData("Ele planejava fugir.", "Ele planeava fugir.")] + [InlineData("PLANEJEI TUDO.", "PLANEEI TUDO.")] + public void PlanejarBecomesPlanear(string text, string expected) => Assert.Equal(expected, Converter.Convert(text)); + + [Theory] + [InlineData("Você fala demais.", "Falas demais.")] + [InlineData("Ele reclama demais.", "Ele reclama demais.")] + [InlineData("Isso é caro demais.", "Isso é muito caro.")] + [InlineData("Caro demais!", "Muito caro!")] + public void DemaisAfterAVerbStays(string text, string expected) => Assert.Equal(expected, Converter.Convert(text)); +} + +public sealed class SlangTests +{ + private static readonly PortugueseConverter Converter = new(ConversionOptions.Default); + + [Theory] + [InlineData("Você é o tira que trabalhou\nno caso da Katie Snow,", "És o polícia que trabalhou\nno caso da Katie Snow,")] + [InlineData("Ela foi estuprada.", "Ela foi violada.")] + [InlineData("Ele estuprou duas mulheres.", "Ele violou duas mulheres.")] + [InlineData("Foi um estupro.", "Foi uma violação.")] + [InlineData("O estuprador fugiu.", "O violador fugiu.")] + [InlineData("Jaqueta gasta, meio velha.", "Casaco gasto, meio velho.")] + [InlineData("Usava uma jaqueta preta e rasgada.", "Usava um casaco preto e rasgado.")] + [InlineData("A geladeira está quebrada.", "O frigorífico está quebrado.")] + [InlineData("Que encrenca danada, cara.", "Que sarilho danado, meu.")] + [InlineData("Nossa encrenca, cara.", "Nosso sarilho, meu.")] + [InlineData("Manterei você informado.", "Manter-te-ei informado.")] + [InlineData("Não manterei você aqui.", "Não te manterei aqui.")] + [InlineData("Te ligarei amanhã.", "Ligar-te-ei amanhã.")] + [InlineData("Eu te direi amanhã.", "Eu dir-te-ei amanhã.")] + [InlineData("Eu o farei.", "Eu fá-lo-ei.")] + [InlineData("Aproveite seu indulto.\nNão vai durar muito.", "Aproveita o teu indulto.\nNão vai durar muito.")] + [InlineData("- Foi bom te ver e sua namorada.\n- Parceira.", "- Foi bom ver-te e a tua namorada.\n- Parceira.")] + [InlineData("Que bom te ver!", "Que bom ver-te!")] + [InlineData("Foi ótimo te conhecer.", "Foi ótimo conhecer-te.")] + [InlineData("Obrigado por me receber.", "Obrigado por me receber.")] + [InlineData("Pegue suas coisas e saia.", "Pega nas tuas coisas e sai.")] + [InlineData("Me dê sua arma.", "Dá-me a tua arma.")] + [InlineData("Diga a sua mãe que eu liguei.", "Diz à tua mãe que eu liguei.")] + [InlineData("Diga a seu pai que eu liguei.", "Diz ao teu pai que eu liguei.")] + [InlineData("Mostre a sua arma.", "Mostra a tua arma.")] + [InlineData("Desculpe, tua mãe ligou.", "Desculpa, a tua mãe ligou.")] + [InlineData("Este é o teu carro.", "Este é o teu carro.")] + [InlineData("Aproveite.", "Aproveita.")] + [InlineData("Isto é para ti.", "Isto é para ti.")] + [InlineData("Dê pé! Vamos!\nLevanta!", "De pé! Vamos!\nLevanta-te!")] + [InlineData("- Não!\n- Levante!", "- Não!\n- Levanta-te!")] + [InlineData("Senta já!", "Senta-te já!")] + [InlineData("Acalmem!", "Acalmem-se!")] + [InlineData("Vamos, mexe!", "Vamos, mexe-te!")] + [InlineData("Abaixa!", "Baixa-te!")] + [InlineData("Levanta daí.", "Levanta-te daí.")] + [InlineData("Levanta a mão.", "Levanta a mão.")] + [InlineData("Ele levanta.", "Ele levanta.")] + [InlineData("Levante-se!", "Levanta-te!")] + [InlineData("Não dê pé para isso.", "Não dês pé para isso.")] + [InlineData("- Essas duas.\n- King, lembra de mim?", "- Essas duas.\n- King, lembras-te de mim?")] + [InlineData("Lembra de mim?", "Lembras-te de mim?")] + [InlineData("Você lembra de mim?", "Lembras-te de mim?")] + [InlineData("Se lembra de onde\nestava há duas noites?", "Lembras-te de onde\nestava há duas noites?")] + [InlineData("Estávamos no hospital, lembra?", "Estávamos no hospital, lembras-te?")] + [InlineData("Não lembra de nada?", "Não te lembras de nada?")] + [InlineData("Lembra de trancar a porta.", "Lembra-te de trancar a porta.")] + [InlineData("Lembre de trancar a porta.", "Lembra-te de trancar a porta.")] + [InlineData("Ele lembra de mim.", "Ele lembra-se de mim.")] + [InlineData("Eu não lembro.", "Eu não me lembro.")] + [InlineData("Eu lembro de você.", "Eu lembro-me de ti.")] + [InlineData("Eu também lembro disso.", "Eu também me lembro disso.")] + [InlineData("Todos lembramos do\nhorrível mal entendido", "Todos nos lembramos do\nhorrível mal entendido")] + [InlineData("Nós lembramos de tudo.", "Nós lembramo-nos de tudo.")] + [InlineData("Ela não lembrava do rosto.", "Ela não se lembrava do rosto.")] + [InlineData("Ele esqueceu da reunião.", "Ele esqueceu-se da reunião.")] + [InlineData("Você esqueceu de mim?", "Esqueceste-te de mim?")] + [InlineData("Não esquece de mim.", "Não te esqueças de mim.")] + [InlineData("Não esqueça de ligar.", "Não te esqueças de ligar.")] + [InlineData("Eu sei. Sinto muito.\nEsqueci.", "Eu sei. Sinto muito.\nEsqueci-me.")] + [InlineData("Doutor, lembra de mim?", "Doutor, lembra-se de mim?")] + [InlineData("Comissário, lembra de mim?", "Comissário, lembra-se de mim?")] + [InlineData("Tiago, sabe onde está o carro?", "Tiago, sabes onde está o carro?")] + [InlineData("Na verdade, nem me\nlembro dessa conversa.", "Na verdade, nem me\nlembro dessa conversa.")] + [InlineData("Não me lembro de nada.", "Não me lembro de nada.")] + [InlineData("Isso lembra o meu pai.", "Isso lembra o meu pai.")] + [InlineData("Esqueci o nome dele.", "Esqueci o nome dele.")] + [InlineData("Esquece isso.", "Esquece isso.")] + [InlineData("Esquece!", "Esquece!")] + [InlineData("Tudo o que lembro.", "Tudo o que lembro.")] + [InlineData("Botei o meu na reta para conseguir prender esse cara.", "Arrisquei o pescoço para conseguir prender esse tipo.")] + [InlineData("Ele colocou o dele na reta por você.", "Ele arriscou o pescoço por ti.")] + [InlineData("Não vou botar a minha na reta.", "Não vou arriscar o pescoço.")] + [InlineData("Ela chega em casa e já reclama de tudo.", "Ela chegou a casa e já está a queixar-se de tudo.")] + [InlineData("Quando cheguei em casa, ela tinha saído.", "Quando cheguei a casa, ela tinha saído.")] + [InlineData("Ele chegou no hospital às duas.", "Ele chegou ao hospital às duas.")] + [InlineData("Eles chegaram em um acordo.", "Eles chegaram a um acordo.")] + [InlineData("Chegaste em tempo.", "Chegaste a tempo.")] + [InlineData("Chego em dez minutos.", "Chego em dez minutos.")] + [InlineData("Ele chegou na hora.", "Ele chegou na hora.")] + [InlineData("Foi pessoal para nós,\nseu babaca.", "Foi pessoal para nós,\nseu parvo.")] + [InlineData("Ele sai da cadeia e já viola\nsua ordem de proteção.", "Ele saiu da prisão e já está a violar\na sua ordem de proteção.")] + [InlineData("Eles saem da escola e já fumam.", "Eles saíram da escola e já estão a fumar.")] + [InlineData("Ele chega e já faz confusão.", "Ele chegou e já está a fazer confusão.")] + [InlineData("Ele sai e já volta.", "Ele sai e já volta.")] + [InlineData("E já sabe o que fazer.", "E já sabe o que fazer.")] + [InlineData("A cadeia de comando é clara.", "A cadeia de comando é clara.")] + [InlineData("Vais apodrecer\nna cadeia.", "Vais apodrecer\nna prisão.")] + [InlineData("Além de aumentar o\nseu colesterol.", "Além de aumentar o\nteu colesterol.")] + [InlineData("Por favor, apenas me mate.", "Por favor, mate-me apenas.")] + [InlineData("Apenas me diga\ncomo o matou.", "Diz-me apenas\ncomo o matou.")] + [InlineData("Apenas me deixe em paz!", "Deixa-me em paz!")] + [InlineData("Simplesmente se acalme.", "Simplesmente acalme-se.")] + [InlineData("Apenas me deixou muito... enojada.", "Apenas me deixou muito... enojada.")] + [InlineData("Eu apenas me lembro disso.", "Eu apenas me lembro disso.")] + [InlineData("será analisado pela Corregedoria,", "será analisado pelos Assuntos Internos,")] + [InlineData("A Corregedoria vai investigar.", "Os Assuntos Internos vão investigar.")] + [InlineData("Ele é da Corregedoria.", "Ele é dos Assuntos Internos.")] + [InlineData("investigador da Assuntos Internos?", "investigador dos Assuntos Internos?")] + [InlineData("O corregedor chegou.", "O inspetor chegou.")] + [InlineData("A Corregedoria-Geral da Justiça abriu um processo.", "A Inspeção-Geral da Justiça abriu um processo.")] + [InlineData("- Cale sua boca.", "- Cala-te.")] + [InlineData("Cala a boca, Tiago.", "Cala-te, Tiago.")] + [InlineData("Calem a boca!", "Calem-se!")] + [InlineData("Bom. Cale a boca\ne continue a trabalhar.", "Bom. Cala-te\ne continua a trabalhar.")] + [InlineData("Quero que cale a boca.", "Quero que cale a boca.")] + [InlineData("Estou surpreso.", "Estou surpreendido.")] + [InlineData("Fiquei surpresa com a notícia.", "Fiquei surpreendida com a notícia.")] + [InlineData("Foi uma surpresa.", "Foi uma surpresa.")] + [InlineData("Sim. Agradeça seu chefe por mim.", "Sim. Agradece ao teu chefe por mim.")] + [InlineData("Temos de agradecer os bombeiros.", "Temos de agradecer aos bombeiros.")] + [InlineData("Agradeço a Deus.", "Agradeço a Deus.")] + [InlineData("Quero agradecer o favor.", "Quero agradecer o favor.")] + [InlineData("Senta no teu trono.", "Senta no teu trono.")] + [InlineData("Não quero que você\nperca o seu emprego.", "Não quero que percas\no teu emprego.")] + [InlineData("Olhe, tua mãe está a caminho.", "Olha, a tua mãe está a caminho.")] + [InlineData("Espere aqui.", "Espera aqui.")] + [InlineData("Eles me queriam também.", "Eles me queriam também.")] + [InlineData("Ele me sequestraria.", "Ele raptar-me-ia.")] + [InlineData("Um estupro foi cometido.", "Uma violação foi cometida.")] + [InlineData("Estupro é hediondo.", "Violação é hedionda.")] + [InlineData("que vira um tira de patrulha.", "que se torna um polícia de patrulha.")] + [InlineData("Só é preciso de dois tiras e\numas caixas velhas.", "Só é preciso de dois polícias e\numas caixas velhas.")] + [InlineData("Joe morreu sendo um bom tira.", "Joe morreu sendo um bom polícia.")] + [InlineData("Sou tira.", "Sou polícia.")] + [InlineData("Matou um tira!", "Matou um polícia!")] + [InlineData("Tiras de rua têm a pior visão.", "Polícias de rua têm a pior visão.")] + [InlineData("Esse é o nosso tira corrupto.", "Esse é o nosso polícia corrupto.")] + [InlineData("O tira tira o casaco.", "O polícia tira o casaco.")] + [InlineData("Nossa, obrigada.", "Caramba, obrigada.")] + [InlineData("-Minha nossa, é roubado?", "-Caramba, é roubado?")] + [InlineData("Droga.", "Bolas.")] + [InlineData("Droga, Ann.", "Bolas, Ann.")] + [InlineData("disse que não o faz um tira ruim.", "disse que não o faz um polícia mau.")] + [InlineData("Está de sacanagem.", "Está a gozar.")] + [InlineData("Que droga!", "Que porcaria!")] + [InlineData("É uma droga.", "É uma porcaria.")] + [InlineData("Não sou dedo-duro.", "Não sou bufo.")] + [InlineData("no caso de estar grampeado.", "no caso de estar sob escuta.")] + [InlineData("Eles estão encrencados.", "Eles estão metidos em sarilhos.")] + [InlineData("Isso é uma grana preta.", "Isso é um balúrdio.")] + [InlineData("Aquele pilantra fugiu.", "Aquele vigarista fugiu.")] + [InlineData("É só papo furado.", "É só conversa fiada.")] + [InlineData("A ganhadora é a Sofia.", "A vencedora é a Sofia.")] + [InlineData("Os ganhadores recebem o prémio.", "Os vencedores recebem o prémio.")] + [InlineData("O promotor quer um acordo.", "O procurador quer um acordo.")] + [InlineData("Não sabia que tiras e promotores\nestavam em lados opostos.", "Não sabia que polícias e procuradores\nestavam em lados opostos.")] + [InlineData("A pesquisadora chegou.", "A investigadora chegou.")] + [InlineData("Brincavam de tiras e ladrões.", "Brincavam de polícias e ladrões.")] + [InlineData("Os bandidos e tiras sabiam.", "Os bandidos e polícias sabiam.")] + [InlineData("A faxineira encontrou o corpo.", "A empregada de limpeza encontrou o corpo.")] + [InlineData("Ele é um batedor de carteiras.", "Ele é um carteirista.")] + [InlineData("Que cara de pau!", "Que descaramento!")] + [InlineData("Ela é uma patricinha.", "Ela é uma betinha.")] + [InlineData("O calouro chegou atrasado.", "O caloiro chegou atrasado.")] + [InlineData("Há um motivo para a\nmaioridade legal ser 18 anos.", "Há um motivo para a\nmaioridade legal ser 18 anos.")] + [InlineData("Ele estava mantendo\na distância mínima legal?", "Ele estava a manter\na distância mínima legal?")] + [InlineData("Digo, a justiça ir atrás desse\ncara, por causa do porte.", "Digo, a justiça ir atrás desse\ntipo, por causa do porte.")] + [InlineData("- Oi.\nCara, que susto.", "- Olá.\nMeu, que susto.")] + [InlineData("Ele é um cara legal.", "Ele é um tipo fixe.")] + public void BrazilianSlangBecomesEuropean(string text, string expected) => Assert.Equal(expected, Converter.Convert(text)); + + [Theory] + [InlineData("Tira a mão de mim!")] + [InlineData("Vê se tira esse site do ar.")] + [InlineData("A escola diz que ele\nsempre tira nota \"A\".")] + [InlineData("Quem tira as fotos?")] + [InlineData("Nossa vítima.")] + [InlineData("Um novo tipo de droga.")] + public void VerbTirarAndOtherMeaningsAreKept(string text) => Assert.Equal(text, Converter.Convert(text)); +} + +public sealed class PluralTemTests +{ + private static readonly PortugueseConverter Converter = new(); + + [Theory] + [InlineData("Tiras de rua tem a pior visão de tudo.", "Polícias de rua têm a pior visão de tudo.")] + [InlineData("Os polícias tem de trabalhar.", "Os polícias têm de trabalhar.")] + [InlineData("Todos os polícias tem armas.", "Todos os polícias têm armas.")] + [InlineData("Os miúdos da escola já tem férias.", "Os miúdos da escola já têm férias.")] + [InlineData("Dois homens tem a chave.", "Dois homens têm a chave.")] + [InlineData("- Os agentes tem\nde sair.", "- Os agentes têm\nde sair.")] + [InlineData("Os meus amigos tem-me ajudado.", "Os meus amigos têm-me ajudado.")] + [InlineData("Estas caixas contém provas.", "Estas caixas contêm provas.")] + [InlineData("Eles tem razão.", "Eles têm razão.")] + [InlineData("Elas não tem culpa.", "Elas não têm culpa.")] + [InlineData("Vocês tem dinheiro?", "Vocês têm dinheiro?")] + [InlineData("Eles vem amanhã.", "Eles vêm amanhã.")] + [InlineData("Disse que eles tem\nmedo.", "Disse que eles têm\nmedo.")] + public void PluralSubjectGetsTem(string br, string pt) => Assert.Equal(pt, Converter.Convert(br)); + + [Theory] + [InlineData("Muitas vezes tem de esperar.")] + [InlineData("Todos os dias tem algo novo.")] + [InlineData("Às vezes tem razão.")] + [InlineData("Depois tem de ir.")] + [InlineData("Lucas tem razão.")] + [InlineData("Carlos da Silva tem razão.")] + [InlineData("Para eles tem de ser assim.")] + [InlineData("Ele tem razão.")] + [InlineData("O pai dos miúdos tem razão.")] + public void SingularOrAdverbialKeepsTem(string text) => Assert.Equal(text, Converter.Convert(text)); + + [Theory] + [InlineData("Então seja bem-vinda ao clube.", "Então sê bem-vinda ao clube.")] + [InlineData("Cadê você?", "Onde estás?")] + [InlineData("Vá se foder!", "Vai-te foder!")] + [InlineData("Vão se foder.", "Vão-se foder.")] + [InlineData("Então me escute, seu viciado:", "Então escuta-me, seu viciado:")] + [InlineData("Por quê?", "Porquê?")] + [InlineData("Sabe por que ele saiu?", "Sabes porque ele saiu?")] + [InlineData("O motivo por que vim.", "O motivo por que vim.")] + [InlineData("Coloque no leite.", "Põe no leite.")] + [InlineData("Pegue suas coisas e saia.", "Pega nas tuas coisas e sai.")] + [InlineData("Pare de negar!", "Para de negar!")] + [InlineData("Não fale com ela.", "Não fales com ela.")] + [InlineData("Não se preocupe.", "Não te preocupes.")] + [InlineData("Senhor, espere aqui.", "Senhor, espere aqui.")] + [InlineData("Seja como for, vou.", "Seja como for, vou.")] + [InlineData("-Estou tentando…", "-Estou a tentar…")] + [InlineData("Tem uma vigia me mandando sair.", "Há uma vigia a mandar-me sair.")] + [InlineData("Tem um elevador saindo do chão.", "Há um elevador a sair do chão.")] + [InlineData("Comece descobrindo quem sabia.", "Começa por descobrir quem sabia.")] + [InlineData("A hipotermia começa quando o corpo arrefece.", "A hipotermia começa quando o corpo arrefece.")] + [InlineData("Nem fodendo.", "Nem pensar.")] + [InlineData("Não tem como apagar.", "Não há forma de apagar.")] + [InlineData("Sempre tem outra jogada.", "Há sempre outra jogada.")] + [InlineData("Tem um minuto?", "Tem um minuto?")] + [InlineData("Ele tem uma filha.", "Ele tem uma filha.")] + [InlineData("Não tem nada a ver.", "Não tem nada a ver.")] + [InlineData("Ela devia ter me deixado.", "Ela devia ter-me deixado.")] + [InlineData("Ele não tinha me dito.", "Ele não me tinha dito.")] + [InlineData("Eu teria me dado bem em Medicina.", "Eu ter-me-ia dado bem em Medicina.")] + [InlineData("Achei que tivesses me deixado entrar.", "Achei que me tivesses deixado entrar.")] + [InlineData("Talvez tenha se esquecido.", "Talvez se tenha esquecido.")] + [InlineData("Obrigado por ter me colocado nessa situação.", "Obrigado por ter-me posto nessa situação.")] + [InlineData("Eu me arrependo de uma coisa que eu disse.", "Eu arrependo-me de uma coisa que eu disse.")] + [InlineData("Está disposto a se reconciliar.", "Está disposto a reconciliar-se.")] + [InlineData("Noah, o que faz aqui?", "Noah, o que fazes aqui?")] + [InlineData("O que quer dizer isso?", "O que quer dizer isso?")] + [InlineData("Pelo bem de tudo que criamos aqui.", "Pelo bem de tudo o que criamos aqui.")] + [InlineData("Agradeço, mas dessa vez é diferente.", "Agradeço, mas desta vez é diferente.")] + [InlineData("Eu falei que ele vinha.", "Eu disse que ele vinha.")] + [InlineData("Se falar que eu trabalho aqui, morre.", "Se falar que eu trabalho aqui, morre.")] + [InlineData("Foi mal.", "Desculpa.")] + [InlineData("O teste foi mal.", "O teste foi mal.")] + [InlineData("É sério?", "A sério?")] + [InlineData("Uma arma de verdade.", "Uma arma a sério.")] + [InlineData("O que houve?", "O que se passou?")] + [InlineData("Bateram na porta.", "Bateram à porta.")] + [InlineData("Nós dois sabemos.", "Nós os dois sabemos.")] + [InlineData("Cheiro de queimado.", "Cheiro a queimado.")] + [InlineData("Não vamos a lugar nenhum.", "Não vamos a lado nenhum.")] + [InlineData("Peço desculpas.", "Peço desculpa.")] + [InlineData("Enquanto isso, ele saiu.", "Entretanto, ele saiu.")] + [InlineData("Faz dois anos que saí.", "Há dois anos que saí.")] + [InlineData("Ele faz anos amanhã.", "Ele faz anos amanhã.")] + [InlineData("Na época, eu era novo.", "Na altura, eu era novo.")] + [InlineData("Opa! Desculpa.", "Epá! Desculpa.")] + [InlineData("Puxa! Que susto.", "Bolas! Que susto.")] + [InlineData("Puxe o manifesto.", "Puxa o manifesto.")] + [InlineData("Ô, Noah!", "Ó, Noah!")] + [InlineData("Cansei de esperar.", "Fartei-me de esperar.")] + [InlineData("É da hora.", "É fixe.")] + [InlineData("Já era.", "Acabou.")] + [InlineData("Já era tarde.", "Já era tarde.")] + [InlineData("-Cai fora daqui.", "-Sai daqui.")] + [InlineData("Vai chegar rapidinho no green.", "Vai chegar num instante no green.")] + [InlineData("Ela vazou o vídeo.", "Ela divulgou o vídeo.")] + [InlineData("Amei o presente.", "Adorei o presente.")] + [InlineData("Quebrei o braço.", "Parti o braço.")] + [InlineData("Eles brigaram.", "Eles discutiram.")] + [InlineData("Estamos brigados.", "Estamos brigados.")] + [InlineData("Para que esse surto?", "Para que esse surto?")] + [InlineData("Maior fracasso!", "Maior fracasso!")] + [InlineData("Ele é um fracassado.", "Ele é um falhado.")] + [InlineData("Tomou os remédios?", "Tomou os medicamentos?")] + [InlineData("Deixa na pia.", "Deixa no lava-loiça.")] + [InlineData("Vou colocar aqui.", "Vou pôr aqui.")] + [InlineData("Eu podia ter colocado uma tocaia.", "Eu podia ter posto uma tocaia.")] + [InlineData("Ele gerencia a loja.", "Ele gere a loja.")] + [InlineData("Anotei a placa do carro.", "Anotei a matrícula do carro.")] + [InlineData("Srta. Neagley, a Judith a espera.", "Mna. Neagley, a Judith a espera.")] + [InlineData("Tina. Ebraheim.", "Tina. Ebraheim.")] + [InlineData("Gabe!", "Gabe!")] + [InlineData("Livre, leve e solta.", "Livre, leve e solta.")] + [InlineData("ATAQUE ZUMBI", "ATAQUE ZUMBI")] + [InlineData("Golfe é para os jovens, Carl.", "Golfe é para os jovens, Carl.")] + [InlineData("Sem gracinhas, Sra. Chore.", "Sem gracinhas, Sra. Chore.")] + [InlineData("Sr. Cole, desculpe entrar dessa forma.", "Sr. Cole, desculpe entrar dessa forma.")] + [InlineData("Vista para o mar e quarto conjugado.", "Vista para o mar e quarto conjugado.")] + [InlineData("Vista-se.", "Veste-te.")] + [InlineData("Fosse o que fosse, acabou.", "Fosse o que fosse, acabou.")] + [InlineData("Trouxa! O Walmart não precisa.", "Trouxa! O Walmart não precisa.")] + [InlineData("Pergunto-me por\nque ela fez isso.", "Pergunto-me\nporque ela fez isso.")] + [InlineData("Sinto o cheiro\nde algo delicioso.", "Sinto o cheiro\na algo delicioso.")] + [InlineData("Então pensei, vocês\ndois têm algum plano?", "Então pensei, vocês\nos dois têm algum plano?")] + [InlineData("Você tem se metido no meu trabalho.", "Tens-te metido no meu trabalho.")] + [InlineData("- Pistola, calibre 45.", "- Pistola, calibre 45.")] + [InlineData("Não que pareças o tipo de boa vizinha.", "Não que pareças o tipo de boa vizinha.")] + [InlineData("Relaxa, estou de boa.", "Relaxa, estou na boa.")] + [InlineData("Coloque-o no carro.", "Põe-no no carro.")] + [InlineData("Traga-o aqui.", "Trá-lo aqui.")] + [InlineData("Chame o tipo e faça-o fazer tudo.", "Chama o tipo e fá-lo fazer tudo.")] + [InlineData("Eles deram-a ao juiz.", "Eles deram-na ao juiz.")] + [InlineData("Alce americano.", "Alce americano.")] + [InlineData("Mas firme como rocha.", "Mas firme como rocha.")] + [InlineData("- Me ouça.\n- Me ouça você!", "- Ouve-me.\n- Ouve-me tu!")] + [InlineData("Ouça você!", "Ouve tu!")] + [InlineData("Me escute você!", "Escuta-me tu!")] + [InlineData("Olha você!", "Olha para ti!")] + [InlineData("Me diga você.", "Diz-me tu.")] + [InlineData("Me ama você?", "Amas-me?")] + [InlineData("Me ouve você?", "Ouves-me?")] + [InlineData("Odeio você!", "Odeio-te!")] + [InlineData("Vejo você amanhã.", "Vejo-te amanhã.")] + [InlineData("Se não, vamos ouví-lo.", "Se não, vamos ouvi-lo.")] + [InlineData("Quero possuí-lo.", "Quero possuí-lo.")] + [InlineData("Tiveram o merecimento de\nde serem os mais treinados,", "Tiveram o mérito\nde serem os mais treinados,")] + [InlineData("mas mostra que está na\ntrilha certa.", "mas mostra que está no\ntrilho certo.")] + [InlineData("Vamos fazer uma trilha noturna.", "Vamos fazer um trilho noturno.")] + [InlineData("Podemos fazer trilha.", "Podemos fazer caminhadas.")] + [InlineData("Adoro a trilha sonora do filme.", "Adoro a banda sonora do filme.")] + [InlineData("É um bom show, e ainda não começou.", "É um bom espetáculo, e ainda não começou.")] + [InlineData("para o reality show da Milli.", "para o reality show da Milli.")] + [InlineData("Trouxe uma torta para ele.", "Trouxe uma tarte para ele.")] + [InlineData("A linha está torta.", "A linha está torta.")] + [InlineData("Foi moleza.", "Foi canja.")] + [InlineData("Lógico, mas vão encontrá-lo antes.", "Claro, mas vão encontrá-lo antes.")] + [InlineData("É um raciocínio lógico.", "É um raciocínio lógico.")] + [InlineData("Sai, cansei das tuas mentiras.", "Sai, fartei-me das tuas mentiras.")] + [InlineData("És um covarde!", "És um cobarde!")] + [InlineData("Ela estava pelada no quarto.", "Ela estava nua no quarto.")] + [InlineData("Vamos jogar uma pelada no domingo.", "Vamos jogar uma futebolada no domingo.")] + [InlineData("Compartilhamos tudo.", "Partilhamos tudo.")] + [InlineData("O gato malhado fugiu.", "O gato malhado fugiu.")] + [InlineData("Ele aceitou uma propina.", "Ele aceitou um suborno.")] + [InlineData("Levei uma bronca do meu pai.", "Levei um raspanete do meu pai.")] + [InlineData("És fã de que time deles?", "És fã de que equipa deles?")] + [InlineData("Ela é hilária.", "Ela é hilariante.")] + [InlineData("Vim trazer um travesseiro antialérgico.", "Vim trazer uma almofada antialérgica.")] + [InlineData("Ganhei na loteria!", "Ganhei na lotaria!")] + [InlineData("Há muitos sem-teto aqui.", "Há muitos sem-abrigo aqui.")] + [InlineData("Mais um drinque?", "Mais uma bebida?")] + [InlineData("Vou de de carro.", "Vou de carro.")] + [InlineData("E, quando a gente para para pensar,", "E, quando a gente para para pensar,")] + [InlineData("de A a Z", "de A a Z")] + [InlineData("Não menciona eles.", "Não os menciona.")] + [InlineData("Comeste ela?", "Comeste-a?")] + [InlineData("Mandei ele sair.", "Mandei-o sair.")] + [InlineData("Não vou usar ela contra ti.", "Não vou usá-la contra ti.")] + [InlineData("Acho ele muito bonito.", "Acho-o muito bonito.")] + [InlineData("Pode ser ele.", "Pode ser ele.")] + [InlineData("Está a mandar eles fazerem coisas.", "Está a mandá-los fazer coisas.")] + [InlineData("Então manda você.", "Então manda tu.")] + [InlineData("Ele manda você embora.", "Ele manda-te embora.")] + [InlineData("Ele levou o Mischa até o estoque?", "Ele levou o Mischa até ao stock?")] + [InlineData("Ele lutou até o fim.", "Ele lutou até ao fim.")] + [InlineData("Fico aqui até as 19h.", "Fico aqui até às 19h.")] + [InlineData("Até o pai sabe.", "Até o pai sabe.")] + [InlineData("Vamos esperar até o Farooq aparecer.", "Vamos esperar até o Farooq aparecer.")] + [InlineData("O álibi dele confere.", "O álibi dele bate certo.")] + [InlineData("Isso confere com o depoimento.", "Isso bate certo com o depoimento.")] + [InlineData("Vou conferir.", "Vou verificar.")] + [InlineData("É meu primeiro dia.", "É o meu primeiro dia.")] + [InlineData("Qual é teu nome?", "Qual é o teu nome?")] + [InlineData("Ele é meu filho.", "Ele é meu filho.")] + [InlineData("Não é tua culpa.", "Não é tua culpa.")] + [InlineData("É meu também.", "É meu também.")] + [InlineData("O duto de ventilação está entupido.", "A conduta de ventilação está entupida.")] + [InlineData("Estava tudo dando certo.", "Estava tudo a dar certo.")] + [InlineData("Há algo muito estranho acontecendo.", "Há algo muito estranho a acontecer.")] + [InlineData("Estamos há quase dois anos trabalhando nisso.", "Estamos há quase dois anos a trabalhar nisso.")] + [InlineData("Virei a noite puxando.", "Virei a noite a puxar.")] + [InlineData("Foi apanhada bebendo em serviço?", "Foi apanhada a beber em serviço?")] + [InlineData("Não parecia uma pessoa tentando sobreviver.", "Não parecia uma pessoa a tentar sobreviver.")] + [InlineData("Invadindo a casa dele?", "A invadir a casa dele?")] + [InlineData("O que você quiser.", "O que quiseres.")] + [InlineData("Tendo em conta isso, sim.", "Tendo em conta isso, sim.")] + [InlineData("Olha só você fazendo uma entrada.", "Olha só para ti a fazer uma entrada.")] + [InlineData("Olha você fazendo isso!", "Olha para ti a fazer isso!")] + [InlineData("Olha você me enganando.", "Olha para ti a enganar-me.")] + [InlineData("Olha, você fazendo isso é estranho.", "Olha, você fazendo isso é estranho.")] + [InlineData("Sei que minha mãe traiu ele.", "Sei que a minha mãe o traiu.")] + [InlineData("Disse que o Jack matou ela.", "Disse que o Jack a matou.")] + [InlineData("Sei que minha mãe traiu você.", "Sei que a minha mãe te traiu.")] + [InlineData("Sei que minha mãe me traiu.", "Sei que a minha mãe me traiu.")] + [InlineData("Quando a polícia achar ele, liga.", "Quando a polícia o achar, liga.")] + [InlineData("Acho que a Maria vai ver ela.", "Acho que a Maria vai vê-la.")] + [InlineData("O tipo que conheci me ligou.", "O tipo que conheci ligou-me.")] + [InlineData("Manda você.", "Manda tu.")] + [InlineData("- Manda você!", "- Manda tu!")] + [InlineData("Incomoda você?", "Incomoda-te?")] + [InlineData("Liga você para ela.", "Liga-lhe.")] + [InlineData("Liga você para ela?", "Ligas tu para ela?")] + [InlineData("Ligue para eles!", "Liga-lhes!")] + [InlineData("Vou ligar para ela.", "Vou ligar-lhe.")] + [InlineData("Não, ainda não liguei para eles.", "Não, ainda não lhes liguei.")] + [InlineData("Ligarei para ela amanhã.", "Ligar-lhe-ei amanhã.")] + [InlineData("Ligue para mim.", "Liga-me.")] + [InlineData("Diz para ele que eu volto.", "Diz-lhe que eu volto.")] + [InlineData("Quando eu pedi para ele sair,", "Quando eu lhe pedi para sair,")] + [InlineData("Não menti para você.", "Não te menti.")] + [InlineData("Pergunta para ele.", "Pergunta-lhe.")] + [InlineData("Paguei para ele ficar calado.", "Paguei-lhe para ficar calado.")] + [InlineData("Está mentindo para mim.", "Está a mentir-me.")] + [InlineData("Sei que minha mãe ligou para ele.", "Sei que a minha mãe lhe ligou.")] + [InlineData("Só peça para ele tirar isso.", "Só lhe pede para tirar isso.")] + [InlineData("Só me ligue.", "Só me liga.")] + [InlineData("Apenas tente.", "Apenas tenta.")] + [InlineData("Não, engraçado é você achar isso.", "Não, engraçado és tu achares isso.")] + [InlineData("Era você vestindo roupas de mulher?", "Eras tu a vestir roupas de mulher?")] + [InlineData("Disse que o João ligou\npra ele do hotel,", "Disse que o João\nlhe ligou do hotel,")] + [InlineData("Então disse pra ela\nme encontrar em sua casa.", "Então disse-lhe\npara me encontrar na sua casa.")] + [InlineData("Nunca contou pra nós\nsobre isso.", "Nunca nos contou\nsobre isso.")] + [InlineData("Disse pra ele trazer seu carro.", "Disse-lhe para trazer o seu carro.")] + [InlineData("Eu o vi na TV,\nfalando sobre o caso.", "Eu vi-o na TV,\na falar sobre o caso.")] + [InlineData("Falando em dinheiro, ele ligou.", "Por falar em dinheiro, ele ligou.")] + [InlineData("Ela não quer que eu\nsaia de casa.", "Ela não quer que eu\nsaia de casa.")] + [InlineData("Isso não conta para ele.", "Isso não conta para ele.")] + [InlineData("Tenho uma pergunta para ela.", "Tenho uma pergunta para ela.")] + [InlineData("Se tiver perguntas para nós,", "Se tiver perguntas para nós,")] + [InlineData("Liguei para ele saber.", "Liguei para ele saber.")] + [InlineData("Olha para ele.", "Olha para ele.")] + [InlineData("Liguei para a Maria.", "Liguei para a Maria.")] + [InlineData("Não dá para ele vir.", "Não dá para ele vir.")] + public void CorpusAuditRules(string br, string pt) => Assert.Equal(pt, Converter.Convert(br)); + + [Theory] + [InlineData("Eu nunca sair da linha, Sofia.", "I never stepped out of bounds, Sofia.", "Eu nunca saí da linha, Sofia.")] + [InlineData("Eu nunca sair da linha.", "I don't ever step out of line.", "Eu nunca saio da linha.")] + [InlineData("Ele falar com ela ontem.", "He talked to her yesterday.", "Ele falou com ela ontem.")] + [InlineData("Nós chegar tarde.", "We arrived late.", "Nós chegámos tarde.")] + [InlineData("Eu nunca sair da linha.", "I could never step out of line.", "Eu nunca sair da linha.")] + [InlineData("Eu sair? Nunca!", "Me leave? Never!", "Eu sair? Nunca!")] + [InlineData("É para eu sair.", "I left.", "É para eu sair.")] + [InlineData("Ele quer que eu pegue vocês", "He wanted me to get you guys", "Ele quer que eu pegue vocês")] + public void BareInfinitiveUsesEnglishTense(string br, string english, string pt) => + Assert.Equal(pt, Converter.Convert(br, null, ReferenceHint.FromText(english))); + + [Fact] + public void BareInfinitiveWithoutReferenceIsOnlyFlagged() + { + Assert.Equal("Eu nunca sair da linha.", Converter.Convert("Eu nunca sair da linha.")); + Assert.Contains("saí", GrammarReview.Note("Eu nunca sair da linha.")!); + Assert.Contains("ter sido", GrammarReview.Note("Devia ter ser reformado.")!); + Assert.Null(GrammarReview.Note("É para eu sair.")); + Assert.Null(GrammarReview.Note("Eu sair? Nunca!")); + Assert.Null(GrammarReview.Note("Vai ter lugar amanhã.")); + Assert.Null(GrammarReview.Note("Eu nem sequer sei.")); + Assert.Null(GrammarReview.Note("Ela quer acabar comigo.")); + Assert.Null(GrammarReview.Note("Vou dizer-lhe quando eu estiver em posição.")); + Assert.Null(GrammarReview.Note("Vou dizer-lhe quando eu sair.")); + Assert.Null(GrammarReview.Note("ele sair no momento em que nos visitaram")); + } + + [Theory] + [InlineData("Não vou fala mais com vocês.", "Não vou falar mais com vocês.")] + [InlineData("Ele vai trabalha amanhã.", "Ele vai trabalhar amanhã.")] + [InlineData("Vamos come depois.", "Vamos comer depois.")] + [InlineData("Eles vão parti amanhã.", "Eles vão partir amanhã.")] + [InlineData("Ela ia fala comigo.", "Ela ia falar comigo.")] + [InlineData("Não vou mais fala com eles.", "Não vou mais falar com eles.")] + [InlineData("Não vais fala comigo.", "Não vais falar comigo.")] + [InlineData("Você vai fala comigo.", "Vais falar comigo.")] + [InlineData("Vou\nfala com eles.", "Vou\nfalar com eles.")] + [InlineData("Não vou fala.", "Não vou falar.")] + [InlineData("NÃO VOU FALA.", "NÃO VOU FALAR.")] + [InlineData("Vou questiona a decisão.", "Vou questionar a decisão.")] + [InlineData("Vou me lembra disso.", "Vou lembrar-me disso.")] + public void MissingInfinitiveEndingAfterIr(string br, string pt) + { + Assert.Equal(pt, Converter.Convert(br)); + Assert.Equal(pt, Converter.Convert(br, null, ReferenceHint.FromText("I'm not going to talk to them anymore."))); + Assert.Equal(pt, Converter.Convert(pt)); + Assert.NotNull(GrammarReview.Note(br)); + Assert.Null(GrammarReview.Note(pt)); + } + + [Theory] + [InlineData("Vou falar com eles.")] + [InlineData("Ele fala comigo.")] + [InlineData("Não fala comigo.")] + [InlineData("Vai para casa.")] + [InlineData("Vou embora.")] + [InlineData("Não vai nada.")] + [InlineData("Vai fora de horas.")] + [InlineData("Vai que dá certo.")] + [InlineData("Vai Sara.")] + [InlineData("Vou a pé.")] + [InlineData("Vai, fala com eles.")] + [InlineData("Ela quer ajuda.")] + [InlineData("Foi luta até ao fim.")] + [InlineData("Vou xyzabcde.")] + [InlineData("Vou fala-lo.")] + [InlineData("Vai à luta.")] + public void MissingInfinitiveEndingDoesNotGuessOtherConstructions(string text) + { + Assert.Equal(text, PortugueseConverter.MissingInfinitiveEnding.Apply(text)); + Assert.Empty(PortugueseConverter.MissingInfinitiveEnding.Find(text)); + Assert.Null(GrammarReview.Note(text)); + } + + [Fact] + public void MissingInfinitiveEndingSharesRepairAndReview() + { + Assert.Contains("vou falar", GrammarReview.Note("Não vou fala mais com vocês.")!); + Assert.Contains("vou falar", GrammarReview.Note("Não vou fala mais com vocês.")!); + Assert.Null(GrammarReview.Note("Não vou falar mais com vocês.")); + var local = new PortugueseLocalWordList(); + local.Ignored.Add("fala"); + Assert.Equal("Não vou fala mais com vocês.", new PortugueseConverter(localWordList: local).Convert("Não vou fala mais com vocês.")); + } + + [Theory] + [InlineData("I never stepped out of bounds.", true, false)] + [InlineData("He went home.", true, false)] + [InlineData("I never do that.", false, true)] + [InlineData("I will never step out.", false, false)] + [InlineData("I'm going to leave.", false, false)] + [InlineData("I talked to her.", true, false)] + public void ReferenceHintTense(string english, bool past, bool present) + { + var hint = ReferenceHint.FromText(english)!; + Assert.Equal(past, hint.Past); + Assert.Equal(present, hint.Present); + } + + [Theory] + [InlineData("Ele chegou ontem à noite com o carro.", "He came in last night with the car.", true)] + [InlineData("Tu.", "You.", false)] + [InlineData("O que foi?", "What? In 15 years of marriage, I never once had to come down here.", false)] + [InlineData("Uma frase qualquer.", null, false)] + public void TranslationReviewSkipsShortAndMisalignedLines(string pt, string? english, bool comparable) => + Assert.Equal(comparable, LocalChecks.IsComparable(pt, english)); +} diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/EnglishExpressionTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/EnglishExpressionTests.cs new file mode 100644 index 00000000..60120f46 --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/EnglishExpressionTests.cs @@ -0,0 +1,176 @@ +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; + +namespace BrazilianToEuropeanPortuguese.Tests; + +public sealed class EnglishExpressionTests +{ + public static TheoryData ReviewedExpressions => new() + { + { "I busted my hump.", "work extremely hard", "Dei cabo das costas." }, + { "Stop busting my chops.", "harass", "Para de me chatear." }, + { "It's a piece of cake.", "very easy task", "É canja." }, + { "Break a leg!", "good luck", "Boa sorte!" }, + { "Cut it out!", "stop doing that", "Chega!" }, + { "Beats me.", "I do not know", "Não faço ideia." }, + { "Hang in there.", "keep going despite difficulty", "Aguenta firme." }, + { "I'm all ears.", "I am ready to listen", "Sou todo ouvidos." }, + { "It's on the house.", "free of charge", "É oferta da casa." }, + { "It costs an arm and a leg.", "be very expensive", "Custa uma fortuna." }, + { "I'm under the weather.", "slightly ill", "Estou adoentado." }, + { "Don't spill the beans.", "reveal a secret", "Não contes tudo." }, + { "He let the cat out of the bag.", "reveal a secret", "Ele revelou o segredo." }, + { "Are you pulling my leg?", "tease", "Estás a gozar?" }, + { "He kicked the bucket.", "die", "Ele bateu a bota." }, + { "Let's hit the sack.", "go to bed", "Vamos para a cama." }, + { "Let's call it a day.", "stop for today", "Ficamos por hoje." }, + { "It's not my cup of tea.", "not something I like", "Não é a minha praia." }, + { "Sleep on it.", "think about it before deciding", "Pensa melhor." }, + { "She got cold feet.", "lose courage at the last moment", "Ela ficou com medo." }, + { "In a nutshell, we won.", "in summary", "Em suma, ganhámos." }, + { "The ball is in your court.", "it is your turn to decide", "Agora é contigo." }, + { "My bad.", "it was my mistake", "Foi erro meu." }, + { "Hold your horses.", "wait and calm down", "Tem calma." }, + { "Get a grip.", "control your emotions", "Controla-te." }, + { "Don't jump the gun.", "act too early", "Não te precipites." }, + { "It came out of the blue.", "unexpectedly", "Aconteceu de repente." }, + { "It's a rule of thumb.", "general practical guideline", "É uma regra geral." }, + { "It was the last straw.", "final problem that exhausts patience", "Foi a gota de água." }, + { "He blew off some steam.", "release tension", "Ele desabafou." }, + { "You're on thin ice.", "in a risky situation", "Estás em perigo." }, + { "Bite the bullet.", "face an unpleasant situation bravely", "Enfrenta a situação." }, + { "They're a dime a dozen.", "very common", "Há aos pontapés." }, + { "Let's hit the road.", "leave on a journey", "Vamos embora." }, + { "He bent over backwards.", "make an exceptional effort", "Ele fez de tudo." }, + { "Do it by the book.", "according to the rules", "Faz isso segundo as regras." }, + { "It's off the record.", "confidentially", "É confidencial." }, + { "It's a long shot.", "an unlikely possibility", "É uma hipótese remota." }, + { "You bet.", "certainly", "Podes crer." }, + { "It's no big deal.", "not important", "Não tem importância." }, + { "Keep your chin up.", "stay optimistic", "Anima-te." }, + { "Let's break the ice.", "ease initial social tension", "Vamos quebrar o gelo." }, + { "I'm absolutely knackered.", "I am exhausted", "Estou de rastos." }, + { "I'm totally skint.", "I have no money", "Estou sem dinheiro." }, + { "I'm flat broke.", "I have no money", "Estou sem dinheiro." }, + { "I'm beat.", "I am exhausted", "Estou de rastos." }, + { "I'm chuffed to bits.", "very pleased", "Estou muito contente." }, + { "I was gobsmacked.", "astonished", "Fiquei de boca aberta." }, + { "Are you taking the mickey?", "make fun", "Estás a gozar?" }, + { "Are you taking the piss?", "make fun", "Estás a gozar?" }, + { "It's doing my head in.", "cause frustration", "Está a dar cabo da cabeça." }, + { "Let's touch base tomorrow.", "communicate briefly", "Vamos falar amanhã." }, + { "Let's get the ball rolling.", "start the activity", "Vamos começar." }, + { "We're on the same page.", "in agreement", "Estamos de acordo." }, + { "She learned the ropes.", "learn how things work", "Ela aprendeu o ofício." }, + { "Pull your weight.", "contribute fairly", "Faz a tua parte." }, + { "We're back to square one.", "starting again", "Voltámos à estaca zero." }, + { "It's back to the drawing board.", "starting again", "É voltar à estaca zero." }, + { "Keep me in the loop.", "informed about developments", "Mantém-me a par." }, + { "It's on the back burner.", "postponed for now", "Fica em segundo plano." }, + { "Give me a ballpark figure.", "rough estimate", "Dá-me uma estimativa." }, + { "We paid through the nose.", "pay an excessive price", "Pagámos os olhos da cara." }, + { "I need to spend a penny.", "use the toilet", "Preciso de ir à casa de banho." }, + { "And Bob's your uncle.", "it is done", "E pronto." }, + { "Can I take a rain check?", "postpone accepting the invitation", "Pode ficar para outra vez?" }, + { "She works to bring home the bacon.", "earn money to support the family", "Ela trabalha para sustentar a família." }, + { "The kids are full of beans.", "very energetic", "Os miúdos estão cheios de energia." }, + { "It was a blessing in disguise.", "an apparent misfortune that turns out well", "Há males que vêm por bem." }, + { "The plan went pear-shaped.", "go wrong", "O plano correu mal." }, + { "I'm in a pickle.", "in a difficult situation", "Estou numa alhada." }, + { "We struggle to make ends meet.", "afford basic living expenses", "É difícil pagar as despesas." }, + { "We arrived in the nick of time.", "just before it was too late", "Chegámos mesmo a tempo." }, + { "It happens once in a blue moon.", "very rarely", "Acontece raramente." }, + { "It's a storm in a teacup.", "an exaggerated reaction to a small problem", "É uma tempestade num copo de água." }, + { "You're barking up the wrong tree.", "look in the wrong place for an answer", "Estás enganado." }, + { "That's a load of old cobblers.", "nonsense", "São disparates." }, + { "That's a load of old pony.", "nonsense", "São tretas." }, + { "That's a load of rubbish.", "nonsense", "São disparates." }, + { "We burned the midnight oil.", "work late into the night", "Trabalhámos pela noite dentro." }, + { "I'll kill two birds with one stone.", "achieve two goals with one action", "Mato dois coelhos de uma cajadada." }, + { "He threw a spanner in the works.", "disrupt the plans", "Ele estragou os planos." }, + { "Get it off your chest.", "talk about a worry", "Desabafa." }, + { "He's all mouth and no trousers.", "all talk and no action", "É muito paleio e pouca ação." }, + { "It's a dog's breakfast.", "a badly organized mess", "É uma trapalhada." }, + { "They're like two peas in a pod.", "very similar to each other", "São como duas gotas de água." }, + { "We avoid the elephant in the room.", "an obvious problem nobody discusses", "Evitamos falar do problema." }, + { "Have a butcher's at this.", "take a look", "Dá uma vista de olhos." }, + { "He threw a wobbly.", "have an angry outburst", "Ele fez uma cena." }, + { "We had a whale of a time.", "have a wonderful time", "Divertimo-nos imenso." }, + { "She threw in the towel.", "give up", "Ela desistiu." }, + { "It's a tough nut to crack.", "a difficult problem to solve", "É um osso duro de roer." }, + { "It's a wild goose chase.", "a futile search", "É uma busca inútil." }, + { "He's on his tod.", "alone", "Está sozinho." }, + }; + + [Theory] + [MemberData(nameof(ReviewedExpressions))] + public void ReviewedExpressionsHaveMeaningsAndHints(string english, string meaning, string portuguese) + { + Assert.Contains(meaning, IdiomHints.MeaningReference(english)); + Assert.NotNull(IdiomHints.Note("Tradução por verificar.", english)); + Assert.Null(IdiomHints.Note(portuguese, english)); + } + + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData("The reference is ordinary dialogue.")] + [InlineData("I'm down.")] + [InlineData("Cheers!")] + [InlineData("You have a butcher's knife.")] + [InlineData("I am a gobsmackedness specialist.")] + [InlineData("I'm beaten.")] + [InlineData("I'm beat up.")] + [InlineData("You bet on the horse.")] + public void AmbiguousOrUnrecognisedEnglishHasNoInventedMeaning(string? english) => + Assert.Null(IdiomHints.MeaningReference(english)); + + [Fact] + public void MeaningsRetainSentenceContextAndHandleTagsLineBreaksAndApostrophes() + { + Assert.Equal("We arrived just before it was too late to help her.", + IdiomHints.MeaningReference("We arrived in the nick\nof time to help her.")); + Assert.Equal("And it is done.", IdiomHints.MeaningReference("And Bob’s your uncle.")); + Assert.Equal("They are very energetic but he is alone.", + IdiomHints.MeaningReference("They are full of beans but he is on his tod.")); + } + + [Theory] + [InlineData("Estou quebrado.", "I'm broke.", "Estou sem dinheiro.")] + [InlineData("Estou quebrada.", "I am skint.", "Estou sem dinheiro.")] + [InlineData("Eu estou quebrado.", "I'm flat broke.", "Eu estou sem dinheiro.")] + [InlineData("Estou quebrado.", "I'm beat.", "Estou de rastos.")] + [InlineData("Estou quebrada.", "I’m absolutely knackered.", "Estou de rastos.")] + [InlineData("ESTOU QUEBRADO!", "I'M TOTALLY SKINT!", "ESTOU SEM DINHEIRO!")] + public void NarrowSlangCorrectionsNeedBothLanguages(string source, string english, string expected) => + Assert.Equal(expected, new PortugueseConverter().Convert(source, null, ReferenceHint.FromText(english))); + + [Theory] + [InlineData("Estou quebrado.", "I'm broken.")] + [InlineData("Estou quebrado.", "I'm broke. He is exhausted.")] + [InlineData("Estou quebrado.", "He is skint.")] + [InlineData("Estou quebrado.", "I'm not skint.")] + [InlineData("O vidro está quebrado.", "I'm skint.")] + [InlineData("Estou quebrado. Ela também.", "I'm skint.")] + public void AmbiguousSlangDoesNotTriggerNewCorrections(string source, string english) + { + var converter = new PortugueseConverter(); + Assert.Equal(converter.Convert(source), converter.Convert(source, null, ReferenceHint.FromText(english))); + } + + [Theory] + [InlineData("vocabulary")] + [InlineData("colloquial")] + [InlineData("reference-idioms")] + public void CorrectionsRespectExistingSwitches(string disabled) + { + var options = disabled switch + { + "vocabulary" => new ConversionOptions(Vocabulary: false), + "colloquial" => new ConversionOptions(Colloquial: false), + _ => new ConversionOptions(DisabledRules: disabled), + }; + var converter = new PortugueseConverter(options); + Assert.Equal(converter.Convert("Estou quebrado."), + converter.Convert("Estou quebrado.", null, ReferenceHint.FromText("I'm skint."))); + } +} diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/LocalChecksTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/LocalChecksTests.cs new file mode 100644 index 00000000..8d5c5d13 --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/LocalChecksTests.cs @@ -0,0 +1,278 @@ +using System.Text.Json; +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; +using SubtitleEdit.Plugins.Shared; +using Xunit; +using Xunit.Abstractions; + +namespace BrazilianToEuropeanPortuguese.Tests; + +// ReferenceTests changes XDG_DATA_HOME for the process; do not run beside it. +[Collection("XdgDataHome")] +public sealed class LocalChecksTests(ITestOutputHelper output) +{ + private static string[] Texts(string original, string converted) => + JudgeAlternatives.Generate(original, converted).Select(c => c.Text).ToArray(); + + [Fact] + public void PluralSubjectOffersTem() + { + Assert.Contains("Os adultos têm muitas coisas.", Texts("Os adultos tem muitas coisas.", "Os adultos tem muitas coisas.")); + } + + [Theory] + [InlineData("Qual é, tem de nos dar algo mais.")] + [InlineData("Mas tem de vir.")] + [InlineData("Ele tem razão. Eles sabem.")] + public void NoPluralSubjectOffersNoTem(string text) => Assert.DoesNotContain(Texts(text, text), t => t.Contains("têm")); + + [Fact] + public void PluralVerbAlwaysOffersSingular() + { + Assert.Contains("Dar permissão para abrir os armários tem implicações.", + Texts("Dar permissão para abrir os armários tem implicações.", "Dar permissão para abrir os armários têm implicações.")); + } + + [Fact] + public void RapazOnlyForGarotoAndKeepsCase() + { + Assert.Contains("Rapaz, que susto.", Texts("Garoto, que susto.", "Miúdo, que susto.")); + Assert.Empty(Texts("Criança, que susto.", "Miúdo, que susto.")); + } + + [Fact] + public void TiraOffersPoliciaAndMauOffersMa() + { + Assert.Contains("Ele é um polícia.", Texts("Ele é um tira.", "Ele é um tira.")); + Assert.Contains("Tem coisas realmente más.", Texts("Tem coisas realmente ruins.", "Tem coisas realmente maus.")); + } + + [Fact] + public void ScoringTextHasNoTagsOrLineBreaks() => + Assert.Equal("Olá, Ann. Tudo bem?", LocalChecks.ForScoring("Olá, Ann.\r\n{\\an8}Tudo bem?")); + + [Fact] + public async Task IdiomMeaningChecksOriginalAndConvertedAgainstPlainEnglish() + { + var seen = new List(); + Task Embed(string? text) + { + seen.Add(text); + return Task.FromResult(text == "It's a very easy task." + ? new[] { 1f, 0f } : text == "É canja." ? new[] { .8f, .6f } : new[] { .2f, .9797959f }); + } + var line = new CheckLine(0, "É um pedaço de bolo.", "É canja.", null, "It's a piece of cake."); + var note = await LocalChecks.IdiomMeaningNoteAsync(line, line.Converted, Embed); + Assert.Contains("possible English idiom", note); + Assert.Contains("before the rules", note); + Assert.Contains("after", note); + Assert.Equal(new[] { "It's a very easy task.", line.Original, line.Converted }, seen); + } + + [Theory] + [InlineData(.8f, .8f, false)] + [InlineData(.2f, .2f, true)] + [InlineData(.8f, .2f, true)] + [InlineData(.8f, .75f, true)] + [InlineData(.8f, .78f, false)] + [InlineData(.4501f, .4501f, false)] + [InlineData(.4499f, .4499f, true)] + [InlineData(.5999f, .54f, false)] + [InlineData(.6001f, .54f, true)] + [InlineData(.8f, .7601f, false)] + [InlineData(.8f, .7599f, true)] + [InlineData(.56f, .4601f, false)] + [InlineData(.56f, .4599f, true)] + public async Task IdiomMeaningUsesExistingThresholds(float before, float after, bool flagged) + { + var line = new CheckLine(0, "Original.", "Converted.", null, "I'm skint."); + Task Embed(string? text) => Task.FromResult(text == "I have no money." + ? new[] { 1f, 0f } : new[] { text == line.Original ? before : after, 0f }); + var note = await LocalChecks.IdiomMeaningNoteAsync(line, line.Converted, Embed); + Assert.Equal(flagged, note != null); + } + + [Fact] + public async Task IdiomMeaningDoesNotEmbedWhenNoGlossExists() + { + var line = new CheckLine(0, "Olá.", "Olá.", null, "Hello."); + Assert.Null(await LocalChecks.IdiomMeaningNoteAsync(line, line.Converted, + _ => throw new InvalidOperationException("No embedding should be requested."))); + } + + [Fact] + public async Task IdiomMeaningReusesUnchangedTextAndDoesNotHideEmbeddingFailures() + { + var line = new CheckLine(0, "Estou sem dinheiro.", "Estou sem dinheiro.", null, "I'm skint."); + var calls = 0; + Task Embed(string? _) { calls++; return Task.FromResult(new[] { 1f, 0f }); } + Assert.Null(await LocalChecks.IdiomMeaningNoteAsync(line, line.Converted, Embed)); + Assert.Equal(2, calls); + await Assert.ThrowsAsync(() => LocalChecks.IdiomMeaningNoteAsync(line, line.Converted, + _ => throw new IOException("Embedding failed."))); + } + + [Fact] + public void TokenGrammarForcesTokenIds() => + Assert.Equal("root ::= <[12]> <[345]>", EmbeddingRuntime.TokenGrammar(new[] { 12, 345 })); + + [Fact] + public void CheckSettingsAreSavedButPathsAreNot() + { + var json = JsonSerializer.Serialize(new EmbeddingSettings(JudgeModelPath: "/x/judge.gguf", CheckMeaning: false, UseJudge: true)); + var back = JsonSerializer.Deserialize(json)!; + Assert.False(back.CheckMeaning); + Assert.True(back.UseJudge); + Assert.DoesNotContain("judge.gguf", json); + } + + [Fact] + public async Task NothingRunsWithoutModels() + { + var settings = new EmbeddingSettings(UseJudge: false, CheckMeaning: false); + var lines = new[] + { + new CheckLine(0, "Eles tem razão.", "Eles tem razão.", null, null), + new CheckLine(1, "Estou no meu Tod.", "Estou no meu Tod.", null, "I'm on my tod."), + }; + var (results, summary) = await LocalChecks.RunAsync(lines, settings, new Progress(_ => { }), CancellationToken.None); + Assert.Empty(results); + Assert.Equal(string.Empty, summary); + } + + [OptInFact("PTPT_TEST_JUDGE", "needs the downloaded Gervásio model and llama-server")] + public async Task GervasioPrefersAgreement() + { + var settings = EmbeddingAssets.WithInstalledFiles(EmbeddingAssets.Load() with { UseJudge = true }); + await using var runtime = await EmbeddingRuntime.StartJudgeAsync(settings, new Progress(_ => { }), CancellationToken.None); + const string context = "Legendas de uma série, em português europeu (de Portugal):\n"; + Assert.True(await runtime.ScoreAsync(context, "Ela tem dois filhos.", CancellationToken.None) + > await runtime.ScoreAsync(context, "Ela têm dois filhos.", CancellationToken.None)); + var lines = new[] + { + new CheckLine(0, "Ouvi dizer que o seu garoto é o detetive chefe?", "Ouvi dizer que o seu miúdo é o detetive chefe?", null, null), + new CheckLine(1, "Ele tira o casaco.", "Ele tira o casaco.", null, null), + }; + var (results, _) = await LocalChecks.RunAsync(lines, settings with { CheckMeaning = false }, new Progress(_ => { }), CancellationToken.None); + Assert.Equal("Ouvi dizer que o seu rapaz é o detetive chefe?", results[0].Text); + Assert.False(results.ContainsKey(1)); + } + + [OptInFact("PTPT_TEST_IDIOM_MODEL", "real MiniLM idiom and screenshot checks with the installed local model")] + public async Task RealMiniLmChecksIdiomReadingsAndScreenshotCue() + { + var folder = Environment.GetEnvironmentVariable("PTPT_EMBEDDING_DIR") ?? EmbeddingAssets.DirectoryPath; + var settings = new EmbeddingSettings( + Directory.GetFiles(folder, OperatingSystem.IsWindows() ? "llama-server.exe" : "llama-server", + SearchOption.AllDirectories).Single(), Path.Combine(folder, EmbeddingAssets.ModelFile)); + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(3)); + await using var runtime = await EmbeddingRuntime.StartAsync(settings, new Progress(output.WriteLine), timeout.Token); + async Task Embed(string? text) => text == null ? null + : await runtime.EmbedAsync(ReferenceAligner.Clean(text), timeout.Token); + const string reference = "He was on his tod."; + var reading = IdiomHints.MeaningReference(reference)!; + var english = (await Embed(reading))!; + var faithful = (await Embed("Ele estava sozinho."))!; + var literal = (await Embed("Ele estava no seu Tod."))!; + var goodScore = ReferenceAligner.Dot(faithful, english); + var literalScore = ReferenceAligner.Dot(literal, english); + output.WriteLine($"Idiom reading: faithful {goodScore:0.000}, literal {literalScore:0.000}."); + Assert.True(goodScore > literalScore); + var line = new CheckLine(0, "Você não lembra de mim,\nmas vou te contar uma parada", + "Não te lembras de mim,\nmas vou contar-te uma coisa", null, + "You don't remember me, but I have something to tell you"); + var before = (await Embed(line.Original))!; + var after = (await Embed(line.Converted))!; + var originalEnglish = (await Embed(line.Reference))!; + output.WriteLine($"Screenshot: BR/PT {ReferenceAligner.Dot(before, after):0.000}; " + + $"BR/EN {ReferenceAligner.Dot(before, originalEnglish):0.000}; PT/EN {ReferenceAligner.Dot(after, originalEnglish):0.000}."); + Assert.Equal(line.Converted, new PortugueseConverter(new ConversionOptions(PostAgreement: false)) + .Convert(line.Original, null, ReferenceHint.FromText(line.Reference))); + Assert.True(ReferenceAligner.Dot(before, after) >= LocalChecks.MeaningThreshold); + } + + [OptInFact("PTPT_TEST_FILE_REVIEW", "local full-file reference alignment, conversion and meaning review")] + public async Task RealSubtitlePipelinePreservesCuesAndReviewsEveryConvertedLine() + { + var sourcePath = Environment.GetEnvironmentVariable("PTPT_SOURCE_SRT") + ?? throw new InvalidOperationException("Set PTPT_SOURCE_SRT."); + var englishPath = Environment.GetEnvironmentVariable("PTPT_ENGLISH_SRT") + ?? throw new InvalidOperationException("Set PTPT_ENGLISH_SRT."); + var source = ReferenceAligner.Load(sourcePath); + var reference = ReferenceAligner.Load(englishPath); + var settings = EmbeddingAssets.WithInstalledFiles(new EmbeddingSettings(UseEmbeddings: true)); + Assert.True(LocalChecks.MeaningReady(settings)); + using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(10)); + var progress = new Progress(output.WriteLine); + var (alignment, alignmentNote) = await ReferenceRunner.AlignAsync(source, reference, settings, progress, timeout.Token); + output.WriteLine(alignment.Describe() + alignmentNote); + Assert.True(alignment.Coverage >= ReferenceAligner.MinimumUsefulCoverage); + var options = new ConversionOptions(PostAgreement: false, ValidateSpelling: true); + var converted = SubtitleConversion.Convert(source, options, english: alignment.Texts); + Assert.Equal(source.Count, converted.Count); + Assert.All(converted, cue => + { + Assert.False(string.IsNullOrWhiteSpace(cue.Text)); + Assert.DoesNotMatch(@"[\uE000-\uF8FF]", cue.Text); + }); + var lines = converted.Select((cue, i) => new CheckLine(i, source[i].Text, cue.Text, + i == 0 ? null : converted[i - 1].Text, alignment.Texts[i])).ToArray(); + var (results, summary) = await LocalChecks.RunAsync(lines, settings, progress, timeout.Token); + output.WriteLine(summary); + Assert.All(results, result => Assert.Equal(converted[result.Key].Text, result.Value.Text)); + Assert.Contains("MiniLM:", summary); + var roundTrip = SubRipParser.Parse(SubRipParser.Serialize(source.Select((cue, i) => new SrtBlock + { + StartMs = cue.StartMs, EndMs = cue.EndMs, Text = converted[i].Text, + }).ToList())); + Assert.Equal(source.Select(cue => (cue.StartMs, cue.EndMs)), roundTrip.Select(cue => (cue.StartMs, cue.EndMs))); + var screenshotCue = source.FindIndex(cue => cue.Text.Contains("vou te contar uma parada", StringComparison.Ordinal)); + if (screenshotCue >= 0) + { + Assert.Contains("vou contar-te uma coisa", converted[screenshotCue].Text); + Assert.Contains("something to tell you", alignment.Texts[screenshotCue]); + output.WriteLine("Screenshot cue: converted correctly with MiniLM-aligned English."); + } + var unknown = NaturaDictionary.Load(options.PostAgreement).UnknownWords(converted.Select(cue => cue.Text)); + output.WriteLine($"Reviewed {source.Count} cues; dictionary reports {unknown.Length} unrecognised words (not necessarily errors)."); + } + + [OptInFact("PTPT_TEST_VULKAN", "real MiniLM meaning review on a Vulkan GPU")] + public async Task MissingInfinitiveEndingKeepsMeaningOnVulkan() + { + var settings = EmbeddingAssets.WithInstalledFiles(new EmbeddingSettings(Vulkan: true, + Device: Environment.GetEnvironmentVariable("PTPT_VULKAN_DEVICE") ?? "Vulkan0")); + Assert.True(LocalChecks.MeaningReady(settings), "MiniLM and llama-server must be installed in the plugin's download folder."); + const string original = "Não vou fala mais com vocês."; + const string english = "I'm not going to talk to you anymore."; + var converted = new PortugueseConverter().Convert(original); + Assert.Equal("Não vou falar mais com vocês.", converted); + Assert.NotNull(GrammarReview.Note(original)); + Assert.Null(GrammarReview.Note(converted)); + Assert.True(LocalChecks.IsComparable(original, english)); + + await using (var runtime = await EmbeddingRuntime.StartAsync(settings, new Progress(output.WriteLine), CancellationToken.None)) + { + Assert.True(runtime.UsesGpu); + var before = await runtime.EmbedAsync(ReferenceAligner.Clean(original), CancellationToken.None); + var after = await runtime.EmbedAsync(ReferenceAligner.Clean(converted), CancellationToken.None); + var reference = await runtime.EmbedAsync(ReferenceAligner.Clean(english), CancellationToken.None); + var similarity = ReferenceAligner.Dot(before, after); + var beforeEnglish = ReferenceAligner.Dot(before, reference); + var afterEnglish = ReferenceAligner.Dot(after, reference); + output.WriteLine($"Original/corrected: {similarity:0.000}; original/English: {beforeEnglish:0.000}; corrected/English: {afterEnglish:0.000}"); + Assert.True(similarity >= LocalChecks.MeaningThreshold); + Assert.True(afterEnglish >= LocalChecks.TranslationThreshold); + Assert.True(beforeEnglish - afterEnglish < LocalChecks.ReferenceDrop); + } + + var lines = new[] + { + new CheckLine(0, original, converted, null, english), + new CheckLine(1, original, original, null, english), + }; + var (results, summary) = await LocalChecks.RunAsync(lines, settings, new Progress(output.WriteLine), CancellationToken.None); + Assert.Empty(results); + Assert.Contains("0 line(s) whose meaning may have changed", summary); + Assert.Contains("0 line(s) that may not match the English", summary); + } +} diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/OrthographyTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/OrthographyTests.cs new file mode 100644 index 00000000..4b7f74cd --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/OrthographyTests.cs @@ -0,0 +1,198 @@ +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; +using SubtitleEdit.Plugins.Shared; +using System.IO; +using System; +using System.Formats.Tar; +using System.IO.Compression; +using System.Net; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; + +namespace BrazilianToEuropeanPortuguese.Tests; + +public sealed class OrthographyTests +{ + [Theory] + [InlineData("A ação do diretor.", "A acção do director.")] + [InlineData("Os atores e as atrizes.", "Os actores e as actrizes.")] + [InlineData("Um projeto ativo.", "Um projecto activo.")] + [InlineData("A receção do espetáculo.", "A recepção do espectáculo.")] + [InlineData("O objeto elétrico.", "O objecto eléctrico.")] + [InlineData("O teto está ótimo.", "O tecto está óptimo.")] + [InlineData("A arquitetura atual.", "A arquitectura actual.")] + [InlineData("A proteção dos espetadores.", "A protecção dos espectadores.")] + [InlineData("AÇÃO E DIREÇÃO", "ACÇÃO E DIRECÇÃO")] + [InlineData("A ação.\\N", "A acção.\\N")] + [InlineData("A ideia heroica.", "A ideia heroica.")] + [InlineData("O facto e o contacto.", "O facto e o contacto.")] + [InlineData("Para a mãe.", "Para a mãe.")] + [InlineData("Eles veem e leem.", "Eles vêem e lêem.")] + public void PreAgreement(string text, string expected) + { + var converter = new PortugueseConverter(new ConversionOptions(PostAgreement: false)); + Assert.Equal(expected, converter.Convert(text)); + } + + [Theory] + [InlineData("A acção do director.", "A ação do diretor.")] + [InlineData("Um projecto activo.", "Um projeto ativo.")] + [InlineData("O objecto eléctrico.", "O objeto elétrico.")] + public void PostAgreement(string text, string expected) => + Assert.Equal(expected, new PortugueseConverter().Convert(text)); + + [Fact] + public void DisablingSpellingDisablesAgreementConversion() + { + var converter = new PortugueseConverter(new ConversionOptions(Spelling: false, PostAgreement: false)); + Assert.Equal("O projeto.", converter.Convert("O projeto.")); + } + + [Fact] + public void IgnoredPhrasesRemainProtected() + { + var list = new PortugueseLocalWordList(); + list.Ignored.Add("projeto"); + Assert.Equal("O projeto.", new PortugueseConverter(new ConversionOptions(PostAgreement: false), list).Convert("O projeto.")); + } + + [Fact] + public void SettingsRoundTripAndLegacyDefaults() + { + var options = new ConversionOptions(Vocabulary: false, PostAgreement: false, ValidateSpelling: true); + Assert.Equal(options, ConversionOptions.Load(new PluginRequest + { + Settings = options.ToJson(), SettingsVersion = ConversionOptions.Version, + })); + var legacy = System.Text.Json.JsonSerializer.SerializeToElement(new { spelling = false, youToTu = false }); + Assert.Equal(new ConversionOptions(Spelling: false, YouToTu: false), + ConversionOptions.Load(new PluginRequest { Settings = legacy, SettingsVersion = 1 })); + } + + [Fact] + public void DictionariesValidateAffixedWordsAndExcludeMarkup() + { + var after = NaturaDictionary.Load(true); + var before = NaturaDictionary.Load(false); + Assert.True(after.Check("ações")); + Assert.True(before.Check("acções")); + Assert.True(after.Check("cantaríamos")); + Assert.Equal(new[] { "zzzzinvalidword" }, after.UnknownWords(new[] { "Bom dia. {\\an8}zzzzinvalidword" })); + } + + [Fact] + public void InvalidArchiveIsRejected() + { + using var stream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 }); + Assert.Throws(() => NaturaDictionary.ReadArchive(stream)); + } + + [Fact] + public void ArchiveWithoutLicenceIsRejected() + { + using var stream = new MemoryStream(); + using (var gzip = new GZipStream(stream, CompressionMode.Compress, leaveOpen: true)) + using (var writer = new TarWriter(gzip, leaveOpen: true)) + { + foreach (var name in new[] { "pt_PT.dic", "pt_PT.aff" }) + { + using var data = new MemoryStream(System.Text.Encoding.UTF8.GetBytes("dummy")); + writer.WriteEntry(new PaxTarEntry(TarEntryType.RegularFile, "test/" + name) { DataStream = data }); + } + } + stream.Position = 0; + Assert.Throws(() => NaturaDictionary.ReadArchive(stream)); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public async Task UpdateChecksDownloadsAndRetainsDictionaryOnFailure(bool postAgreement) + { + var directory = Path.Combine(Path.GetTempPath(), "natura-test-" + Guid.NewGuid().ToString("N")); + var file = Path.Combine(directory, NaturaDictionary.FileName(postAgreement)); + using var source = typeof(NaturaDictionary).Assembly.GetManifestResourceStream( + "BrazilianToEuropeanPortuguese.Dictionaries." + NaturaDictionary.FileName(postAgreement))!; + using var bytes = new MemoryStream(); + source.CopyTo(bytes); + var handler = new DictionaryHandler(bytes.ToArray()); + using var client = new HttpClient(handler); + try + { + Assert.Contains("up to date", await NaturaDictionary.UpdateAsync(postAgreement, false, client, directory)); + Assert.False(Directory.Exists(directory)); + Assert.True(NaturaDictionary.Load(postAgreement, directory).Check("casa")); + Assert.Contains("downloaded and validated", await NaturaDictionary.UpdateAsync(postAgreement, true, client, directory)); + Assert.Equal(bytes.ToArray(), File.ReadAllBytes(file)); + Assert.True(NaturaDictionary.Load(postAgreement, directory).Check("casa")); + handler.Bytes = new byte[] { 1, 2, 3, 4 }; + await Assert.ThrowsAsync(() => NaturaDictionary.UpdateAsync(postAgreement, true, client, directory)); + Assert.Equal(bytes.ToArray(), File.ReadAllBytes(file)); + handler.Status = HttpStatusCode.ServiceUnavailable; + await Assert.ThrowsAsync(() => NaturaDictionary.UpdateAsync(postAgreement, true, client, directory)); + Assert.Equal(bytes.ToArray(), File.ReadAllBytes(file)); + // A corrupt local file must not prevent manual recovery. + File.WriteAllBytes(file, handler.Bytes); + handler.Bytes = bytes.ToArray(); + handler.Status = HttpStatusCode.OK; + Assert.Contains("Update available", await NaturaDictionary.UpdateAsync(postAgreement, false, client, directory)); + await NaturaDictionary.UpdateAsync(postAgreement, true, client, directory); + Assert.True(NaturaDictionary.Load(postAgreement, directory).Check("casa")); + } + finally + { + if (File.Exists(file)) File.Delete(file); + if (Directory.Exists(directory)) Directory.Delete(directory); + } + } + + private sealed class DictionaryHandler(byte[] bytes) : HttpMessageHandler + { + public byte[] Bytes { get; set; } = bytes; + public HttpStatusCode Status { get; set; } = HttpStatusCode.OK; + + protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + Assert.Equal(HttpMethod.Get, request.Method); + Assert.Equal("natura.di.uminho.pt", request.RequestUri!.Host); + Assert.Null(request.Content); + return Task.FromResult(new HttpResponseMessage(Status) { Content = new ByteArrayContent(Bytes) }); + } + } + + [Fact] + public void UnchangedBatchStillReportsValidation() + { + var request = new PluginRequest + { + RequestType = PluginRequestType.Batch, + Settings = new ConversionOptions(ValidateSpelling: true).ToJson(), + SettingsVersion = ConversionOptions.Version, + Subtitle = new PluginSubtitle { SubRip = "1\n00:00:01,000 --> 00:00:02,000\nzzzzinvalidword\n" }, + }; + var response = BatchMode.BuildBatchResponse(request, Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".xml")); + Assert.Equal(PluginStatus.Ok, response.Status); + Assert.Null(response.Subtitle); + Assert.Contains("zzzzinvalidword", response.Message); + } + + [Fact] + public void BatchUsesOrthographyAndReportsUnrecognisedWords() + { + var request = new PluginRequest + { + RequestType = PluginRequestType.Batch, + Settings = new ConversionOptions(PostAgreement: false, ValidateSpelling: true).ToJson(), + SettingsVersion = ConversionOptions.Version, + Subtitle = new PluginSubtitle + { + SubRip = "1\n00:00:01,000 --> 00:00:02,000\nO projeto. zzzzinvalidword\n", + }, + }; + var response = BatchMode.BuildBatchResponse(request, Path.Combine(Path.GetTempPath(), System.Guid.NewGuid() + ".xml")); + Assert.Equal(PluginStatus.Ok, response.Status); + Assert.Contains("O projecto.", response.Subtitle!.Native); + Assert.Contains("zzzzinvalidword", response.Message); + Assert.False(response.Settings!.Value.GetProperty("postAgreement").GetBoolean()); + } +} diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/QualityTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/QualityTests.cs new file mode 100644 index 00000000..7150643a --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/QualityTests.cs @@ -0,0 +1,409 @@ +using System.Text.Json; +using System.Text.RegularExpressions; +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; +using SubtitleEdit.Plugins.Shared; + +namespace BrazilianToEuropeanPortuguese.Tests; + +public sealed class QualityTests +{ + private static SrtBlock Cue(string text, long start = 0, long end = 4000) => new() { Text = text, StartMs = start, EndMs = end }; + + [Fact] + public void SettingsRoundTripAndOldSettingsPreserveConservativeDefaults() + { + var options = new ConversionOptions(Address: AddressMode.Formal, SentenceContext: true, Rewrap: true, + LineLength: 38, MaxLines: 3, CharactersPerSecond: 18, DisabledRules: "address,word-list"); + var request = new PluginRequest { SettingsVersion = ConversionOptions.Version, Settings = options.ToJson() }; + Assert.Equal(options, ConversionOptions.Load(request)); + request.Settings = JsonSerializer.SerializeToElement(new { spelling = true }); + Assert.Equal(ConversionOptions.Default, ConversionOptions.Load(request)); + } + + [Theory] + [InlineData("""{"address":"invalid"}""")] + [InlineData("""{"lineLength":0}""")] + [InlineData("""{"maxLines":"two"}""")] + [InlineData("""{"charactersPerSecond":100}""")] + [InlineData("""{"sentenceContext":"yes"}""")] + [InlineData("""{"rewrap":null}""")] + [InlineData("""{"disabledRules":[]}""")] + public void InvalidNewSettingsAreExplicitErrors(string json) => + Assert.Throws(() => ConversionOptions.Load(new PluginRequest + { + SettingsVersion = ConversionOptions.Version, Settings = JsonDocument.Parse(json).RootElement.Clone(), + })); + + [Fact] + public void AddressOverrideAppliesAcrossCuesWithoutReference() + { + var blocks = new[] { Cue("Você está bem?"), Cue("Certo, veja.", 4500, 6000) }; + var formal = SubtitleConversion.Convert(blocks, new ConversionOptions(Address: AddressMode.Formal)); + Assert.Equal("Está bem?", formal[0].Text); + Assert.Equal("Certo, veja.", formal[1].Text); + var informal = SubtitleConversion.Convert(new[] { Cue("Senhor, você está bem?") }, + new ConversionOptions(Address: AddressMode.Informal)); + Assert.Contains("estás", informal[0].Text); + } + + [Fact] + public void RegisterStopsAtSceneGapsAndExplicitSpeakerChanges() + { + var blocks = new[] { Cue("Senhor, espere."), Cue("Certo, veja.", 11000, 15000) }; + Assert.False(SubtitleConversion.Convert(blocks, new ConversionOptions())[1].Hint?.FormalAddress == true); + Assert.Equal("Certo, vê.", SubtitleConversion.Convert(blocks, new ConversionOptions())[1].Text); + blocks = new[] { Cue("JOÃO: Senhor, espere."), Cue("MARIA: Certo, veja.", 4100, 8000) }; + Assert.True(DialogueRegister.DifferentSpeaker(blocks[0].Text, blocks[1].Text)); + Assert.False(SubtitleConversion.Convert(blocks, new ConversionOptions())[1].Hint?.FormalAddress == true); + } + + [Fact] + public void SpeakerIdentityDoesNotLeakAcrossUnlabelledCues() + { + var blocks = new[] { Cue("JOÃO: Senhor, espere."), Cue("Não sei.", 4100, 6000), Cue("MARIA: Certo, veja.", 6100, 9000) }; + Assert.False(DialogueRegister.IsFormal(blocks, 2)); + } + + [Fact] + public void SubtitleActorMetadataBoundsRegisterAndSentenceContext() + { + var blocks = new[] { Cue("Senhor, espere."), Cue("Não sei.", 4100, 6000), Cue("Certo, veja.", 6100, 9000) }; + var result = SubtitleConversion.Convert(blocks, new ConversionOptions(), speakers: new string?[] { "A", "A", "B" }); + Assert.False(result[2].Hint?.FormalAddress == true); + Assert.Equal("Certo, vê.", result[2].Text); + result = SubtitleConversion.Convert(new[] { Cue("Não vou"), Cue("fala mais.", 4100, 8000) }, + new ConversionOptions(SentenceContext: true), speakers: new string?[] { "A", "B" }); + Assert.All(result, r => Assert.Equal(-1, r.SentenceGroup)); + } + + [Fact] + public void MismatchedSpeakerMetadataIsReportedNotSilentlyApplied() + { + var request = new PluginRequest + { + Subtitle = new PluginSubtitle { Paragraphs = new List { new() { Actor = "A", StartMs = 100, EndMs = 500 } } }, + }; + Assert.Null(SubtitleConversion.Speakers(request, new[] { Cue("Senhor, espere.") }, out var note)); + Assert.Contains("ignored", note); + } + + [Fact] + public void ConflictingRegisterWithholdsAddressChangesAndFlagsReview() + { + var result = SubtitleConversion.Convert(new[] { Cue("Senhor, tu sabes que você está bem.") }, new ConversionOptions())[0]; + Assert.Contains("você", result.Text); + Assert.Contains("conflict", result.ContextNote); + Assert.DoesNotContain(result.Rules, r => r.Id == "address"); + } + + [Fact] + public void SentenceConversionRepairsCrossCueInfinitiveAndPreservesTimings() + { + var blocks = new[] { Cue("Não vou", 100, 2000), Cue("fala mais.", 2100, 4000) }; + var result = SubtitleConversion.Convert(blocks, new ConversionOptions(SentenceContext: true, YouToTu: false)); + Assert.Equal("Não vou", result[0].Text); + Assert.Equal("falar mais.", result[1].Text); + Assert.Equal(result[0].SentenceGroup, result[1].SentenceGroup); + Assert.Equal(0, result[0].SentenceGroup); + Assert.Equal((100L, 2000L, 2100L, 4000L), (blocks[0].StartMs, blocks[0].EndMs, blocks[1].StartMs, blocks[1].EndMs)); + Assert.Contains(result[1].Rules, r => r.Id == "missing-infinitive"); + } + + [Theory] + [InlineData("Não vou.", "fala mais.", 4100)] + [InlineData("Não vou", "Fala mais.", 4100)] + [InlineData("Não vou", "- fala mais.", 4100)] + [InlineData("Não vou", "fala mais.", 4100)] + [InlineData("Não vou", "fala mais.", 11000)] + public void UnsafeSentenceBoundariesAreNotJoined(string first, string second, long start) + { + var result = SubtitleConversion.Convert(new[] { Cue(first), Cue(second, start, start + 4000) }, + new ConversionOptions(SentenceContext: true)); + Assert.All(result, r => Assert.Equal(-1, r.SentenceGroup)); + } + + [Fact] + public void SentenceConversionDoesNotTouchUnselectedCues() + { + var result = SubtitleConversion.Convert(new[] { Cue("Não vou"), Cue("fala mais.", 4100, 8000) }, + new ConversionOptions(SentenceContext: true), selected: new HashSet { 0 }); + Assert.Equal("fala mais.", result[1].Text); + Assert.All(result, r => Assert.Equal(-1, r.SentenceGroup)); + } + + [Fact] + public void SentenceMappingKeepsOriginalInternalLineBreaksAndNonEmptyCues() + { + var result = SubtitleConversion.Convert(new[] { Cue("Não vou\nmesmo"), Cue("fala com vocês.", 4100, 8000) }, + new ConversionOptions(SentenceContext: true, YouToTu: false)); + Assert.Contains('\n', result[0].Text); + Assert.Contains("falar", result[1].Text); + Assert.All(result, r => Assert.False(string.IsNullOrWhiteSpace(r.Text))); + } + + [Fact] + public void SentencePassPreservesPerCueContextCorrectionsAndAmbiguousOutputs() + { + var result = SubtitleConversion.Convert(new[] + { + Cue("A gente sempre escuta,"), Cue("mas nunca acha que vai acontecer contigo.", 4100, 8000), + }, new ConversionOptions(SentenceContext: true)); + Assert.Contains("nunca achamos", result[1].Text); + result = SubtitleConversion.Convert(new[] + { + Cue("Ele usa um terno"), Cue("azul.", 4100, 8000), + }, new ConversionOptions(SentenceContext: true)); + Assert.Contains("fato", string.Join(" ", result.Select(r => r.Text))); + Assert.DoesNotContain("facto", string.Join(" ", result.Select(r => r.Text))); + } + + [Fact] + public void TraceStagesCanBeDisabledWithoutDisablingOtherStages() + { + var options = new ConversionOptions(DisabledRules: "word-list"); + var result = SubtitleConversion.Convert(new[] { Cue("Você está no trem.") }, options)[0]; + Assert.Contains("trem", result.Text); + Assert.DoesNotContain("Você", result.Text); + Assert.Contains(result.Rules, r => r.Id == "address"); + Assert.DoesNotContain(result.Rules, r => r.Id == "word-list"); + } + + [Fact] + public void RewrapMeetsConfiguredLimitsAndIsStable() + { + var options = new ConversionOptions(Rewrap: true, LineLength: 30); + var text = "Vou falar com o diretor amanhã de manhã."; + var wrapped = SubtitleLayout.Rewrap(text, options); + Assert.NotEqual(text, wrapped); + Assert.All(wrapped.Split('\n'), line => Assert.InRange(line.Length, 1, 30)); + Assert.InRange(wrapped.Split('\n').Length, 1, 2); + Assert.Equal(text, wrapped.Replace('\n', ' ')); + Assert.Equal(wrapped, SubtitleLayout.Rewrap(wrapped, options)); + Assert.DoesNotMatch(@"(?:\bo|\bcom|\bde|\bVou)\n", wrapped); + } + + [Theory] + [InlineData("Vou falar com o diretor amanhã de manhã.")] + [InlineData("- Vou falar com o diretor.\n- Espera um momento.")] + [InlineData(@"{\an8}Vou falar com o diretor amanhã de manhã.")] + public void RewrapPreservesFormattingAndSpeakerMarkers(string text) => + Assert.Equal(text, SubtitleLayout.Rewrap(text, new ConversionOptions(Rewrap: true, LineLength: 20))); + + [Fact] + public void InfeasibleLayoutIsKeptAndFlagged() + { + const string text = "Esta frase é demasiado comprida para caber em duas linhas de vinte caracteres."; + var options = new ConversionOptions(Rewrap: true, LineLength: 20, LayoutWarnings: true); + Assert.Equal(text, SubtitleLayout.Rewrap(text, options)); + Assert.Contains("exceeds 20", SubtitleLayout.Review(text, Cue(text), options)); + } + + [Fact] + public void ReadingSpeedUsesDurationAndExactThreshold() + { + var options = new ConversionOptions(CharactersPerSecond: 20, LayoutWarnings: true); + Assert.Null(SubtitleLayout.Review("12345678901234567890", Cue("", end: 1000), options)); + Assert.Contains("21.0", SubtitleLayout.Review("123456789012345678901", Cue("", end: 1000), options)); + Assert.Contains("zero or negative", SubtitleLayout.Review("Olá.", Cue("", end: 0), options)); + } + + [Fact] + public void VisibleCharacterWarningsDecodeEntitiesAndCountGraphemes() + { + var options = new ConversionOptions(CharactersPerSecond: 5, LayoutWarnings: true); + Assert.Null(SubtitleLayout.Review("&&&&&", Cue("", end: 1000), options)); + Assert.Contains("6.0", SubtitleLayout.Review("😀😀😀😀😀😀", Cue("", end: 1000), options)); + } + + [Fact] + public void RewrapAvoidsNameAndAuxiliarySplitsAndSupportsThreeLines() + { + var options = new ConversionOptions(Rewrap: true, LineLength: 22, MaxLines: 3); + var names = SubtitleLayout.Rewrap("O John Smith chegou a casa cedo.", options); + Assert.DoesNotContain("John\nSmith", names); + var auxiliary = SubtitleLayout.Rewrap("Vou falar com a diretora amanhã.", options); + Assert.DoesNotContain("Vou\nfalar", auxiliary); + var three = SubtitleLayout.Rewrap("Este texto tem muitas palavras para caber em três linhas.", options); + Assert.Equal(3, three.Split('\n').Length); + Assert.All(three.Split('\n'), line => Assert.InRange(line.Length, 1, 22)); + } + + [Fact] + public void FindingTypesDistinguishRulesModelsReviewsAndManualEdits() + { + var rules = new ChangeProposal(0, "A", "B", rules: new[] { new RuleChange("word-list", "Vocabulary") }); + Assert.Equal(FindingType.RuleBased, rules.FindingTypes); + var mini = new ChangeProposal(1, "A", "A", reviewNote: "MiniLM (before the rules): check it."); + Assert.Equal(FindingType.MiniLm, mini.FindingTypes); + var judge = new ChangeProposal(2, "A", "B", reviewNote: "Gervásio chose an alternative.", + rules: new[] { new RuleChange("local-judge", "Model choice") }); + Assert.Equal(FindingType.Judge, judge.FindingTypes); + var combined = new ChangeProposal(3, "A", "B", + reviewNote: "MiniLM: check it.\nGervásio chose an alternative.\nGrammar: check agreement.", + rules: new[] { new RuleChange("word-list", "Vocabulary") }); + Assert.Equal(FindingType.RuleBased | FindingType.MiniLm | FindingType.Judge | FindingType.OtherReview, + combined.FindingTypes); + mini.ConvertedText = "Manual correction"; + Assert.Equal(FindingType.MiniLm | FindingType.ManualEdit, mini.FindingTypes); + mini.ConvertedText = "A"; + Assert.Equal(FindingType.MiniLm, mini.FindingTypes); + var layout = new ChangeProposal(4, "A", "A", wrappedText: "A\n", languageLayoutNote: "Layout: long line."); + Assert.Equal(FindingType.RuleBased, layout.FindingTypes); + layout.IncludeLayout = false; + Assert.Equal(FindingType.RuleBased | FindingType.OtherReview, layout.FindingTypes); + Assert.True(new ChangeProposal(5, "A", "A").VisibleInReview); + } + + [Fact] + public void LayoutCanBeRejectedWithoutRejectingLanguage() + { + var proposal = new ChangeProposal(0, "Estou no trem.", "Estou no comboio.", wrappedText: "Estou no\ncomboio."); + Assert.True(proposal.HasLayoutChange); + proposal.IncludeLayout = false; + Assert.Equal("Estou no comboio.", proposal.ConvertedText); + Assert.True(proposal.Include); + } + + [Fact] + public void RejectingLayoutRefreshesVisibleWarnings() + { + var proposal = new ChangeProposal(0, "Original.", "Texto sem quebra.", wrappedText: "Texto sem\nquebra.", + wrappedLayoutNote: null, languageLayoutNote: "Layout: long line."); + Assert.False(proposal.HasReview); + proposal.IncludeLayout = false; + Assert.Contains("long line", proposal.ReviewNote); + Assert.True(proposal.HasReview); + } + + [Fact] + public void ExportIsStructuredAndDoesNotIncludeReferenceOrFileMetadata() + { + var proposal = new ChangeProposal(0, "Estou no trem.", "Estou no comboio.", "English secret reference", + rules: new[] { new RuleChange("word-list", "Vocabulary") }); + proposal.ExpectedText = "Estou no comboio!"; + var exported = CorrectionExport.Create(new[] { proposal }); + Assert.Equal(1, exported.GetProperty("schemaVersion").GetInt32()); + var test = exported.GetProperty("cases")[0]; + Assert.Equal("Estou no comboio!", test.GetProperty("expected").GetString()); + Assert.Equal(new[] { "original", "expected", "rules", "sentenceGroup" }, test.EnumerateObject().Select(p => p.Name)); + Assert.DoesNotContain("English secret", exported.GetRawText()); + } + + [Theory] + [InlineData("Nós está aqui.", "estamos")] + [InlineData("Eles falas muito.", "plural")] + [InlineData("Tu sabe a resposta.", "sabes")] + [InlineData("Não conheço-te.", "pronoun placement")] + [InlineData("Uma casaco velho.", "gender agreement")] + [InlineData("A equipa está cansado.", "noun/adjective")] + [InlineData("O casaco está velha.", "noun/adjective")] + [InlineData("Eu gosto o chocolate.", "preposition de")] + public void FinalGrammarReviewDetectsAgreementCliticsAndGovernment(string text, string? fragment) + { + if (fragment == null) return; + Assert.Contains(fragment, GrammarReview.Note(text)); + } + + [Theory] + [InlineData("Nós estamos aqui.")] + [InlineData("Eles falam muito.")] + [InlineData("Tu sabes a resposta.")] + [InlineData("Não te conheço.")] + [InlineData("Um casaco velho.")] + [InlineData("A equipa está cheia.")] + [InlineData("A polícia está aqui.")] + [InlineData("O casaco está velho.")] + [InlineData("Eu gosto do chocolate.")] + [InlineData("Gosto um pouco de chocolate.")] + [InlineData("É preciso um plano.")] + [InlineData("Se tu falares, ouvimos.")] + public void FinalGrammarReviewPreservesValidCounterexamples(string text) => Assert.Null(GrammarReview.Note(text)); + + public static IEnumerable BenchmarkCases() + { + yield return new object[] { "police", "Vamos pegar este cara.", "Vamos apanhar este tipo." }; + yield return new object[] { "police", "Ele é um tira.", "Ele é um polícia." }; + yield return new object[] { "police", "Ele foi pego.", "Ele foi apanhado." }; + yield return new object[] { "police", "Foi um sequestro.", "Foi um rapto." }; + yield return new object[] { "police", "Não fala.", "Não fales." }; + yield return new object[] { "family", "Minha geladeira está vazia.", "O meu frigorífico está vazio." }; + yield return new object[] { "family", "Papai está trabalhando.", "Pai está a trabalhar." }; + yield return new object[] { "family", "O café da manhã está pronto.", "O pequeno-almoço está pronto." }; + yield return new object[] { "family", "Gosto do suco.", "Gosto do sumo." }; + yield return new object[] { "family", "Estou com saudade.", "Tenho saudades." }; + yield return new object[] { "family", "Vou te ajudar.", "Vou ajudar-te." }; + yield return new object[] { "family", "Você tem razão.", "Tens razão." }; + yield return new object[] { "family", "Você se lembra?", "Lembras-te?" }; + yield return new object[] { "comedy", "Que cara de pau!", "Que descaramento!" }; + yield return new object[] { "comedy", "Que saco!", "Que seca!" }; + yield return new object[] { "comedy", "Legal!", "Fixe!" }; + yield return new object[] { "comedy", "Sério?", "A sério?" }; + yield return new object[] { "comedy", "Tá bom.", "Está bem." }; + yield return new object[] { "comedy", "Oi!", "Olá!" }; + yield return new object[] { "formal", "Doutor, você está bem?", "Doutor, está bem?" }; + yield return new object[] { "formal", "Senhor, isto é para você.", "Senhor, isto é para si." }; + yield return new object[] { "formal", "Detetive, posso falar com você?", "Detetive, posso falar consigo?" }; + yield return new object[] { "formal", "Doutora, não se preocupe.", "Doutora, não se preocupe." }; + yield return new object[] { "formal", "A senhora está bem?", "A senhora está bem?" }; + yield return new object[] { "preservation", "Não te conheço.", "Não te conheço." }; + yield return new object[] { "preservation", "O comboio chegou.", "O comboio chegou." }; + yield return new object[] { "preservation", "A equipa está pronta.", "A equipa está pronta." }; + yield return new object[] { "preservation", "Ela tira o casaco.", "Ela tira o casaco." }; + yield return new object[] { "preservation", "O frigorífico está vazio.", "O frigorífico está vazio." }; + yield return new object[] { "preservation", "Nunca nos esquecemos.", "Nunca nos esquecemos." }; + } + + [Theory] + [MemberData(nameof(BenchmarkCases))] + public void CrossDomainBenchmarkHasNoWrongOrMissedChangesAndIsIdempotent(string domain, string source, string expected) + { + Assert.NotEmpty(domain); + var converter = new PortugueseConverter(); + var output = converter.Convert(source); + Assert.Equal(expected, output); + Assert.Equal(output, converter.Convert(output)); + } + + [Fact] + public void BenchmarkMeasuresWrongChangesMissesAndPreservation() + { + var cases = BenchmarkCases().ToArray(); + var converter = new PortugueseConverter(); + var rows = cases.Select(c => (Source: (string)c[1], Expected: (string)c[2], Output: converter.Convert((string)c[1]))).ToArray(); + var wrongChanges = rows.Count(r => r.Output != r.Source && r.Output != r.Expected); + var missedChanges = rows.Count(r => r.Output == r.Source && r.Expected != r.Source); + var preservationFailures = rows.Count(r => r.Expected == r.Source && r.Output != r.Source); + Assert.Equal(0, wrongChanges); + Assert.Equal(0, missedChanges); + Assert.Equal(0, preservationFailures); + Assert.Equal(5, cases.Select(c => c[0]).Distinct().Count()); + } + + [Fact] + public void BatchAndSharedPipelineAgreeOnOptionalSentenceAndLayoutBehavior() + { + var options = new ConversionOptions(SentenceContext: true, Rewrap: true, LineLength: 30, UseReference: false, YouToTu: false); + var blocks = new List + { + Cue("Não vou", 0, 2000), Cue("fala mais com vocês.", 2100, 4000), + Cue("Vou falar com o diretor amanhã de manhã.", 8000, 12000), + }; + var request = new PluginRequest + { + RequestType = PluginRequestType.Batch, Settings = options.ToJson(), SettingsVersion = ConversionOptions.Version, + Subtitle = new PluginSubtitle { Format = "SubRip", SubRip = SubRipParser.Serialize(blocks) }, + }; + var output = BatchMode.BuildBatchResponse(request, Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".xml"), + new EmbeddingSettings(CheckMeaning: false, UseJudge: false)); + Assert.Equal(PluginStatus.Ok, output.Status); + var actual = SubRipParser.Parse(output.Subtitle!.Native); + var expected = SubtitleConversion.Convert(blocks, options); + Assert.Equal(blocks.Count, actual.Count); + for (var i = 0; i < blocks.Count; i++) + { + Assert.Equal(SubtitleLayout.Rewrap(expected[i].Text, options), actual[i].Text); + Assert.Equal(blocks[i].StartMs, actual[i].StartMs); + Assert.Equal(blocks[i].EndMs, actual[i].EndMs); + } + } +} diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs new file mode 100644 index 00000000..83fc02fc --- /dev/null +++ b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs @@ -0,0 +1,1110 @@ +using System.Text; +using Avalonia.Controls; +using Avalonia.Controls.Primitives; +using Avalonia.VisualTree; +using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese; +using SubtitleEdit.Plugins.Shared; +using Xunit.Abstractions; + +namespace BrazilianToEuropeanPortuguese.Tests; + +public sealed class OptInFactAttribute : FactAttribute +{ + public OptInFactAttribute(string variable, string reason) + { + if (Environment.GetEnvironmentVariable(variable) != "1") Skip = $"Opt-in ({variable}=1): {reason}"; + } +} + +[Collection("XdgDataHome")] +public sealed class ReferenceTests(ITestOutputHelper output) +{ + private static readonly PortugueseConverter Converter = new(ConversionOptions.Default); + + private static SrtBlock Cue(long start, long end, string text) => new() { StartMs = start, EndMs = end, Text = text }; + + [Fact] + public void EmptiedLineIsRemovedFromTheSubtitle() + { + var blocks = new List { Cue(0, 1000, "Um."), Cue(1000, 2000, "Dois."), Cue(2000, 3000, "Três.") }; + var response = BatchMode.BuildOkResponse(blocks, new Dictionary { [1] = " ", [2] = "Três!" }, ConversionOptions.Default); + var texts = SubRipParser.Parse(response.Subtitle!.Native!).Select(b => b.Text).ToArray(); + Assert.Equal(new[] { "Um.", "Três!" }, texts); + } + + [Theory] + [InlineData("O policial chegou.", "The officer arrived.", "O agente chegou.")] + [InlineData("Os policiais chegaram.", "The officers arrived.", "Os agentes chegaram.")] + [InlineData("Um policial foi baleado.", "An officer was shot.", "Um agente foi baleado.")] + [InlineData("O policial chegou.", "He arrived.", "O polícia chegou.")] + [InlineData("Chame a polícia.", "Call the police.", "Chama a polícia.")] + public void OfficerInTheEnglishMeansAgente(string br, string english, string expected) => + Assert.Equal(expected, Converter.Convert(br, null, ReferenceHint.FromText(english))); + + [Fact] + public void ManualEditReplacesTheProposalAndIsSelected() + { + var proposal = new ChangeProposal(0, "Tem uma ligação\ncom o chefe.", "Há uma chamada\ncom o chefe."); + proposal.Include = false; + proposal.ConvertedText = "Tens uma chamada\r\ncom o chefe."; + Assert.Equal("Tens uma chamada\ncom o chefe.", proposal.ConvertedText); + Assert.True(proposal.Include); + Assert.Equal(proposal.ConvertedText, proposal.ExpectedText); + proposal.ConvertedText = "Há uma chamada\ncom o chefe."; + Assert.Equal("Há uma chamada\ncom o chefe.", proposal.ConvertedText); + } + + [Theory] + [InlineData("Tem uma ligação\ncom o chefe da PBA às 13h.", "You have a call with the PBA chief at 1:00,", "Tens uma chamada\ncom o chefe da PBA às 13h.")] + [InlineData("Tem uma reunião\ncom TARU às 15h,", "you have a briefing with TARU at 3:00 p.m.,", "Tens uma reunião\ncom TARU às 15h,")] + [InlineData("Tem uma consulta marcada.", "You have an appointment.", "Tens uma consulta marcada.")] + public void HavingAnAppointmentIsNotExistential(string br, string english, string expected) => + Assert.Equal(expected, Converter.Convert(br, null, ReferenceHint.FromText(english))); + + [Theory] + [InlineData("acha", "achamos")] + [InlineData("pensa", "pensamos")] + [InlineData("imagina", "imaginamos")] + public void InclusiveWeContinuesAcrossAdjacentCues(string verb, string plural) + { + var source = $"mas nunca {verb} que vai acontecer contigo."; + var blocks = new[] { Cue(0, 1500, "A gente sempre escuta,"), Cue(1501, 3000, source) }; + var english = new string?[] { "You just hear about this stuff.", "Never think it's going to happen to you." }; + var hint = ReferenceHint.FromContext(blocks, 1, english); + Assert.True(hint!.InclusiveContinuation); + Assert.Equal($"mas nunca {plural} que vá acontecer connosco.", Converter.Convert(source, blocks[0].Text, hint)); + blocks[1].StartMs = 7000; + Assert.False(ReferenceHint.FromContext(blocks, 1, english)!.InclusiveContinuation); + } + + [Theory] + [InlineData("Ela sempre escuta,", "Never think it's going to happen to you.")] + [InlineData("A gente sempre escuta,", "He never thinks it's going to happen to you.")] + public void InclusiveContinuationDoesNotGuessAnotherSubject(string previous, string english) + { + var blocks = new[] { Cue(0, 1500, previous), Cue(1501, 3000, "mas nunca acha que vai acontecer contigo.") }; + Assert.False(ReferenceHint.FromContext(blocks, 1, new string?[] { null, english })!.InclusiveContinuation); + } + + [Theory] + [InlineData("You just hear about this stuff.", true)] + [InlineData("We always heard about it.", true)] + [InlineData("She hears about these things.", true)] + [InlineData("Listen carefully.", false)] + [InlineData("We listen to music.", false)] + [InlineData("Listen, I heard about it.", false)] + [InlineData("Did you hear that sound?", false)] + public void HearAboutReferenceHint(string english, bool expected) => + Assert.Equal(expected, ReferenceHint.FromText(english)!.HearAbout); + + [Theory] + [InlineData("Is that why you never dated any officers?", true, true)] + [InlineData("Is that why you already arrived?", true, false)] + [InlineData("Is that why he never dated any officers?", false, true)] + [InlineData("What happened to you?", false, false)] + [InlineData("I never stayed any longer.", false, false)] + [InlineData("I never wanted any more.", false, false)] + public void ReferenceSubjectAdverbsAndNeverAnyHints(string english, bool subject, bool any) + { + var hint = ReferenceHint.FromText(english)!; + Assert.Equal(subject, hint.SecondPersonSubject); + Assert.Equal(any, hint.NeverAnyObject); + } + + [Theory] + [InlineData("Bem, Sr. vice-cônsul,")] + [InlineData("Bom dia, professora.")] + [InlineData("Senhor Silva, posso entrar?")] + [InlineData("Não concordo, detetive.")] + [InlineData("- Muito obrigado, doutora.")] + [InlineData("Capitão, espere.")] + public void NearbyPortugueseAddressPreservesFormalCommands(string address) + { + var blocks = new[] { Cue(0, 1500, address), Cue(2000, 3500, "Não sei."), Cue(4000, 5500, "Certo, veja...") }; + var hint = ReferenceHint.FromContext(blocks, 2); + Assert.True(hint!.FormalAddress); + Assert.Equal("Certo, veja...", Converter.Convert(blocks[2].Text, blocks[1].Text, hint)); + } + + [Theory] + [InlineData("I disagree, Detective.")] + [InlineData("Well, Mr. Deputy Consul,")] + [InlineData("Yes, sir.")] + [InlineData("Doctor Smith, please listen.")] + [InlineData("Thank you, Your Honor.")] + public void NearbyEnglishAddressPreservesFormalCommands(string address) + { + var blocks = new[] { Cue(0, 1500, "Certo, veja..."), Cue(2000, 3500, "Não sei."), Cue(4000, 5500, "Não concordo.") }; + var english = new string?[] { "Okay, look--", "I don't know.", address }; + var hint = ReferenceHint.FromContext(blocks, 0, english); + Assert.True(hint!.FormalAddress); + Assert.Equal("Certo, veja...", Converter.Convert(blocks[0].Text, null, hint)); + } + + [Theory] + [InlineData("O detetive chegou.", "The detective arrived.")] + [InlineData("Falei com o professor.", "I spoke to the professor.")] + [InlineData("O senhor saiu.", "The gentleman left.")] + [InlineData("Foi uma decisão do juiz.", "It was the judge's decision.")] + [InlineData("Você sabe.", "You know.")] + public void MentionedTitlesAndEnglishYouDoNotEstablishFormalContext(string text, string english) + { + var blocks = new[] { Cue(0, 1500, text), Cue(2000, 3500, "Não sei."), Cue(4000, 5500, "Certo, veja...") }; + var reference = new string?[] { english, "I don't know.", "Okay, look--" }; + Assert.False(ReferenceHint.FromContext(blocks, 2, reference)!.FormalAddress); + Assert.Equal("Certo, vê...", Converter.Convert(blocks[2].Text, blocks[1].Text, ReferenceHint.FromContext(blocks, 2, reference))); + } + + [Fact] + public void FormalContextStopsAtTimingAndInformalBoundaries() + { + var gap = new[] { Cue(0, 1000, "Senhor, espere."), Cue(6001, 7000, "Certo, veja...") }; + Assert.False(DialogueRegister.IsFormal(gap, 1)); + var continuous = Enumerable.Range(0, 12).Select(i => Cue(i * 3000, i * 3000 + 2500, i == 0 ? "Senhor, espere." : "Certo, veja...")).ToArray(); + Assert.True(DialogueRegister.IsFormal(continuous, 10)); + Assert.False(DialogueRegister.IsFormal(continuous, 11)); + var dense = Enumerable.Range(0, 14).Select(i => Cue(i * 1000, i * 1000 + 900, i == 0 ? "Senhor, espere." : "Certo, veja...")).ToArray(); + Assert.True(DialogueRegister.IsFormal(dense, 12)); + Assert.False(DialogueRegister.IsFormal(dense, 13)); + var informal = new[] { Cue(0, 1000, "Senhor, espere."), Cue(2000, 3000, "Tu sabes."), Cue(4000, 5000, "Certo, veja...") }; + Assert.False(DialogueRegister.IsFormal(informal, 2)); + Assert.False(DialogueRegister.IsFormal(informal, 1)); + var ahead = new[] { Cue(0, 1000, "Certo, veja..."), Cue(2000, 3000, "Tu sabes."), Cue(4000, 5000, "Senhor, espere.") }; + Assert.False(DialogueRegister.IsFormal(ahead, 0)); + } + + [Theory] + [InlineData("Diga a sua mãe.", "Diga à sua mãe.")] + [InlineData("Não fale comigo.", "Não fale comigo.")] + [InlineData("Você tem razão.", "Tem razão.")] + [InlineData("Posso falar com você?", "Posso falar consigo?")] + [InlineData("Isto é para você.", "Isto é para si.")] + [InlineData("Cale a boca.", "Cale-se.")] + [InlineData("Lembre de fechar a porta.", "Lembre-se de fechar a porta.")] + public void FormalContextIsSharedByAddressPronounsAndCommands(string source, string expected) + { + var blocks = new[] { Cue(0, 1500, "Doutora, um momento."), Cue(2000, 3500, "Não sei."), Cue(4000, 5500, source) }; + var hint = ReferenceHint.FromContext(blocks, 2); + Assert.Equal(expected, Converter.Convert(source, blocks[1].Text, hint)); + Assert.Equal(expected, Converter.Convert(expected, blocks[1].Text, hint)); + Assert.Null(ReferenceReview.Note("Você tem a sua chave.", hint)); + } + + [Theory] + [InlineData("Ninguém leva as tuas coisas.", false, false)] + [InlineData("I already sent him his stuff.", false, true)] + [InlineData("This was his last message to us,", false, true)] + [InlineData("Now, your brother Tiago,", true, false)] + [InlineData("I sent her your things.", true, true)] + public void PossessiveHints(string english, bool second, bool third) + { + var hint = ReferenceHint.FromText(english)!; + Assert.Equal(second, hint.SecondPossessive); + Assert.Equal(third, hint.ThirdPossessive); + Assert.Equal(third && !second, hint.KeepsThirdPersonPossessive); + } + + [Theory] + [InlineData("Is he okay?", true)] + [InlineData("They're home.", true)] + [InlineData("Are you okay?", false)] + [InlineData("You're right, he is.", false)] + [InlineData("Okay?", false)] + public void DroppedYouHint(string english, bool excluded) => + Assert.Equal(excluded, ReferenceHint.FromText(english)!.ExcludesDroppedYou); + + [Fact] + public void NoReferenceTextGivesNoHint() + { + Assert.Null(ReferenceHint.FromText(null)); + Assert.Null(ReferenceHint.FromText(" ")); + } + + [Theory] + [InlineData("DEMARCUS (groans): Yeah, I'm seeing double.", "Yeah, I'm seeing double.")] + [InlineData("TERESA: There he is!\n- Hey!", "There he is! Hey!")] + [InlineData("WOMAN: * Start spreading the news", "Start spreading the news")] + [InlineData("[door closes] It's 10:30.", "It's 10:30.")] + [InlineData("{\\an8}Mr. Banse", "Mr. Banse")] + public void CleanRemovesTagsAndHearingImpairedText(string text, string expected) => + Assert.Equal(expected, ReferenceAligner.Clean(text)); + + [Fact] + public void DecodesUtf8Bom16AndWindows1252() + { + Assert.Equal("ação", ReferenceAligner.Decode(new byte[] { 0xEF, 0xBB, 0xBF }.Concat(Encoding.UTF8.GetBytes("ação")).ToArray())); + Assert.Equal("“his”", ReferenceAligner.Decode(new byte[] { 0x93, 0x68, 0x69, 0x73, 0x94 })); + Assert.Equal("you", ReferenceAligner.Decode(new byte[] { 0xFF, 0xFE }.Concat(Encoding.Unicode.GetBytes("you")).ToArray())); + } + + [Fact] + public void LooksEnglishNeedsEnglishFunctionWords() + { + Assert.True(ReferenceAligner.LooksEnglish(new[] { Cue(0, 1, "What are you doing?"), Cue(1, 2, "Fine.") })); + Assert.False(ReferenceAligner.LooksEnglish(new[] { Cue(0, 1, "¿Qué estás haciendo?"), Cue(1, 2, "Nada.") })); + } + + [Fact] + public void TimingJoinsOverlappingCuesAndSkipsGaps() + { + var source = new[] { Cue(1000, 4000, "Já temos digitais e sua foto."), Cue(10_000, 12_000, "Oi."), Cue(20_000, 21_000, "♪") }; + var reference = new[] + { + Cue(900, 2400, "So we got prints"), Cue(2500, 4100, "and his picture now."), Cue(30_000, 31_000, "Hi."), + }; + var alignment = ReferenceAligner.AlignByTiming(source, reference); + Assert.Equal("So we got prints\nand his picture now.", alignment.Texts[0]); + Assert.Null(alignment.Texts[1]); + Assert.Null(alignment.Texts[2]); + Assert.Equal(2, alignment.Total); + Assert.Equal(1, alignment.Matched); + } + + [Fact] + public void ShortOverlapAtCueBoundaryIsIgnored() + { + var alignment = ReferenceAligner.AlignByTiming(new[] { Cue(1000, 3000, "Ele sabe.") }, + new[] { Cue(0, 1100, "Your car."), Cue(1050, 3000, "He knows.") }); + Assert.Equal("He knows.", alignment.Texts[0]); + } + + [Fact] + public void FitTimeMapRecoversFrameRateAndOffsetDespiteOutliers() + { + var random = new Random(7); + var matches = Enumerable.Range(0, 60).Select(i => + { + var source = i * 40_000.0; + var reference = source * 1.0427 + 4200 + random.Next(-300, 300); + return (source, i % 6 == 0 ? reference + 25_000 : reference); + }).ToList(); + var map = ReferenceAligner.FitTimeMap(matches)!; + Assert.InRange(map.Scale, 1.040, 1.045); + Assert.InRange(map.Map(1_000_000) - (1_000_000 * 1.0427 + 4200), -500, 500); + } + + [Fact] + public void FitTimeMapKeepsIdentityAndRejectsTooFew() + { + var aligned = Enumerable.Range(0, 30).Select(i => (i * 50_000.0, i * 50_000.0 + (i % 2 == 0 ? 120 : -90))).ToList(); + Assert.True(ReferenceAligner.FitTimeMap(aligned)!.IsIdentity); + Assert.Null(ReferenceAligner.FitTimeMap(aligned.Take(5).ToList())); + } + + [Fact] + public void MutualMatchesRejectAmbiguousPairs() + { + float[] V(params float[] v) => v; + var source = new[] { V(1, 0, 0), V(0, 1, 0), V(0, 0, 1) }; + var reference = new[] { V(1, 0, 0), V(0, 0.9f, 0.436f), V(0, 0.9f, 0.436f), V(0, 0, 1) }; + var matches = ReferenceAligner.MutualMatches(source, reference); + Assert.Contains((0, 0, 1.0), matches.Select(m => (m.Source, m.Reference, Math.Round(m.Score, 3)))); + Assert.DoesNotContain(matches, m => m.Source == 1); + Assert.Contains(matches, m => m.Source == 2 && m.Reference == 3); + } + + /// A reference 4 s late and stretched, with one scene cut out, still pairs every line. + [Fact] + public void EmbeddingAlignmentFixesShiftStretchAndCut() + { + const int count = 120; + var source = new List(); + var reference = new List(); + var sourceVectors = new List(); + var referenceVectors = new List(); + for (var i = 0; i < count; i++) + { + long start = i * 20_000L; + source.Add(Cue(start, start + 2500, $"Linha portuguesa número {i} com bastante texto")); + sourceVectors.Add(Basis(i, count)); + var cut = i >= 80 ? 7000 : 0; + var mapped = (long)(start * 1.0427) + 4000 - cut; + reference.Add(Cue(mapped, mapped + (long)(2500 * 1.0427), $"English line number {i} with plenty of text")); + referenceVectors.Add(Basis(i, count)); + } + + var timingOnly = ReferenceAligner.AlignByTiming(source, reference); + Assert.True(timingOnly.Coverage < 0.3); + var alignment = ReferenceAligner.AlignWithEmbeddings(source, reference, sourceVectors, referenceVectors); + for (var i = 0; i < count; i++) + { + Assert.Equal($"English line number {i} with plenty of text", alignment.Texts[i]); + } + Assert.InRange(alignment.Map.Scale, 1.04, 1.045); + } + + [Fact] + public void EmbeddingAlignmentDropsPairsThatAreNotTranslations() + { + var source = new[] { Cue(0, 2000, "Bom dia a todos vocês aqui presentes"), Cue(5000, 7000, "Bom.") }; + var reference = new[] { Cue(0, 2000, "Good morning to all of you here"), Cue(5000, 7000, "I hate keeping secrets.") }; + var alignment = ReferenceAligner.AlignWithEmbeddings(source, reference, + new[] { Basis(0, 3), Basis(1, 3) }, new[] { Basis(0, 3), Basis(2, 3) }); + Assert.Equal("Good morning to all of you here", alignment.Texts[0]); + Assert.Null(alignment.Texts[1]); + Assert.Equal(1, alignment.Rejected); + } + + private static float[] Basis(int index, int size) + { + var vector = new float[size]; + vector[index] = 1; + return vector; + } + + [Theory] + [InlineData("Carteira de motorista da Flórida.\nJá temos digitais e sua foto.", "so we got prints and his picture now.", + "Carta de condução da Flórida.\nJá temos impressões digitais e a sua foto.", + "Carta de condução da Flórida.\nJá temos impressões digitais e a tua foto.")] + [InlineData("Esta foi sua última mensagem\npara nós.", "This was his last message to us,", + "Esta foi a sua última mensagem\npara nós.", "Esta foi a tua última mensagem\npara nós.")] + [InlineData("Já até mandei suas coisas.", "I already sent him his stuff.", + "Até, já lhe mandei as suas coisas.", "Já até mandei as tuas coisas.")] + [InlineData("Está bem?", "Is he okay?", "Está bem?", "Estás bem?")] + public void ThirdPersonReferenceKeepsSeuAndThirdPersonVerbs(string text, string english, string withReference, string without) + { + Assert.Equal(without, Converter.Convert(text)); + Assert.Equal(withReference, Converter.Convert(text, null, ReferenceHint.FromText(english))); + } + + /// English "your" cannot tell "tu" from formal "o seu marido": it must never force "teu". + [Theory] + [InlineData("Precisamos falar com\nseu marido. Ele está em casa?", "We need to talk to your husband. Is he home?")] + [InlineData("Agora, seu irmão Tiago,", "Now, your brother Tiago,")] + [InlineData("Mamãe tá brava com ele\npor quê ficou ao seu lado.", "Mom's mad at him because he took your side.")] + [InlineData("Você está bem?", "Are you okay?")] + [InlineData("Não fala assim.", "Don't talk like that.")] + [InlineData("Se afaste!", "Step aside!")] + public void SecondPersonOrNeutralReferenceChangesNothing(string text, string english) => + Assert.Equal(Converter.Convert(text), Converter.Convert(text, null, ReferenceHint.FromText(english))); + + [Fact] + public void ParsesVulkanDevicesAndSkipsSoftwareRenderers() + { + var devices = EmbeddingRuntime.ParseDevices( + "Available devices:\n Vulkan0: AMD Radeon RX 560 Series (RADV POLARIS11) (4096 MiB, 2045 MiB free)\n Vulkan1: llvmpipe (LLVM 17)\n"); + var device = Assert.Single(devices); + Assert.Equal("Vulkan0", device.Id); + Assert.StartsWith("AMD Radeon RX 560", device.Name); + } + + [Theory] + [InlineData("../evil")] + [InlineData("/etc/passwd")] + [InlineData("a\\b")] + public void RuntimeArchivePathsCannotEscape(string entry) => + Assert.Throws(() => EmbeddingAssets.SafePath(Path.GetTempPath(), entry)); + + [Fact] + public void ChangeProposalShowsReferenceOnOneLine() + { + Assert.Equal("EN: his\nstuff".Replace('\n', ' '), new ChangeProposal(0, "a", "b", "his\nstuff").ReferenceText); + Assert.False(new ChangeProposal(0, "a", "b").HasReference); + } + + // Real assets downloaded by the plugin, or PTPT_EMBEDDING_DIR with llama-server and the GGUF. + private static EmbeddingSettings RealSettings(bool gpu) + { + var folder = Environment.GetEnvironmentVariable("PTPT_EMBEDDING_DIR") ?? EmbeddingAssets.DirectoryPath; + var runtime = Directory.GetFiles(folder, "llama-server", SearchOption.AllDirectories).First(); + return new EmbeddingSettings(runtime, Path.Combine(folder, EmbeddingAssets.ModelFile), true, gpu, + Environment.GetEnvironmentVariable("PTPT_VULKAN_DEVICE") ?? "Vulkan0"); + } + + private static (List Source, List Reference) RealPair() + { + // PTPT_SOURCE_SRT and PTPT_ENGLISH_SRT: a real PT-BR subtitle and the English subtitle of the same release. + var source = Environment.GetEnvironmentVariable("PTPT_SOURCE_SRT") + ?? throw new InvalidOperationException("Set PTPT_SOURCE_SRT to a PT-BR .srt file."); + var english = Environment.GetEnvironmentVariable("PTPT_ENGLISH_SRT") + ?? throw new InvalidOperationException("Set PTPT_ENGLISH_SRT to the English .srt of the same release."); + return (ReferenceAligner.Load(source), ReferenceAligner.Load(english)); + } + + [OptInFact("PTPT_TEST_EMBEDDING", "real MiniLM on the CPU")] + public Task RealEmbeddingAlignmentOnCpu() => RealEmbeddingAlignment(false); + + [OptInFact("PTPT_TEST_VULKAN", "real MiniLM on a Vulkan GPU")] + public Task RealEmbeddingAlignmentOnVulkan() => RealEmbeddingAlignment(true); + + private async Task RealEmbeddingAlignment(bool gpu) + { + var (source, reference) = RealPair(); + var shifted = reference.Select(r => Cue((long)(r.StartMs * 25.0 / 23.976) + 4200, (long)(r.EndMs * 25.0 / 23.976) + 4200, r.Text)).ToList(); + await using var runtime = await EmbeddingRuntime.StartAsync(RealSettings(gpu), new Progress(output.WriteLine), default); + Assert.Equal(gpu, runtime.UsesGpu); + var sourceVectors = await runtime.EmbedCuesAsync(source.Select(b => b.Text).ToList(), new Progress(_ => { }), "pt", default); + var referenceVectors = await runtime.EmbedCuesAsync(reference.Select(b => b.Text).ToList(), new Progress(_ => { }), "en", default); + + var alignment = ReferenceAligner.AlignWithEmbeddings(source, reference, sourceVectors, referenceVectors); + var moved = ReferenceAligner.AlignWithEmbeddings(source, shifted, sourceVectors, referenceVectors); + output.WriteLine(alignment.Describe()); + output.WriteLine(moved.Describe()); + Assert.True(alignment.Coverage > 0.95); + Assert.True(moved.Coverage > 0.95); + Assert.True(ReferenceAligner.AlignByTiming(source, shifted).Coverage < 0.9); + var same = Enumerable.Range(0, source.Count).Count(i => alignment.Texts[i] == moved.Texts[i]); + Assert.True(same > source.Count * 0.93, $"{same} of {source.Count} identical"); + // Cues the user reported; 739 drifts in the original files and needs the local correction. + Assert.Contains("his picture", alignment.Texts[331]); + Assert.Contains("his last message", alignment.Texts[726]); + Assert.Contains("Anybody find anything yet?", alignment.Texts[738]); + Assert.Contains("your father", alignment.Texts[818]); + } + + [OptInFact("PTPT_TEST_UI", "native Avalonia window (run under xvfb-run)")] + public void MainWindowAppliesReferenceToProposals() + { + var data = Path.Combine(Path.GetTempPath(), "ptpt-ui-" + Guid.NewGuid().ToString("N")); + Environment.SetEnvironmentVariable("XDG_DATA_HOME", data); + try + { + var english = Path.Combine(data, "episode.en.srt"); + Directory.CreateDirectory(data); + File.WriteAllText(english, "1\n00:00:01,000 --> 00:00:04,000\nSo we got prints and his picture now.\n\n" + + "2\n00:00:05,000 --> 00:00:07,000\nAre you okay?\n\n" + + "3\n00:00:08,000 --> 00:00:10,000\nWe need to talk to your husband. Is he home?\n\n" + + "4\n00:00:11,000 --> 00:00:13,000\nI'm not going to talk to you anymore.\n"); + var subtitle = Path.Combine(data, "episode.pt-br.srt"); + File.WriteAllText(subtitle, ""); + PluginBootstrap.BuildAvaloniaApp().SetupWithoutStarting(); + var repeatedWindow = new MainWindow(new PluginRequest + { + Subtitle = new PluginSubtitle + { + Format = "SubRip", + SubRip = "1\n00:00:01,000 --> 00:00:04,000\nO trem chegou.\n\n" + + "2\n00:00:05,000 --> 00:00:07,000\nO trem chegou.\n", + }, + }); + repeatedWindow.ApplyCheckResults(new[] + { + new CheckLine(0, "O trem chegou.", "O comboio chegou.", null, null), + new CheckLine(1, "O trem chegou.", "O comboio chegou.", "O comboio chegou.", null), + }, new Dictionary + { + [1] = new("O comboio chegou.", "Second cue only."), + }); + Assert.DoesNotContain("Second cue only.", repeatedWindow.Proposals.Single(p => p.LineIndex == 0).ReviewNote ?? ""); + Assert.Contains("Second cue only.", repeatedWindow.Proposals.Single(p => p.LineIndex == 1).ReviewNote); + repeatedWindow.FindControl("MeaningCheck")!.IsChecked = false; + Assert.All(repeatedWindow.Proposals, p => Assert.DoesNotContain("Second cue only.", p.ReviewNote ?? "")); + Assert.Contains("cleared because settings changed", repeatedWindow.ChecksStatusText); + repeatedWindow.ApplyCheckResults(new[] + { + new CheckLine(0, "O trem chegou.", "O comboio chegou.", null, null), + }, new Dictionary { [0] = new("O comboio chegou.", "Old reference result.") }); + repeatedWindow.LoadReferenceAsync(english).GetAwaiter().GetResult(); + Assert.All(repeatedWindow.Proposals, p => Assert.DoesNotContain("Old reference result.", p.ReviewNote ?? "")); + + var filterWindow = new MainWindow(new PluginRequest + { + SettingsVersion = ConversionOptions.Version, + Settings = new ConversionOptions(UseReference: false).ToJson(), + Subtitle = new PluginSubtitle + { + Format = "SubRip", + SubRip = "1\n00:00:01,000 --> 00:00:04,000\nO trem chegou.\n\n" + + "2\n00:00:05,000 --> 00:00:07,000\nBom dia.\n\n" + + "3\n00:00:08,000 --> 00:00:10,000\nBoa noite.\n\n" + + "4\n00:00:11,000 --> 00:00:13,000\nAté amanhã.\n", + }, + }); + filterWindow.ApplyCheckResults(new[] + { + new CheckLine(1, "Bom dia.", "Bom dia.", "O comboio chegou.", null), + new CheckLine(2, "Boa noite.", "Boa noite.", "Bom dia.", null), + new CheckLine(3, "Até amanhã.", "Até amanhã.", "Boa noite.", null), + }, new Dictionary + { + [1] = new("Bom dia.", "MiniLM: check the translation."), + [2] = new("Boa noite!", "Gervásio chose an alternative."), + [3] = new("Até amanhã.", "Review this wording."), + }); + filterWindow.Show(); + Avalonia.Threading.Dispatcher.UIThread.RunJobs(); + var filterNames = new[] { "RuleBasedFilter", "MiniLmFilter", "JudgeFilter", "OtherReviewFilter", "ManualEditFilter" }; + Assert.All(filterNames, name => Assert.True(filterWindow.FindControl(name)!.IsChecked)); + Assert.Equal(4, filterWindow.Proposals.Count); + Assert.All(filterWindow.Proposals, p => Assert.True(p.VisibleInReview)); + void SetFilter(string name, bool enabled) + { + var button = filterWindow.FindControl(name)!; + button.IsChecked = enabled; + button.RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent)); + Avalonia.Threading.Dispatcher.UIThread.RunJobs(); + } + foreach (var name in filterNames) SetFilter(name, false); + Assert.All(filterWindow.Proposals, p => Assert.False(p.VisibleInReview)); + Assert.Contains("Showing 0 of 4", filterWindow.FindControl("SummaryLabel")!.Text); + Assert.True(filterWindow.FindControl + + + + + + + + + + + + + + + + + + + + + + +