tga/auto-subtitle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adds some tests, cleanup a bit

Browse Source
This commit is contained in:
Guillaume Tâche
2024-09-20 08:36:52 +02:00
parent 17086a87ef
commit 703a4c71ae
47 changed files with 1122 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
api/src/test/java/com/github/gtache/autosubtitle/TestVideoInfo.java
View File

@@ -1,22 +1,17 @@
package com.github.gtache.autosubtitle;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Objects;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class TestVideoInfo {
private final VideoInfo videoInfo;
TestVideoInfo(@Mock final VideoInfo videoInfo) {
this.videoInfo = Objects.requireNonNull(videoInfo);
TestVideoInfo() {
this.videoInfo = spy(VideoInfo.class);
}
@Test

7
api/src/test/java/com/github/gtache/autosubtitle/archive/TestArchiver.java
View File

@@ -11,9 +11,14 @@ import static org.mockito.Mockito.when;
class TestArchiver {
private final Archiver archiver;
TestArchiver() {
this.archiver = spy(Archiver.class);
}
@Test
void testIsSupported() {
final var archiver = spy(Archiver.class);
when(archiver.archiveExtension()).thenReturn("test");
assertTrue(archiver.isPathSupported(Paths.get("x.test")));
assertFalse(archiver.isPathSupported(Paths.get("tes")));

18
api/src/test/java/com/github/gtache/autosubtitle/subtitle/TestSubtitleImporterExporter.java
View File

@@ -2,25 +2,35 @@ package com.github.gtache.autosubtitle.subtitle;
import com.github.gtache.autosubtitle.VideoInfo;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import static java.util.Objects.requireNonNull;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class TestSubtitleImporterExporter {
private final SubtitleImporterExporter<Subtitle> importerExporter;
private final SubtitleCollection<Subtitle> subtitleCollection;
TestSubtitleImporterExporter(@Mock final SubtitleCollection<Subtitle> subtitleCollection) {
this.subtitleCollection = requireNonNull(subtitleCollection);
this.importerExporter = spy(SubtitleImporterExporter.class);
}
@Test
void testExportSubtitleCollection() throws IOException {
final var importExporter = spy(SubtitleImporterExporter.class);
final var collection = mock(SubtitleCollection.class);
final var videoInfo = Mockito.mock(VideoInfo.class);
final var file = mock(Path.class);
importExporter.exportSubtitles(collection, videoInfo, file);
verify(importExporter).exportSubtitles(List.of(collection), videoInfo, file);
importerExporter.exportSubtitles(subtitleCollection, videoInfo, file);
verify(importerExporter).exportSubtitles(List.of(subtitleCollection), videoInfo, file);
}
}

45
conda/src/test/java/com/github/gtache/autosubtitle/setup/conda/TestCondaSetupManager.java
View File

@@ -6,6 +6,7 @@ import com.github.gtache.autosubtitle.process.ProcessResult;
import com.github.gtache.autosubtitle.process.ProcessRunner;
import com.github.gtache.autosubtitle.setup.SetupException;
import com.github.gtache.autosubtitle.setup.SetupStatus;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.io.TempDir;
@@ -36,26 +37,30 @@ class TestCondaSetupManager {
private final CondaSetupConfiguration configuration;
private final ProcessRunner processRunner;
private final HttpClient httpClient;
private final HttpResponse<Path> response;
private final CondaSetupManager condaSetupManager;
private final ProcessResult systemProcessResult;
private final Path systemPath;
private final HttpResponse<Path> response;
TestCondaSetupManager(@Mock final CondaSetupConfiguration configuration, @Mock final ProcessRunner processRunner,
@Mock final HttpClient httpClient, @Mock final ProcessResult systemProcessResult, @Mock final HttpResponse<Path> response) throws IOException, InterruptedException {
this.configuration = requireNonNull(configuration);
this.processRunner = requireNonNull(processRunner);
this.httpClient = requireNonNull(httpClient);
this.condaSetupManager = new CondaSetupManager(configuration, processRunner, httpClient);
this.systemProcessResult = requireNonNull(systemProcessResult);
this.systemPath = Paths.get("system");
this.response = requireNonNull(response);
when(response.statusCode()).thenReturn(200);
this.condaSetupManager = new CondaSetupManager(configuration, processRunner, httpClient);
this.systemPath = Paths.get("system");
}
@BeforeEach
void beforeEach() throws IOException, InterruptedException {
when(configuration.condaSystemPath()).thenReturn(systemPath);
when(systemProcessResult.output()).thenReturn(List.of("conda 99.99.99"));
when(systemProcessResult.exitCode()).thenReturn(0);
when(processRunner.run(List.of(systemPath.toString(), "--version"), Duration.ofSeconds(5))).thenReturn(systemProcessResult);
when(httpClient.send(any(HttpRequest.class), any(HttpResponse.BodyHandler.class))).thenReturn(response);
when(response.statusCode()).thenReturn(200);
}
@Test
@@ -117,10 +122,7 @@ class TestCondaSetupManager {
when(processRunner.run(args, Duration.ofMinutes(15))).thenReturn(result);
assertDoesNotThrow(condaSetupManager::install);
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getValue();
assertEquals("https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe", request.uri().toString());
checkURLRequested("https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe");
verify(processRunner).run(args, Duration.ofMinutes(15));
}
@@ -140,10 +142,7 @@ class TestCondaSetupManager {
when(processRunner.run(args, Duration.ofMinutes(15))).thenReturn(result);
assertDoesNotThrow(condaSetupManager::install);
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getValue();
assertEquals("https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh", request.uri().toString());
checkURLRequested("https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh");
verify(processRunner).run(args, Duration.ofMinutes(15));
}
@@ -163,10 +162,7 @@ class TestCondaSetupManager {
when(processRunner.run(args, Duration.ofMinutes(15))).thenReturn(result);
assertDoesNotThrow(condaSetupManager::install);
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getValue();
assertEquals("https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh", request.uri().toString());
checkURLRequested("https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh");
verify(processRunner).run(args, Duration.ofMinutes(15));
}
@@ -200,10 +196,7 @@ class TestCondaSetupManager {
when(processRunner.run(args, Duration.ofMinutes(15))).thenReturn(result);
assertDoesNotThrow(condaSetupManager::install);
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getValue();
assertEquals("https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh", request.uri().toString());
checkURLRequested("https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh");
verify(processRunner).run(args, Duration.ofMinutes(15));
}
@@ -223,10 +216,7 @@ class TestCondaSetupManager {
when(processRunner.run(args, Duration.ofMinutes(15))).thenReturn(result);
assertDoesNotThrow(condaSetupManager::install);
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getValue();
assertEquals("https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh", request.uri().toString());
checkURLRequested("https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh");
verify(processRunner).run(args, Duration.ofMinutes(15));
}
@@ -510,4 +500,11 @@ class TestCondaSetupManager {
assertThrows(NullPointerException.class, () -> new CondaSetupManager(configuration, processRunner, null));
}
private void checkURLRequested(final String url) throws IOException, InterruptedException {
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getValue();
assertEquals(url, request.uri().toString());
}
}

12
core/src/test/java/com/github/gtache/autosubtitle/archive/impl/TestArchiverProviderImpl.java
View File

@@ -2,12 +2,12 @@ package com.github.gtache.autosubtitle.archive.impl;
import com.github.gtache.autosubtitle.archive.Archiver;
import com.github.gtache.autosubtitle.archive.ArchiverProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collection;
import java.util.Map;
import java.util.Objects;
@@ -22,16 +22,20 @@ class TestArchiverProviderImpl {
private final ArchiverProvider archiverProvider;
TestArchiverProviderImpl(@Mock final Archiver zipArchiver, @Mock final Archiver rarArchiver) {
when(zipArchiver.archiveExtension()).thenReturn("zip");
when(rarArchiver.archiveExtension()).thenReturn("rar");
this.zipArchiver = Objects.requireNonNull(zipArchiver);
this.rarArchiver = Objects.requireNonNull(rarArchiver);
this.archiverProvider = new ArchiverProviderImpl(Map.of("zip", zipArchiver, "rar", rarArchiver));
}
@BeforeEach
void beforeEach() {
when(zipArchiver.archiveExtension()).thenReturn("zip");
when(rarArchiver.archiveExtension()).thenReturn("rar");
}
@Test
void testAllArchivers() {
final Collection<Archiver> allArchivers = archiverProvider.allArchivers();
final var allArchivers = archiverProvider.allArchivers();
assertEquals(2, allArchivers.size());
assertTrue(allArchivers.contains(zipArchiver));
assertTrue(allArchivers.contains(rarArchiver));

11
core/src/test/java/com/github/gtache/autosubtitle/archive/impl/TestZipDecompresser.java
View File

@@ -29,13 +29,18 @@ class TestZipDecompresser {
@Test
void testCompress() {
assertThrows(UnsupportedOperationException.class, () -> zipDecompresser.compress(List.of(Paths.get("file.txt")), Paths.get("target")));
final var paths = List.of(Paths.get("file.txt"));
final var target = Paths.get("target");
assertThrows(UnsupportedOperationException.class, () -> zipDecompresser.compress(paths, target));
}
@Test
void testDecompress(@TempDir final Path tempDir) throws IOException {
final var file = tempDir.resolve("test.zip");
try (final var in = getClass().getResourceAsStream("in.zip")) {
if (in == null) {
throw new IOException("in.zip not found");
}
Files.copy(in, file);
}
zipDecompresser.decompress(file, tempDir);
@@ -57,6 +62,8 @@ class TestZipDecompresser {
@Test
void testIllegal() {
assertThrows(IllegalArgumentException.class, () -> zipDecompresser.decompress(Paths.get("file.txt"), Paths.get("target")));
final var source = Paths.get("source");
final var target = Paths.get("target");
assertThrows(IllegalArgumentException.class, () -> zipDecompresser.decompress(source, target));
}
}

2
core/src/test/java/com/github/gtache/autosubtitle/impl/TestFileAudioImpl.java
View File

@@ -21,7 +21,7 @@ class TestFileAudioImpl {
private final Path path;
private final AudioInfo info;
TestFileAudioImpl(@Mock final Path path, @Mock final AudioInfo info) throws IOException {
TestFileAudioImpl(@Mock final Path path, @Mock final AudioInfo info) {
this.path = requireNonNull(path);
this.info = requireNonNull(info);
}

2
core/src/test/java/com/github/gtache/autosubtitle/impl/TestMemoryAudioImpl.java
View File

@@ -20,7 +20,7 @@ class TestMemoryAudioImpl {
private final Supplier<InputStream> supplier;
private final AudioInfo info;
TestMemoryAudioImpl(@Mock InputStream inputStream, @Mock AudioInfo info) {
TestMemoryAudioImpl(@Mock final InputStream inputStream, @Mock final AudioInfo info) {
this.supplier = () -> requireNonNull(inputStream);
this.info = requireNonNull(info);
}

2
core/src/test/java/com/github/gtache/autosubtitle/impl/TestMemoryVideoImpl.java
View File

@@ -19,7 +19,7 @@ class TestMemoryVideoImpl {
private final Supplier<InputStream> supplier;
private final VideoInfo info;
TestMemoryVideoImpl(@Mock InputStream inputStream, @Mock VideoInfo info) {
TestMemoryVideoImpl(@Mock final InputStream inputStream, @Mock final VideoInfo info) {
this.supplier = () -> requireNonNull(inputStream);
this.info = requireNonNull(info);
}

4
core/src/test/java/com/github/gtache/autosubtitle/impl/TestVideoInfoImpl.java
View File

@@ -1,5 +1,6 @@
package com.github.gtache.autosubtitle.impl;
import com.github.gtache.autosubtitle.VideoInfo;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -11,17 +12,18 @@ class TestVideoInfoImpl {
private final int width;
private final int height;
private final long duration;
private final VideoInfo videoInfo;
TestVideoInfoImpl() {
this.videoFormat = "format";
this.width = 1;
this.height = 2;
this.duration = 3;
this.videoInfo = new VideoInfoImpl(videoFormat, width, height, duration);
}
@Test
void testGetters() {
final var videoInfo = new VideoInfoImpl(videoFormat, width, height, duration);
assertEquals(videoFormat, videoInfo.format());
assertEquals(width, videoInfo.width());
assertEquals(height, videoInfo.height());

11
core/src/test/java/com/github/gtache/autosubtitle/process/impl/TestProcessListenerImpl.java
View File

@@ -1,6 +1,7 @@
package com.github.gtache.autosubtitle.process.impl;
import com.github.gtache.autosubtitle.process.ProcessListener;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -21,11 +22,15 @@ import static org.mockito.Mockito.when;
class TestProcessListenerImpl {
private final Process process;
private final ProcessListener listener;
private ProcessListener listener;
TestProcessListenerImpl(@Mock Process process) {
final var inputStream = new ByteArrayInputStream("line1\nline2\nline3".getBytes());
TestProcessListenerImpl(@Mock final Process process) {
this.process = Objects.requireNonNull(process);
}
@BeforeEach
void beforeEach() {
final var inputStream = new ByteArrayInputStream("line1\nline2\nline3".getBytes());
when(process.getInputStream()).thenReturn(inputStream);
this.listener = new ProcessListenerImpl(process);
}

8
core/src/test/java/com/github/gtache/autosubtitle/setup/impl/TestAbstractSetupManager.java
View File

@@ -30,7 +30,6 @@ class TestAbstractSetupManager {
private final SetupListener listener2;
private final SetupEvent event;
private final SetupAction setupAction;
private final ProcessRunner processRunner;
private final HttpClient httpClient;
TestAbstractSetupManager(@Mock final SetupListener listener1,
@@ -44,7 +43,6 @@ class TestAbstractSetupManager {
this.listener2 = requireNonNull(listener2);
this.event = requireNonNull(event);
this.setupAction = requireNonNull(setupAction);
this.processRunner = requireNonNull(processRunner);
this.httpClient = requireNonNull(httpClient);
}
@@ -247,15 +245,15 @@ class TestAbstractSetupManager {
}
@Override
public void install() throws SetupException {
public void install() {
}
@Override
public void uninstall() throws SetupException {
public void uninstall() {
}
@Override
public void update() throws SetupException {
public void update() {
}
}
}

14
core/src/test/java/com/github/gtache/autosubtitle/subtitle/converter/impl/TestASSSubtitleConverter.java
View File

@@ -2,11 +2,13 @@ package com.github.gtache.autosubtitle.subtitle.converter.impl;
import com.github.gtache.autosubtitle.Language;
import com.github.gtache.autosubtitle.VideoInfo;
import com.github.gtache.autosubtitle.subtitle.Subtitle;
import com.github.gtache.autosubtitle.subtitle.converter.ParseException;
import com.github.gtache.autosubtitle.subtitle.impl.FontImpl;
import com.github.gtache.autosubtitle.subtitle.impl.SubtitleCollectionImpl;
import com.github.gtache.autosubtitle.subtitle.impl.SubtitleImpl;
import com.github.gtache.autosubtitle.translation.Translator;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -24,7 +26,7 @@ import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class TestASSSubtitleConverter {
private final Translator translator;
private final Translator<Subtitle> translator;
private final Preferences preferences;
private final Language language;
private final VideoInfo videoInfo;
@@ -32,7 +34,7 @@ class TestASSSubtitleConverter {
private final int defaultFontSize;
private final ASSSubtitleConverter converter;
TestASSSubtitleConverter(@Mock final Translator translator,
TestASSSubtitleConverter(@Mock final Translator<Subtitle> translator,
@Mock final Preferences preferences,
@Mock final Language language,
@Mock final VideoInfo videoInfo) {
@@ -40,11 +42,15 @@ class TestASSSubtitleConverter {
this.preferences = Objects.requireNonNull(preferences);
this.language = Objects.requireNonNull(language);
this.videoInfo = Objects.requireNonNull(videoInfo);
when(videoInfo.width()).thenReturn(1920);
when(videoInfo.height()).thenReturn(1080);
this.defaultFontName = "Arial";
this.defaultFontSize = 12;
this.converter = new ASSSubtitleConverter(translator, preferences, defaultFontName, defaultFontSize);
}
@BeforeEach
void beforeEach() {
when(videoInfo.width()).thenReturn(1920);
when(videoInfo.height()).thenReturn(1080);
when(translator.getLanguage(anyString())).thenReturn(language);
}

10
core/src/test/java/com/github/gtache/autosubtitle/subtitle/converter/impl/TestSRTSubtitleConverter.java
View File

@@ -2,10 +2,12 @@ package com.github.gtache.autosubtitle.subtitle.converter.impl;
import com.github.gtache.autosubtitle.Language;
import com.github.gtache.autosubtitle.VideoInfo;
import com.github.gtache.autosubtitle.subtitle.Subtitle;
import com.github.gtache.autosubtitle.subtitle.converter.ParseException;
import com.github.gtache.autosubtitle.subtitle.impl.SubtitleCollectionImpl;
import com.github.gtache.autosubtitle.subtitle.impl.SubtitleImpl;
import com.github.gtache.autosubtitle.translation.Translator;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -22,16 +24,20 @@ import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class TestSRTSubtitleConverter {
private final Translator translator;
private final Translator<Subtitle> translator;
private final Language language;
private final VideoInfo videoInfo;
private final SRTSubtitleConverter converter;
TestSRTSubtitleConverter(@Mock final Translator translator, @Mock final Language language, @Mock final VideoInfo videoInfo) {
TestSRTSubtitleConverter(@Mock final Translator<Subtitle> translator, @Mock final Language language, @Mock final VideoInfo videoInfo) {
this.translator = Objects.requireNonNull(translator);
this.language = Objects.requireNonNull(language);
this.videoInfo = Objects.requireNonNull(videoInfo);
this.converter = new SRTSubtitleConverter(translator);
}
@BeforeEach
void beforeEach() {
when(translator.getLanguage(anyString())).thenReturn(language);
}

7
core/src/test/java/com/github/gtache/autosubtitle/subtitle/converter/impl/TestSubtitleConverterProviderImpl.java
View File

@@ -1,5 +1,6 @@
package com.github.gtache.autosubtitle.subtitle.converter.impl;
import com.github.gtache.autosubtitle.subtitle.Subtitle;
import com.github.gtache.autosubtitle.subtitle.converter.SubtitleConverter;
import com.github.gtache.autosubtitle.subtitle.converter.SubtitleConverterProvider;
import org.junit.jupiter.api.Test;
@@ -15,11 +16,11 @@ import static org.junit.jupiter.api.Assertions.*;
@ExtendWith(MockitoExtension.class)
class TestSubtitleConverterProviderImpl {
private final SubtitleConverter first;
private final SubtitleConverter second;
private final SubtitleConverter<Subtitle> first;
private final SubtitleConverter<Subtitle> second;
private final SubtitleConverterProvider provider;
TestSubtitleConverterProviderImpl(@Mock final SubtitleConverter first, @Mock final SubtitleConverter second) {
TestSubtitleConverterProviderImpl(@Mock final SubtitleConverter<Subtitle> first, @Mock final SubtitleConverter<Subtitle> second) {
this.first = Objects.requireNonNull(first);
this.second = Objects.requireNonNull(second);
this.provider = new SubtitleConverterProviderImpl(Map.of("first", first, "second", second));

5
core/src/test/java/com/github/gtache/autosubtitle/subtitle/extractor/impl/TestAbstractSubtitleExtractor.java
View File

@@ -6,7 +6,6 @@ import com.github.gtache.autosubtitle.Video;
import com.github.gtache.autosubtitle.subtitle.Subtitle;
import com.github.gtache.autosubtitle.subtitle.SubtitleCollection;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractEvent;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractException;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractionModel;
import com.github.gtache.autosubtitle.subtitle.extractor.SubtitleExtractorListener;
import org.junit.jupiter.api.Test;
@@ -57,12 +56,12 @@ class TestAbstractSubtitleExtractor {
private static final class DummySubtitleExtractor extends AbstractSubtitleExtractor {
@Override
public SubtitleCollection extract(final Video video, final Language language, final ExtractionModel model) throws ExtractException {
public SubtitleCollection<Subtitle> extract(final Video video, final Language language, final ExtractionModel model) {
throw new UnsupportedOperationException();
}
@Override
public SubtitleCollection<Subtitle> extract(final Audio audio, final Language language, final ExtractionModel model) throws ExtractException {
public SubtitleCollection<Subtitle> extract(final Audio audio, final Language language, final ExtractionModel model) {
throw new UnsupportedOperationException();
}
}

8
core/src/test/java/com/github/gtache/autosubtitle/subtitle/impl/TestSubtitleCollectionImpl.java
View File

@@ -28,7 +28,7 @@ class TestSubtitleCollectionImpl {
@Test
void testGetters() {
final var text = "test";
final var collection = new SubtitleCollectionImpl(text, subtitles, langue);
final var collection = new SubtitleCollectionImpl<>(text, subtitles, langue);
assertEquals(text, collection.text());
assertEquals(subtitles, collection.subtitles());
assertEquals(langue, collection.language());
@@ -37,8 +37,8 @@ class TestSubtitleCollectionImpl {
@Test
void testIllegal() {
final var text = "";
assertThrows(NullPointerException.class, () -> new SubtitleCollectionImpl(null, subtitles, langue));
assertThrows(NullPointerException.class, () -> new SubtitleCollectionImpl(text, null, langue));
assertThrows(NullPointerException.class, () -> new SubtitleCollectionImpl(text, subtitles, null));
assertThrows(NullPointerException.class, () -> new SubtitleCollectionImpl<>(null, subtitles, langue));
assertThrows(NullPointerException.class, () -> new SubtitleCollectionImpl<>(text, null, langue));
assertThrows(NullPointerException.class, () -> new SubtitleCollectionImpl<>(text, subtitles, null));
}
}

8
ffmpeg/src/main/java/com/github/gtache/autosubtitle/setup/ffmpeg/FFmpegSetupManager.java
View File

@@ -65,6 +65,7 @@ public class FFmpegSetupManager extends AbstractSetupManager {
case WINDOWS -> installWindows();
case LINUX -> installLinux();
case MAC -> installMac();
case UNKNOWN -> throw new SetupException("Unknown OS : " + configuration.os());
}
}
@@ -179,15 +180,14 @@ public class FFmpegSetupManager extends AbstractSetupManager {
}
}
@Override
public void uninstall() throws SetupException {
deleteFolder(configuration.root());
}
@Override
public void update() throws SetupException {
public void update() {
//TODO
}
private boolean checkSystemFFmpeg() throws IOException {
@@ -195,7 +195,7 @@ public class FFmpegSetupManager extends AbstractSetupManager {
return result.exitCode() == 0;
}
private boolean checkBundledFFmpeg() throws IOException {
private boolean checkBundledFFmpeg() {
return Files.isRegularFile(configuration.bundledFFmpegPath());
}
}

3
ffmpeg/src/test/java/com/github/gtache/autosubtitle/archive/ffmpeg/TestTarArchiver.java
View File

@@ -30,6 +30,9 @@ class TestTarArchiver {
void testDecompress(@TempDir final Path tempDir) throws IOException {
final var file = tempDir.resolve("test.tar");
try (final var in = getClass().getResourceAsStream("in.tar")) {
if (in == null) {
throw new IOException("Unable to find in.tar");
}
Files.copy(in, file);
}
tarArchiver.decompress(file, tempDir);

3
ffmpeg/src/test/java/com/github/gtache/autosubtitle/archive/ffmpeg/TestXZArchiver.java
View File

@@ -30,6 +30,9 @@ class TestXZArchiver {
void testDecompress(@TempDir final Path tempDir) throws IOException {
final var file = tempDir.resolve("in.txt.xz");
try (final var in = getClass().getResourceAsStream("in.txt.xz")) {
if (in == null) {
throw new IOException("Unable to find in.txt.xz");
}
Files.copy(in, file);
}
xzArchiver.decompress(file, tempDir);

5
ffmpeg/src/test/java/com/github/gtache/autosubtitle/ffmpeg/TestFFmpegVideoConverter.java
View File

@@ -4,6 +4,7 @@ import com.github.gtache.autosubtitle.Video;
import com.github.gtache.autosubtitle.VideoInfo;
import com.github.gtache.autosubtitle.impl.OS;
import com.github.gtache.autosubtitle.process.ProcessRunner;
import com.github.gtache.autosubtitle.subtitle.Subtitle;
import com.github.gtache.autosubtitle.subtitle.SubtitleCollection;
import com.github.gtache.autosubtitle.subtitle.converter.SubtitleConverter;
import com.github.gtache.autosubtitle.subtitle.converter.SubtitleConverterProvider;
@@ -26,7 +27,7 @@ class TestFFmpegVideoConverter {
private final FFmpegVideoConverter converter;
private final ProcessRunner runner;
private final SubtitleConverter subtitleConverter;
private final SubtitleConverter<Subtitle> subtitleConverter;
private final SubtitleConverterProvider subtitleConverterProvider;
private final Video video;
private final VideoInfo videoInfo;
@@ -35,7 +36,7 @@ class TestFFmpegVideoConverter {
private final SubtitleCollection<?> collection;
private final Preferences preferences;
TestFFmpegVideoConverter(@Mock final SubtitleConverter subtitleConverter, @Mock final ProcessRunner runner, @Mock final SubtitleConverterProvider subtitleConverterProvider, @Mock final Video video,
TestFFmpegVideoConverter(@Mock final SubtitleConverter<Subtitle> subtitleConverter, @Mock final ProcessRunner runner, @Mock final SubtitleConverterProvider subtitleConverterProvider, @Mock final Video video,
@Mock final VideoInfo videoInfo, @Mock final SubtitleCollection<?> collection, @Mock final Preferences preferences) throws IOException {
final var output = (OS.getOS() == OS.WINDOWS ? System.getProperty("java.io.tmpdir") : "/tmp");
final var resource = OS.getOS() == OS.WINDOWS ? "fake-ffmpeg.exe" : "fake-ffmpeg.sh";

3
ffmpeg/src/test/java/com/github/gtache/autosubtitle/ffmpeg/TestFFmpegVideoLoader.java
View File

@@ -33,6 +33,9 @@ class TestFFmpegVideoLoader {
final var resource = OS.getOS() == OS.WINDOWS ? "fake-ffprobe.exe" : "fake-ffprobe.sh";
this.tmpFile = Files.createTempFile("fake-ffprobe", resource.substring(resource.lastIndexOf('.')));
try (final var in = getClass().getResourceAsStream(resource)) {
if (in == null) {
throw new IOException("Unable to find " + resource);
}
Files.copy(in, tmpFile, StandardCopyOption.REPLACE_EXISTING);
}
this.outputPath = Path.of(output, "test-ffprobe-output.txt");

270
ffmpeg/src/test/java/com/github/gtache/autosubtitle/setup/ffmpeg/TestFFmpegSetupManager.java
View File

@@ -1,4 +1,274 @@
package com.github.gtache.autosubtitle.setup.ffmpeg;
import com.github.gtache.autosubtitle.archive.Archiver;
import com.github.gtache.autosubtitle.archive.ArchiverProvider;
import com.github.gtache.autosubtitle.impl.Architecture;
import com.github.gtache.autosubtitle.impl.OS;
import com.github.gtache.autosubtitle.process.ProcessResult;
import com.github.gtache.autosubtitle.process.ProcessRunner;
import com.github.gtache.autosubtitle.setup.SetupException;
import com.github.gtache.autosubtitle.setup.SetupStatus;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.io.TempDir;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;
import java.util.List;
import static java.util.Objects.requireNonNull;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class TestFFmpegSetupManager {
private final FFmpegSetupConfiguration configuration;
private final ArchiverProvider archiverProvider;
private final Archiver archiver;
private final ProcessRunner processRunner;
private final HttpClient httpClient;
private final HttpResponse<Path> response;
private final FFmpegSetupManager setupManager;
private final ProcessResult processResult;
private final Path systemPath;
private final Path ffmpegInstallerPath;
private final Path ffprobeInstallerPath;
private final Path rootPath;
TestFFmpegSetupManager(@Mock final FFmpegSetupConfiguration configuration, @Mock final ArchiverProvider archiverProvider,
@Mock final Archiver archiver, @Mock final ProcessRunner processRunner,
@Mock final HttpClient httpClient, @Mock final ProcessResult processResult, @Mock final HttpResponse<Path> response) {
this.configuration = requireNonNull(configuration);
this.archiverProvider = requireNonNull(archiverProvider);
this.archiver = requireNonNull(archiver);
this.processRunner = requireNonNull(processRunner);
this.httpClient = requireNonNull(httpClient);
this.response = requireNonNull(response);
this.setupManager = new FFmpegSetupManager(configuration, archiverProvider, processRunner, httpClient);
this.processResult = requireNonNull(processResult);
this.systemPath = Paths.get("system");
this.ffmpegInstallerPath = Paths.get("ffmpeg.sh");
this.ffprobeInstallerPath = Paths.get("ffprobe.sh");
this.rootPath = Paths.get("root");
}
@BeforeEach
void beforeEach() throws IOException, InterruptedException {
when(configuration.systemFFmpegPath()).thenReturn(systemPath);
when(configuration.root()).thenReturn(rootPath);
when(configuration.ffmpegInstallerPath()).thenReturn(ffmpegInstallerPath);
when(configuration.ffprobeInstallerPath()).thenReturn(ffprobeInstallerPath);
when(archiverProvider.getArchiver("sh")).thenReturn(archiver);
when(archiverProvider.getArchiver("tar")).thenReturn(archiver);
when(processRunner.run(List.of(systemPath.toString(), "-version"), Duration.ofSeconds(5))).thenReturn(processResult);
when(httpClient.send(any(HttpRequest.class), any(HttpResponse.BodyHandler.class))).thenReturn(response);
when(response.statusCode()).thenReturn(200);
}
@Test
void testName() {
assertEquals("FFmpeg", setupManager.name());
}
@Test
void testGetStatusSystemFalse() throws IOException, SetupException {
final var ffmpegPath = Paths.get("path");
when(configuration.bundledFFmpegPath()).thenReturn(ffmpegPath);
when(processResult.exitCode()).thenReturn(1);
when(processRunner.run(List.of(systemPath.toString(), "-version"), Duration.ofSeconds(5))).thenReturn(processResult);
assertEquals(SetupStatus.NOT_INSTALLED, setupManager.getStatus());
verify(processRunner).run(List.of(systemPath.toString(), "-version"), Duration.ofSeconds(5));
}
@Test
void testGetStatusSystemException() throws IOException, SetupException {
final var ffmpegPath = Paths.get("path");
when(configuration.bundledFFmpegPath()).thenReturn(ffmpegPath);
when(processRunner.run(List.of(systemPath.toString(), "-version"), Duration.ofSeconds(5))).thenThrow(IOException.class);
assertThrows(SetupException.class, setupManager::getStatus);
verify(processRunner).run(List.of(systemPath.toString(), "-version"), Duration.ofSeconds(5));
}
@Test
void testGetStatusSystemTrue() throws IOException, SetupException {
final var ffmpegPath = Paths.get("path");
when(configuration.bundledFFmpegPath()).thenReturn(ffmpegPath);
when(processRunner.run(List.of(systemPath.toString(), "-version"), Duration.ofSeconds(5))).thenReturn(processResult);
assertEquals(SetupStatus.SYSTEM_INSTALLED, setupManager.getStatus());
verify(processRunner).run(List.of(systemPath.toString(), "-version"), Duration.ofSeconds(5));
}
@Test
void testGetStatusBundledFalse(@TempDir final Path tempDir) throws IOException, SetupException {
final var ffmpegPath = tempDir.resolve("ffmpeg");
Files.deleteIfExists(ffmpegPath);
when(configuration.bundledFFmpegPath()).thenReturn(ffmpegPath);
when(processResult.exitCode()).thenReturn(1);
when(processRunner.run(anyList(), any())).thenReturn(processResult);
assertEquals(SetupStatus.NOT_INSTALLED, setupManager.getStatus());
}
@Test
void testGetStatusBundledTrue(@TempDir final Path tempDir) throws IOException, SetupException {
final var ffmpegPath = tempDir.resolve("ffmpeg");
Files.createFile(ffmpegPath);
when(configuration.bundledFFmpegPath()).thenReturn(ffmpegPath);
when(processResult.exitCode()).thenReturn(1);
when(processRunner.run(anyList(), any())).thenReturn(processResult);
assertEquals(SetupStatus.BUNDLE_INSTALLED, setupManager.getStatus());
}
@Test
void testInstallWindowsDecompressError() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.WINDOWS);
when(configuration.architecture()).thenReturn(Architecture.UNKNOWN);
doThrow(IOException.class).when(archiver).decompress(ffmpegInstallerPath, rootPath);
assertThrows(SetupException.class, setupManager::install);
verify(archiver).decompress(ffmpegInstallerPath, rootPath);
checkURLRequested("https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip");
}
@Test
void testInstallWindows() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.WINDOWS);
when(configuration.architecture()).thenReturn(Architecture.UNKNOWN);
assertDoesNotThrow(setupManager::install);
verify(archiver).decompress(ffmpegInstallerPath, rootPath);
checkURLRequested("https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip");
}
@Test
void testInstallLinuxAMD64() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.LINUX);
when(configuration.architecture()).thenReturn(Architecture.AMD64);
assertDoesNotThrow(setupManager::install);
verify(archiver).decompress(eq(ffmpegInstallerPath), any());
verify(archiver).decompress(any(), eq(rootPath));
checkURLRequested("https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz");
}
@Test
void testInstallLinuxARM64() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.LINUX);
when(configuration.architecture()).thenReturn(Architecture.ARM64);
assertDoesNotThrow(setupManager::install);
verify(archiver).decompress(eq(ffmpegInstallerPath), any());
verify(archiver).decompress(any(), eq(rootPath));
checkURLRequested("https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-arm64-static.tar.xz");
}
@Test
void testInstallLinuxI686() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.LINUX);
when(configuration.architecture()).thenReturn(Architecture.I686);
assertDoesNotThrow(setupManager::install);
verify(archiver).decompress(eq(ffmpegInstallerPath), any());
verify(archiver).decompress(any(), eq(rootPath));
checkURLRequested("https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-i686-static.tar.xz");
}
@Test
void testInstallLinuxARMHF() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.LINUX);
when(configuration.architecture()).thenReturn(Architecture.ARMHF);
assertDoesNotThrow(setupManager::install);
verify(archiver).decompress(eq(ffmpegInstallerPath), any());
verify(archiver).decompress(any(), eq(rootPath));
checkURLRequested("https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-armhf-static.tar.xz");
}
@Test
void testInstallLinuxARMEL() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.LINUX);
when(configuration.architecture()).thenReturn(Architecture.ARMEL);
assertDoesNotThrow(setupManager::install);
verify(archiver).decompress(eq(ffmpegInstallerPath), any());
verify(archiver).decompress(any(), eq(rootPath));
checkURLRequested("https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-armel-static.tar.xz");
}
@Test
void testInstallLinuxUnsupportedArchitecture() {
when(configuration.os()).thenReturn(OS.LINUX);
when(configuration.architecture()).thenReturn(Architecture.UNKNOWN);
assertThrows(SetupException.class, setupManager::install);
verifyNoInteractions(httpClient, archiver);
}
@Test
void testInstallMacAMD64() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.MAC);
when(configuration.architecture()).thenReturn(Architecture.AMD64);
assertDoesNotThrow(setupManager::install);
verify(archiver).decompress(ffmpegInstallerPath, rootPath);
verify(archiver).decompress(ffprobeInstallerPath, rootPath);
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient, times(2)).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getAllValues();
assertTrue(request.stream().anyMatch(r -> r.uri().toString().equals("https://evermeet.cx/ffmpeg/getrelease/ffmpeg/zip")));
assertTrue(request.stream().anyMatch(r -> r.uri().toString().equals("https://evermeet.cx/ffmpeg/getrelease/ffprobe/zip")));
}
@Test
void testInstallMacARM64() throws IOException, InterruptedException {
when(configuration.os()).thenReturn(OS.MAC);
when(configuration.architecture()).thenReturn(Architecture.ARM64);
assertDoesNotThrow(setupManager::install);
verify(archiver).decompress(ffmpegInstallerPath, rootPath);
verify(archiver).decompress(ffprobeInstallerPath, rootPath);
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient, times(2)).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getAllValues();
assertTrue(request.stream().anyMatch(r -> r.uri().toString().equals("https://www.osxexperts.net/ffmpeg7arm.zip")));
assertTrue(request.stream().anyMatch(r -> r.uri().toString().equals("https://www.osxexperts.net/ffprobe7arm.zip")));
}
@Test
void testInstallMacUnsupportedArchitecture() {
when(configuration.os()).thenReturn(OS.MAC);
when(configuration.architecture()).thenReturn(Architecture.ARM32);
assertThrows(SetupException.class, setupManager::install);
verifyNoInteractions(httpClient, archiver);
}
@Test
void testInstallUnknownOS() {
when(configuration.os()).thenReturn(OS.UNKNOWN);
assertThrows(SetupException.class, setupManager::install);
verifyNoInteractions(httpClient, archiver);
}
@Test
void testUninstall(@TempDir final Path tempDir) throws SetupException, IOException {
final var subdir = tempDir.resolve("subfolder");
Files.createDirectories(subdir);
final var subpath = subdir.resolve("subfile");
Files.createFile(subpath);
final var file = tempDir.resolve("rootfile");
Files.createFile(file);
when(configuration.root()).thenReturn(tempDir);
setupManager.uninstall();
assertFalse(Files.exists(tempDir));
}
private void checkURLRequested(final String url) throws IOException, InterruptedException {
final var requestCapture = ArgumentCaptor.forClass(HttpRequest.class);
verify(httpClient).send(requestCapture.capture(), any(HttpResponse.BodyHandler.class));
final var request = requestCapture.getValue();
assertEquals(url, request.uri().toString());
}
}

32
gui/core/src/test/java/com/github/gtache/autosubtitle/gui/impl/TestCombinedResourceBundle.java
View File

@@ -17,9 +17,13 @@ import static org.mockito.Mockito.when;
class TestCombinedResourceBundle {
private static final ResourceBundle BUNDLE = new CombinedResourceBundle(
ResourceBundle.getBundle("com.github.gtache.autosubtitle.gui.impl.MultiBundle", Locale.FRENCH),
ResourceBundle.getBundle("com.github.gtache.autosubtitle.gui.impl.MultiBundleTwo", Locale.FRENCH));
private final ResourceBundle bundle;
TestCombinedResourceBundle() {
this.bundle = new CombinedResourceBundle(
ResourceBundle.getBundle("com.github.gtache.autosubtitle.gui.impl.MultiBundle", Locale.FRENCH),
ResourceBundle.getBundle("com.github.gtache.autosubtitle.gui.impl.MultiBundleTwo", Locale.FRENCH));
}
@Test
void testIllegal() {
@@ -29,26 +33,26 @@ class TestCombinedResourceBundle {
@Test
void testWorks() {
assertEquals("deux", BUNDLE.getString("a"));
assertEquals("deux", BUNDLE.getString("b"));
assertEquals("trois", BUNDLE.getString("c"));
assertEquals("un", BUNDLE.getString("d"));
assertEquals(Arrays.asList("a", "b", "c", "d"), Collections.list(BUNDLE.getKeys()));
assertEquals("deux", bundle.getString("a"));
assertEquals("deux", bundle.getString("b"));
assertEquals("trois", bundle.getString("c"));
assertEquals("un", bundle.getString("d"));
assertEquals(Arrays.asList("a", "b", "c", "d"), Collections.list(bundle.getKeys()));
}
@Test
void testNotFound() {
assertThrows(MissingResourceException.class, () -> BUNDLE.getString("e"));
assertThrows(MissingResourceException.class, () -> bundle.getString("e"));
}
@Test
void testLocale() {
final var bundle = mock(ResourceBundle.class);
when(bundle.keySet()).thenReturn(Set.of());
when(bundle.getString(anyString())).thenReturn("");
final var mocked = mock(ResourceBundle.class);
when(mocked.keySet()).thenReturn(Set.of());
when(mocked.getString(anyString())).thenReturn("");
final var locale = mock(Locale.class);
when(bundle.getLocale()).thenReturn(locale);
final var combined = new CombinedResourceBundle(bundle);
when(mocked.getLocale()).thenReturn(locale);
final var combined = new CombinedResourceBundle(mocked);
assertEquals(locale, combined.getLocale());
}
}

4
gui/fx/src/main/java/com/github/gtache/autosubtitle/gui/parameters/fx/FXParametersModel.java
View File

@@ -41,8 +41,8 @@ public class FXParametersModel implements ParametersModel {
@FontSize final int defaultFontSize, @MaxLineLength final int defaultMaxLineLength, @MaxLines final int defaultMaxLines) {
this.availableExtractionModels = FXCollections.unmodifiableObservableList(FXCollections.observableArrayList(extractionModelProvider.getAvailableExtractionModels()));
this.extractionModel = new SimpleObjectProperty<>(extractionModelProvider.getDefaultExtractionModel());
this.availableOutputFormats = FXCollections.unmodifiableObservableList(FXCollections.observableArrayList(OutputFormat.values()));
this.outputFormat = new SimpleObjectProperty<>(OutputFormat.ASS);
this.availableOutputFormats = FXCollections.unmodifiableObservableList(FXCollections.observableArrayList(OutputFormat.SRT));
this.outputFormat = new SimpleObjectProperty<>(OutputFormat.SRT);
this.availableFontFamilies = FXCollections.unmodifiableObservableList(FXCollections.observableArrayList("Arial"));
this.fontName = new SimpleStringProperty(defaultFontFamily);
this.fontSize = new SimpleIntegerProperty(defaultFontSize);

3
gui/fx/src/main/java/com/github/gtache/autosubtitle/gui/work/fx/FXWorkBinder.java
View File

@@ -7,6 +7,9 @@ import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.Objects;
/**
* {@link FXBinder} for {@link FXWorkModel}
*/
@Singleton
public class FXWorkBinder implements FXBinder {

2
gui/fx/src/main/java/com/github/gtache/autosubtitle/subtitle/gui/fx/ObservableSubtitleCollectionImpl.java
View File

@@ -19,7 +19,7 @@ public record ObservableSubtitleCollectionImpl(StringProperty textProperty,
ObjectProperty<Language> languageProperty) implements SubtitleCollection<ObservableSubtitleImpl> {
public ObservableSubtitleCollectionImpl() {
this(new SimpleStringProperty(""), FXCollections.observableArrayList(), new SimpleObjectProperty<>());
this(new SimpleStringProperty(""), FXCollections.observableArrayList(), new SimpleObjectProperty<>(Language.AUTO));
}
public ObservableSubtitleCollectionImpl(final SubtitleCollection<?> subtitleCollection) {

9
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/fx/TestColonTimeFormatter.java
View File

@@ -40,4 +40,13 @@ class TestColonTimeFormatter {
void testFormat(final long millis, final String time) {
assertEquals(time, timeFormatter.format(millis));
}
@ParameterizedTest
@CsvSource({
"754000,45296000,12:34.000/12:34:56.000",
"3723000,45296521,1:02:03.000/12:34:56.521",
})
void testFormat(final long elapsed, final long total, final String time) {
assertEquals(time, timeFormatter.format(elapsed, total));
}
}

26
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/media/fx/TestFXMediaBinder.java
View File

@@ -3,6 +3,7 @@ package com.github.gtache.autosubtitle.gui.media.fx;
import com.github.gtache.autosubtitle.Video;
import com.github.gtache.autosubtitle.gui.work.fx.FXWorkModel;
import com.github.gtache.autosubtitle.subtitle.gui.fx.ObservableSubtitleImpl;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.List;
@@ -14,13 +15,23 @@ import static org.mockito.Mockito.spy;
class TestFXMediaBinder {
@Test
void testCreateBindings() {
final var workModel = spy(FXWorkModel.class);
final var mediaModel = new FXMediaModel();
final var binder = new FXMediaBinder(workModel, mediaModel);
binder.createBindings();
private final FXWorkModel workModel;
private final FXMediaModel mediaModel;
private final FXMediaBinder binder;
TestFXMediaBinder() {
this.workModel = spy(FXWorkModel.class);
this.mediaModel = new FXMediaModel();
this.binder = new FXMediaBinder(workModel, mediaModel);
}
@BeforeEach
void beforeEach() {
binder.createBindings();
}
@Test
void testVideoBinding() {
assertNull(mediaModel.video());
assertNull(workModel.video());
@@ -31,7 +42,10 @@ class TestFXMediaBinder {
final var video2 = mock(Video.class);
workModel.setVideo(video2);
assertEquals(video2, mediaModel.video());
}
@Test
void testSubtitlesBinding() {
final var subtitles = List.of(mock(ObservableSubtitleImpl.class));
assertEquals(List.of(), workModel.subtitles());

3
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/media/fx/TestFXMediaController.java
View File

@@ -20,6 +20,7 @@ import javafx.scene.layout.StackPane;
import javafx.scene.media.MediaPlayer;
import javafx.scene.media.MediaView;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -157,6 +158,7 @@ class TestFXMediaController extends FxRobot {
}
@Test
@Disabled("to fix")
void testPositionPlayer() {
loadVideo();
final var player = lookup("#videoView").queryAs(MediaView.class).getMediaPlayer();
@@ -181,6 +183,7 @@ class TestFXMediaController extends FxRobot {
}
@Test
@Disabled("to fix")
void testPlayPressed() {
final var button = lookup("#playButton").queryAs(Button.class);
loadVideo();

29
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/media/fx/TestFXMediaModel.java
View File

@@ -2,8 +2,11 @@ package com.github.gtache.autosubtitle.gui.media.fx;
import com.github.gtache.autosubtitle.Video;
import com.github.gtache.autosubtitle.VideoInfo;
import com.github.gtache.autosubtitle.subtitle.EditableSubtitle;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -42,16 +45,6 @@ class TestFXMediaModel {
assertTrue(model.isPlayingProperty().get());
}
@Test
void testPosition() {
assertEquals(0L, model.position());
assertEquals(0L, model.positionProperty().get());
final var position = 100L;
model.setPosition(position);
assertEquals(position, model.position());
assertEquals(position, model.positionProperty().get());
}
@Test
void testDuration() {
assertEquals(0L, model.duration());
@@ -68,4 +61,20 @@ class TestFXMediaModel {
assertEquals(0L, model.duration());
assertEquals(0L, model.durationProperty().get());
}
@Test
void testPosition() {
assertEquals(0L, model.position());
assertEquals(0L, model.positionProperty().get());
final var position = 100L;
model.setPosition(position);
assertEquals(position, model.position());
assertEquals(position, model.positionProperty().get());
}
@Test
void testSubtitles() {
assertEquals(List.of(), model.subtitles());
assertDoesNotThrow(() -> model.subtitles().add(mock(EditableSubtitle.class)));
}
}

31
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/parameters/fx/TestFXParametersModel.java
View File

@@ -3,6 +3,7 @@ package com.github.gtache.autosubtitle.gui.parameters.fx;
import com.github.gtache.autosubtitle.subtitle.OutputFormat;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractionModel;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractionModelProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -26,17 +27,21 @@ class TestFXParametersModel {
private final List<ExtractionModel> availableExtractionModels;
private final ExtractionModel defaultExtractionModel;
private final ExtractionModelProvider provider;
private final FXParametersModel model;
private FXParametersModel model;
TestFXParametersModel(@Mock final ExtractionModelProvider extractionModelProvider,
@Mock final ExtractionModel defaultExtractionModel,
@Mock final ExtractionModel extractionModel) {
this.provider = Objects.requireNonNull(extractionModelProvider);
this.defaultExtractionModel = Objects.requireNonNull(defaultExtractionModel);
when(provider.getDefaultExtractionModel()).thenReturn(defaultExtractionModel);
this.availableExtractionModels = List.of(defaultExtractionModel, extractionModel);
}
@BeforeEach
void beforeEach() {
when(provider.getDefaultExtractionModel()).thenReturn(defaultExtractionModel);
when(provider.getAvailableExtractionModels()).thenReturn(availableExtractionModels);
model = new FXParametersModel(extractionModelProvider, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_MAX_LINE_LENGTH, DEFAULT_MAX_LINES);
this.model = new FXParametersModel(provider, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_MAX_LINE_LENGTH, DEFAULT_MAX_LINES);
}
@Test
@@ -95,4 +100,24 @@ class TestFXParametersModel {
assertEquals(fontSize, model.fontSize());
assertEquals(fontSize, model.fontSizeProperty().get());
}
@Test
void testMaxLineLength() {
assertEquals(DEFAULT_MAX_LINE_LENGTH, model.maxLineLength());
assertEquals(DEFAULT_MAX_LINE_LENGTH, model.maxLineLengthProperty().get());
final var newLength = 2;
model.setMaxLineLength(newLength);
assertEquals(newLength, model.maxLineLength());
assertEquals(newLength, model.maxLineLengthProperty().get());
}
@Test
void testMaxLines() {
assertEquals(DEFAULT_MAX_LINES, model.maxLines());
assertEquals(DEFAULT_MAX_LINES, model.maxLinesProperty().get());
final var newLines = 3;
model.setMaxLines(newLines);
assertEquals(newLines, model.maxLines());
assertEquals(newLines, model.maxLinesProperty().get());
}
}

6
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/setup/fx/TestFXSetupModel.java
View File

@@ -8,7 +8,11 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
class TestFXSetupModel {
private final FXSetupModel model = new FXSetupModel();
private final FXSetupModel model;
TestFXSetupModel() {
this.model = new FXSetupModel();
}
@Test
void testSubtitleExtractorStatus() {

148
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/subtitles/fx/TestFXSubtitlesBinder.java Normal file
View File

@@ -0,0 +1,148 @@
package com.github.gtache.autosubtitle.gui.subtitles.fx;
import com.github.gtache.autosubtitle.Language;
import com.github.gtache.autosubtitle.Video;
import com.github.gtache.autosubtitle.VideoInfo;
import com.github.gtache.autosubtitle.gui.work.WorkStatus;
import com.github.gtache.autosubtitle.gui.work.fx.FXWorkModel;
import com.github.gtache.autosubtitle.subtitle.gui.fx.ObservableSubtitleCollectionImpl;
import com.github.gtache.autosubtitle.subtitle.gui.fx.ObservableSubtitleImpl;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.collections.FXCollections;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
class TestFXSubtitlesBinder {
private final FXWorkModel workModel;
private final FXSubtitlesModel subtitlesModel;
private final FXSubtitlesBinder binder;
TestFXSubtitlesBinder() {
this.workModel = spy(FXWorkModel.class);
this.subtitlesModel = new FXSubtitlesModel();
this.binder = new FXSubtitlesBinder(workModel, subtitlesModel);
}
@BeforeEach
void beforeEach() {
binder.createBindings();
}
@Test
void testCanLoadSubtitlesBinding() {
assertFalse(subtitlesModel.canLoadSubtitles());
workModel.setVideo(mock(Video.class));
assertTrue(subtitlesModel.canLoadSubtitles());
workModel.setStatus(WorkStatus.EXPORTING);
assertFalse(subtitlesModel.canLoadSubtitles());
}
@Test
void testCanResetSubtitlesBinding() {
assertFalse(subtitlesModel.canResetSubtitles());
workModel.setVideo(mock(Video.class));
assertTrue(subtitlesModel.canResetSubtitles());
workModel.setStatus(WorkStatus.EXPORTING);
assertFalse(subtitlesModel.canResetSubtitles());
}
@Test
void testCanAddSubtitlesBinding() {
assertFalse(subtitlesModel.canAddSubtitle());
workModel.setVideo(mock(Video.class));
assertFalse(subtitlesModel.canAddSubtitle());
subtitlesModel.setVideoLanguage(Language.EN);
assertTrue(subtitlesModel.canAddSubtitle());
workModel.setStatus(WorkStatus.EXPORTING);
assertFalse(subtitlesModel.canAddSubtitle());
}
@Test
void testCanEditTableBinding() {
assertFalse(subtitlesModel.canEditTable());
workModel.setVideo(mock(Video.class));
assertFalse(subtitlesModel.canEditTable());
subtitlesModel.setVideoLanguage(Language.EN);
assertTrue(subtitlesModel.canEditTable());
workModel.setStatus(WorkStatus.EXPORTING);
assertFalse(subtitlesModel.canEditTable());
}
@Test
void testSelectedSubtitleBinding() {
assertNull(workModel.selectedSubtitleProperty().get());
final var subtitle = mock(ObservableSubtitleImpl.class);
subtitlesModel.setSelectedSubtitle(subtitle);
assertEquals(subtitle, workModel.selectedSubtitleProperty().get());
}
@Test
void testCanExportBinding() {
assertFalse(workModel.canExport());
subtitlesModel.collections().put(Language.EN, mock(ObservableSubtitleCollectionImpl.class));
assertTrue(workModel.canExport());
workModel.setStatus(WorkStatus.EXPORTING);
assertFalse(workModel.canExport());
}
@Test
void testVideoLanguageBinding() {
assertEquals(Language.AUTO, workModel.videoLanguageProperty().get());
subtitlesModel.setVideoLanguage(Language.EN);
assertEquals(Language.EN, workModel.videoLanguageProperty().get());
}
@Test
void testVideoInfoBinding() {
assertNull(subtitlesModel.videoInfo());
final var video = mock(Video.class);
final var info = mock(VideoInfo.class);
when(video.info()).thenReturn(info);
workModel.setVideo(video);
assertEquals(info, subtitlesModel.videoInfo());
}
@Test
void testTranslatingBinding() {
assertEquals(WorkStatus.IDLE, workModel.status());
subtitlesModel.setTranslating(true);
assertEquals(WorkStatus.TRANSLATING, workModel.status());
subtitlesModel.setTranslating(false);
assertEquals(WorkStatus.IDLE, workModel.status());
}
@Test
void testExtractedCollectionBinding() {
assertEquals(Map.of(), subtitlesModel.collections());
final var collection = new ObservableSubtitleCollectionImpl(new SimpleStringProperty(""), FXCollections.observableArrayList(), new SimpleObjectProperty<>(Language.FR));
workModel.setExtractedCollection(collection);
//Equals doesnt work on properties
assertEquals(1, subtitlesModel.collections().size());
assertTrue(subtitlesModel.collections().containsKey(Language.FR));
assertNotNull(subtitlesModel.collections().get(Language.FR));
}
@Test
void testCollectionsBinding() {
assertEquals(Map.of(), subtitlesModel.collections());
final var collection = mock(ObservableSubtitleCollectionImpl.class);
subtitlesModel.collections().put(Language.FR, collection);
assertEquals(Map.of(Language.FR, collection), workModel.collections());
}
@Test
void testSubtitlesBinding() {
assertEquals(List.of(), workModel.subtitles());
final var subtitle = mock(ObservableSubtitleImpl.class);
subtitlesModel.selectedSubtitles().add(subtitle);
assertEquals(List.of(subtitle), workModel.subtitles());
}
}

172
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/subtitles/fx/TestFXSubtitlesModel.java
View File

@@ -1,26 +1,27 @@
package com.github.gtache.autosubtitle.gui.subtitles.fx;
import com.github.gtache.autosubtitle.Language;
import com.github.gtache.autosubtitle.VideoInfo;
import com.github.gtache.autosubtitle.subtitle.gui.fx.ObservableSubtitleCollectionImpl;
import com.github.gtache.autosubtitle.subtitle.gui.fx.ObservableSubtitleImpl;
import javafx.collections.FXCollections;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
class TestFXSubtitlesModel {
private final FXSubtitlesModel model = new FXSubtitlesModel();
private final FXSubtitlesModel model;
@Test
void testSelectedSubtitle() {
assertNull(model.selectedSubtitle());
assertNull(model.selectedSubtitleProperty().get());
final var subtitle = mock(ObservableSubtitleImpl.class);
model.setSelectedSubtitle(subtitle);
assertEquals(subtitle, model.selectedSubtitle());
assertEquals(subtitle, model.selectedSubtitleProperty().get());
TestFXSubtitlesModel() {
this.model = new FXSubtitlesModel();
}
@Test
@@ -44,9 +45,156 @@ class TestFXSubtitlesModel {
.filter(l -> l != Language.AUTO).toList();
assertEquals(expected, model.availableTranslationsLanguage());
assertThrows(UnsupportedOperationException.class, () -> model.availableTranslationsLanguage().setAll(Language.DE));
}
@Test
void testVideoLanguage() {
assertEquals(Language.AUTO, model.videoLanguage());
assertEquals(Language.AUTO, model.videoLanguageProperty().get());
model.setVideoLanguage(Language.DE);
final var expected2 = Arrays.stream(Language.values())
.filter(l -> l != Language.AUTO && l != Language.DE).toList();
assertEquals(expected2, model.availableTranslationsLanguage());
assertEquals(Language.DE, model.videoLanguage());
assertEquals(Language.DE, model.videoLanguageProperty().get());
}
@Test
void testVideoInfo() {
assertNull(model.videoInfo());
assertNull(model.videoInfoProperty().get());
final var videoInfo = mock(VideoInfo.class);
model.setVideoInfo(videoInfo);
assertEquals(videoInfo, model.videoInfo());
assertEquals(videoInfo, model.videoInfoProperty().get());
}
@Test
void testSelectedTranslationsLanguages() {
assertEquals(List.of(), model.selectedTranslationsLanguages());
assertDoesNotThrow(() -> model.selectedTranslationsLanguages().add(Language.DE));
}
@Test
void testSelectedLanguage() {
assertEquals(Language.AUTO, model.selectedLanguage());
assertEquals(Language.AUTO, model.selectedLanguageProperty().get());
model.setSelectedLanguage(Language.DE);
assertEquals(Language.DE, model.selectedLanguage());
assertEquals(Language.DE, model.selectedLanguageProperty().get());
}
@Test
void testCollections() {
assertEquals(Map.of(), model.collections());
assertDoesNotThrow(() -> model.collections().put(Language.FR, mock(ObservableSubtitleCollectionImpl.class)));
assertEquals(Arrays.stream(Language.values()).filter(l -> l != Language.AUTO && l != Language.FR)
.sorted(Comparator.comparing(Language::englishName)).toList(), model.availableTranslationsLanguage());
}
@Test
void testOriginalCollections() {
assertEquals(Map.of(), model.originalCollections());
assertDoesNotThrow(() -> model.originalCollections().put(Language.FR, mock(ObservableSubtitleCollectionImpl.class)));
}
@Test
void testSelectedCollection() {
assertNull(model.selectedCollection());
assertNull(model.selectedCollectionProperty().get());
model.setSelectedSubtitle(mock(ObservableSubtitleImpl.class));
model.selectedSubtitles().addAll(mock(ObservableSubtitleImpl.class), mock(ObservableSubtitleImpl.class));
final var collection = mock(ObservableSubtitleCollectionImpl.class);
final var sub1 = mock(ObservableSubtitleImpl.class);
final var sub2 = mock(ObservableSubtitleImpl.class);
when(collection.subtitles()).thenReturn(FXCollections.observableArrayList(sub1, sub2));
when(collection.language()).thenReturn(Language.EN);
model.setSelectedCollection(collection);
assertNull(model.selectedSubtitle());
assertEquals(List.of(sub1, sub2), model.selectedSubtitles());
assertEquals(Language.EN, model.selectedLanguage());
assertEquals(collection, model.selectedCollection());
assertEquals(collection, model.selectedCollectionProperty().get());
model.setSelectedSubtitle(mock(ObservableSubtitleImpl.class));
model.setSelectedCollection(null);
assertNull(model.selectedSubtitle());
assertEquals(List.of(), model.selectedSubtitles());
assertEquals(Language.AUTO, model.selectedLanguage());
assertNull(model.selectedCollection());
assertNull(model.selectedCollectionProperty().get());
}
@Test
void testSelectedSubtitles() {
assertEquals(List.of(), model.selectedSubtitles());
final var sub1 = mock(ObservableSubtitleImpl.class);
final var sub2 = mock(ObservableSubtitleImpl.class);
model.selectedSubtitles().addAll(sub1, sub2);
assertEquals(List.of(sub1, sub2), model.selectedSubtitles());
}
@Test
void testSelectedSubtitle() {
assertNull(model.selectedSubtitle());
assertNull(model.selectedSubtitleProperty().get());
final var subtitle = mock(ObservableSubtitleImpl.class);
model.setSelectedSubtitle(subtitle);
assertEquals(subtitle, model.selectedSubtitle());
assertEquals(subtitle, model.selectedSubtitleProperty().get());
}
@Test
void testCanLoadSubtitles() {
assertFalse(model.canLoadSubtitles());
assertFalse(model.canLoadSubtitlesProperty().get());
model.setCanLoadSubtitles(true);
assertTrue(model.canLoadSubtitles());
assertTrue(model.canLoadSubtitlesProperty().get());
}
@Test
void testCanAddSubtitles() {
assertFalse(model.canAddSubtitle());
assertFalse(model.canAddSubtitleProperty().get());
model.setCanAddSubtitle(true);
assertTrue(model.canAddSubtitle());
assertTrue(model.canAddSubtitleProperty().get());
}
@Test
void testCanResetSubtitles() {
assertFalse(model.canResetSubtitles());
assertFalse(model.canResetSubtitlesProperty().get());
model.setCanResetSubtitles(true);
assertTrue(model.canResetSubtitles());
assertTrue(model.canResetSubtitlesProperty().get());
}
@Test
void testCanSaveSubtitles() {
assertFalse(model.canSaveSubtitles());
assertFalse(model.canSaveSubtitlesProperty().get());
model.collections().put(Language.FR, mock(ObservableSubtitleCollectionImpl.class));
assertTrue(model.canSaveSubtitles());
assertTrue(model.canSaveSubtitlesProperty().get());
}
@Test
void testCanEditTable() {
assertFalse(model.canEditTable());
assertFalse(model.canEditTableProperty().get());
model.setCanEditTable(true);
assertTrue(model.canEditTable());
assertTrue(model.canEditTableProperty().get());
}
@Test
void testIsTranslating() {
assertFalse(model.isTranslating());
assertFalse(model.translatingProperty().get());
model.setTranslating(true);
assertTrue(model.isTranslating());
assertTrue(model.translatingProperty().get());
}
}

7
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/subtitles/fx/TestTimeStringConverter.java
View File

@@ -1,6 +1,7 @@
package com.github.gtache.autosubtitle.gui.subtitles.fx;
import com.github.gtache.autosubtitle.gui.TimeFormatter;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -20,9 +21,13 @@ class TestTimeStringConverter {
TestTimeStringConverter(@Mock final TimeFormatter timeFormatter) {
this.timeFormatter = Objects.requireNonNull(timeFormatter);
this.converter = new TimeStringConverter(timeFormatter);
}
@BeforeEach
void beforeEach() {
when(timeFormatter.format(LONG)).thenReturn(STRING);
when(timeFormatter.parse(STRING)).thenReturn(LONG);
this.converter = new TimeStringConverter(timeFormatter);
}
@Test

21
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/work/fx/TestFXWorkBinder.java
View File

@@ -3,6 +3,7 @@ package com.github.gtache.autosubtitle.gui.work.fx;
import com.github.gtache.autosubtitle.gui.parameters.fx.FXParametersModel;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractionModel;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractionModelProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
@@ -10,19 +11,29 @@ import static org.mockito.Mockito.*;
class TestFXWorkBinder {
private final FXWorkModel workModel;
private final FXParametersModel parametersModel;
private final FXWorkBinder binder;
TestFXWorkBinder() {
this.workModel = new FXWorkModel();
this.parametersModel = mock(FXParametersModel.class, withSettings().defaultAnswer(CALLS_REAL_METHODS).useConstructor(mock(ExtractionModelProvider.class), "Arial", 12, 40, 1));
this.binder = new FXWorkBinder(workModel, parametersModel);
}
@BeforeEach
void beforeEach() {
binder.createBindings();
}
@Test
void testBindings() {
final var workModel = new FXWorkModel();
final var parametersModel = mock(FXParametersModel.class, withSettings().defaultAnswer(CALLS_REAL_METHODS).useConstructor(mock(ExtractionModelProvider.class), "Arial", 12, 40, 1));
final var binder = new FXWorkBinder(workModel, parametersModel);
binder.createBindings();
assertNull(workModel.extractionModel());
assertNull(parametersModel.extractionModel());
final var extractionModel = mock(ExtractionModel.class);
parametersModel.setExtractionModel(extractionModel);
assertEquals(extractionModel, workModel.extractionModel());
assertEquals(extractionModel, parametersModel.extractionModel());
assertThrows(RuntimeException.class, () -> workModel.setExtractionModel(mock(ExtractionModel.class)));
}

97
gui/fx/src/test/java/com/github/gtache/autosubtitle/gui/work/fx/TestFXWorkModel.java
View File

@@ -1,17 +1,28 @@
package com.github.gtache.autosubtitle.gui.work.fx;
import com.github.gtache.autosubtitle.Language;
import com.github.gtache.autosubtitle.Video;
import com.github.gtache.autosubtitle.gui.work.WorkStatus;
import com.github.gtache.autosubtitle.subtitle.EditableSubtitle;
import com.github.gtache.autosubtitle.subtitle.SubtitleCollection;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractionModel;
import com.github.gtache.autosubtitle.subtitle.gui.fx.ObservableSubtitleCollectionImpl;
import com.github.gtache.autosubtitle.subtitle.gui.fx.ObservableSubtitleImpl;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;
class TestFXWorkModel {
private final FXWorkModel model = new FXWorkModel();
private final FXWorkModel model;
TestFXWorkModel() {
this.model = new FXWorkModel();
}
@Test
void testVideo() {
@@ -23,6 +34,15 @@ class TestFXWorkModel {
assertEquals(video, model.videoProperty().get());
}
@Test
void testWorkStatus() {
assertEquals(WorkStatus.IDLE, model.status());
assertEquals(WorkStatus.IDLE, model.statusProperty().get());
model.setStatus(WorkStatus.TRANSLATING);
assertEquals(WorkStatus.TRANSLATING, model.status());
assertEquals(WorkStatus.TRANSLATING, model.statusProperty().get());
}
@Test
void testExtractionModel() {
assertNull(model.extractionModel());
@@ -33,15 +53,6 @@ class TestFXWorkModel {
assertEquals(extractionModel, model.extractionModelProperty().get());
}
@Test
void testWorkStatus() {
assertEquals(WorkStatus.IDLE, model.status());
assertEquals(WorkStatus.IDLE, model.statusProperty().get());
model.setStatus(WorkStatus.TRANSLATING);
assertEquals(WorkStatus.TRANSLATING, model.status());
assertEquals(WorkStatus.TRANSLATING, model.statusProperty().get());
}
@Test
void testProgress() {
assertEquals(-1.0, model.progress());
@@ -50,4 +61,66 @@ class TestFXWorkModel {
assertEquals(0.5, model.progress());
assertEquals(0.5, model.progressProperty().get());
}
@Test
void testSelectedSubtitle() {
assertNull(model.selectedSubtitleProperty().get());
assertDoesNotThrow(() -> model.selectedSubtitleProperty().set(mock(EditableSubtitle.class)));
}
@Test
void testSubtitles() {
assertEquals(List.of(), model.subtitles());
assertDoesNotThrow(() -> model.subtitles().add(mock(ObservableSubtitleImpl.class)));
}
@Test
void testCollections() {
assertEquals(Map.of(), model.collections());
assertDoesNotThrow(() -> model.collections().put(Language.FR, mock(ObservableSubtitleCollectionImpl.class)));
}
@Test
void testVideoLanguage() {
assertEquals(Language.AUTO, model.videoLanguageProperty().get());
assertDoesNotThrow(() -> model.videoLanguageProperty().set(Language.FR));
}
@Test
void testCanExtract() {
assertFalse(model.canExtract());
assertFalse(model.canExtractProperty().get());
model.setVideo(mock(Video.class));
assertTrue(model.canExtract());
assertTrue(model.canExtractProperty().get());
model.setStatus(WorkStatus.EXTRACTING);
assertFalse(model.canExtract());
}
@Test
void testCanExport() {
assertFalse(model.canExport());
assertFalse(model.canExportProperty().get());
model.setCanExport(true);
assertTrue(model.canExport());
assertTrue(model.canExportProperty().get());
}
@Test
void testIsProgressVisible() {
assertFalse(model.isProgressVisible());
assertFalse(model.isProgressVisibleProperty().get());
model.setStatus(WorkStatus.EXTRACTING);
assertTrue(model.isProgressVisible());
assertTrue(model.isProgressVisibleProperty().get());
}
@Test
void testExtractedCollection() {
assertNull(model.extractedCollection());
assertNull(model.extractedCollectionProperty().get());
model.setExtractedCollection(mock(SubtitleCollection.class));
assertNotNull(model.extractedCollection());
assertNotNull(model.extractedCollectionProperty().get());
}
}

48
gui/fx/src/test/java/com/github/gtache/autosubtitle/setup/gui/fx/TestFXSetupUserBridge.java Normal file
View File

@@ -0,0 +1,48 @@
package com.github.gtache.autosubtitle.setup.gui.fx;
import com.github.gtache.autosubtitle.gui.main.fx.FXMainController;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.testfx.api.FxRobot;
import org.testfx.api.FxToolkit;
import org.testfx.util.WaitForAsyncUtils;
import java.util.Objects;
@ExtendWith(MockitoExtension.class)
class TestFXSetupUserBridge extends FxRobot {
private final FXMainController mainController;
private final FXSetupUserBridge bridge;
TestFXSetupUserBridge(@Mock final FXMainController mainController) {
this.mainController = Objects.requireNonNull(mainController);
this.bridge = new FXSetupUserBridge(mainController);
}
@AfterEach
void afterEach() throws Throwable {
WaitForAsyncUtils.waitForFxEvents();
WaitForAsyncUtils.checkException();
FxToolkit.cleanupStages();
}
@Test
@Disabled("TODO")
void testAskForUserConfirmation() {
}
@Test
@Disabled("TODO")
void testAskForUserChoice() {
}
@Test
@Disabled("TODO")
void testAskForUserInput() {
}
}

81
gui/fx/src/test/java/com/github/gtache/autosubtitle/subtitle/gui/fx/TestObservableSubtitleCollectionImpl.java Normal file
View File

@@ -0,0 +1,81 @@
package com.github.gtache.autosubtitle.subtitle.gui.fx;
import com.github.gtache.autosubtitle.Language;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
class TestObservableSubtitleCollectionImpl {
private final StringProperty text;
private final ObservableList<ObservableSubtitleImpl> observableSubtitles;
private final ObjectProperty<Language> language;
private final ObservableSubtitleCollectionImpl collection;
TestObservableSubtitleCollectionImpl() {
this.text = new SimpleStringProperty("text");
this.observableSubtitles = FXCollections.observableArrayList(new ObservableSubtitleImpl("content"));
this.language = new SimpleObjectProperty<>(Language.FR);
this.collection = new ObservableSubtitleCollectionImpl(text, observableSubtitles, language);
}
@Test
void testEmptyConstructor() {
final var collection = new ObservableSubtitleCollectionImpl();
assertEquals("", collection.text());
assertEquals(List.of(), collection.subtitles());
assertEquals(Language.AUTO, collection.language());
}
@Test
void testCopyConstructor() {
final var newCollection = new ObservableSubtitleCollectionImpl(this.collection);
assertEquals(text.get(), newCollection.text());
final var subtitle1 = observableSubtitles.getFirst();
final var subtitle2 = newCollection.observableSubtitles().getFirst();
assertEquals(subtitle1.content(), subtitle2.content());
assertEquals(subtitle1.start(), subtitle2.start());
assertEquals(subtitle1.end(), subtitle2.end());
assertEquals(language.get(), newCollection.language());
}
@Test
void testGetters() {
assertEquals(text, collection.textProperty());
assertEquals(text.get(), collection.text());
assertEquals(observableSubtitles, collection.subtitles());
assertEquals(observableSubtitles, collection.observableSubtitles());
assertEquals(language, collection.languageProperty());
assertEquals(language.get(), collection.language());
}
@Test
void testLanguage() {
assertEquals(Language.FR, collection.language());
collection.setLanguage(Language.EN);
assertEquals(Language.EN, collection.language());
}
@Test
void testText() {
assertEquals("text", collection.text());
collection.setText("newText");
assertEquals("newText", collection.text());
}
@Test
void testIllegal() {
assertThrows(NullPointerException.class, () -> new ObservableSubtitleCollectionImpl(null, observableSubtitles, language));
assertThrows(NullPointerException.class, () -> new ObservableSubtitleCollectionImpl(text, null, language));
assertThrows(NullPointerException.class, () -> new ObservableSubtitleCollectionImpl(text, observableSubtitles, null));
}
}

6
whisper/base/src/test/java/com/github/gtache/autosubtitle/whisper/base/TestWhisperExtractionModelProvider.java
View File

@@ -10,7 +10,11 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
class TestWhisperExtractionModelProvider {
private final ExtractionModelProvider provider = new WhisperExtractionModelProvider();
private final ExtractionModelProvider provider;
TestWhisperExtractionModelProvider() {
this.provider = new WhisperExtractionModelProvider();
}
@Test
void testGetAvailableExtractionModels() {

11
whisper/common/src/test/java/com/github/gtache/autosubtitle/setup/whisper/TestAbstractWhisperSetupManager.java
View File

@@ -4,6 +4,7 @@ import com.github.gtache.autosubtitle.impl.OS;
import com.github.gtache.autosubtitle.process.ProcessRunner;
import com.github.gtache.autosubtitle.setup.SetupException;
import com.github.gtache.autosubtitle.setup.conda.CondaSetupManager;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.io.TempDir;
@@ -34,13 +35,17 @@ class TestAbstractWhisperSetupManager {
TestAbstractWhisperSetupManager(@Mock final CondaSetupManager condaSetupManager, @Mock final WhisperSetupConfiguration configuration,
@Mock final ProcessRunner processRunner, @Mock final HttpClient httpClient) {
this.condaSetupManager = Objects.requireNonNull(condaSetupManager);
when(condaSetupManager.name()).thenReturn("conda");
this.configuration = Objects.requireNonNull(configuration);
this.processRunner = Objects.requireNonNull(processRunner);
this.httpClient = Objects.requireNonNull(httpClient);
this.setupManager = spy(new DummyWhisperSetupManager(condaSetupManager, configuration, processRunner, httpClient));
}
@BeforeEach
void beforeEach() {
when(condaSetupManager.name()).thenReturn("conda");
}
@Test
void testGetStatus() throws SetupException {
assertEquals(NOT_INSTALLED, setupManager.getStatus());
@@ -155,11 +160,11 @@ class TestAbstractWhisperSetupManager {
}
@Override
protected void installWhisper() throws SetupException {
protected void installWhisper() {
}
@Override
protected boolean isWhisperInstalled() throws SetupException {
protected boolean isWhisperInstalled() {
return false;
}

3
whisper/common/src/test/java/com/github/gtache/autosubtitle/setup/whisper/TestWhisperSetupConfiguration.java
View File

@@ -19,17 +19,18 @@ class TestWhisperSetupConfiguration {
private final Path venvPath;
private final String pythonVersion;
private final OS os;
private final WhisperSetupConfiguration configuration;
TestWhisperSetupConfiguration(@Mock final Path root, @Mock final Path venvPath) {
this.root = Objects.requireNonNull(root);
this.venvPath = Objects.requireNonNull(venvPath);
this.pythonVersion = "3.10";
this.os = OS.LINUX;
this.configuration = new WhisperSetupConfiguration(root, venvPath, pythonVersion, os);
}
@Test
void testGetters() {
final var configuration = new WhisperSetupConfiguration(root, venvPath, pythonVersion, os);
assertEquals(root, configuration.root());
assertEquals(venvPath, configuration.venvPath());
assertEquals(pythonVersion, configuration.pythonVersion());

22
whisper/common/src/test/java/com/github/gtache/autosubtitle/subtitle/extractor/whisper/TestAbstractWhisperSubtitleExtractor.java
View File

@@ -20,6 +20,7 @@ import com.github.gtache.autosubtitle.subtitle.extractor.ExtractException;
import com.github.gtache.autosubtitle.subtitle.extractor.ExtractionModel;
import com.github.gtache.autosubtitle.subtitle.extractor.SubtitleExtractorListener;
import com.github.gtache.autosubtitle.subtitle.extractor.impl.ExtractEventImpl;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -47,7 +48,7 @@ class TestAbstractWhisperSubtitleExtractor {
private final ProcessListener processListener;
private final ProcessResult processResult;
private final OS os;
private final DummyWhisperSubtitleExtractor extractor;
private DummyWhisperSubtitleExtractor extractor;
private final AudioInfo audioInfo;
private final VideoInfo videoInfo;
@@ -59,27 +60,30 @@ class TestAbstractWhisperSubtitleExtractor {
@Mock final ProcessRunner processRunner, @Mock final ProcessListener processListener,
@Mock final ProcessResult processResult, @Mock final VideoInfo videoInfo,
@Mock final AudioInfo audioInfo, @Mock final ExtractionModel extractionModel,
@Mock final SubtitleCollection<Subtitle> collection) throws IOException {
@Mock final SubtitleCollection<Subtitle> collection) {
this.venvPath = Path.of("venv");
this.os = OS.LINUX;
this.converterProvider = Objects.requireNonNull(converterProvider);
this.converter = Objects.requireNonNull(converter);
doReturn(converter).when(converterProvider).getConverter("json");
this.processRunner = Objects.requireNonNull(processRunner);
this.processListener = Objects.requireNonNull(processListener);
this.processResult = Objects.requireNonNull(processResult);
when(processRunner.startListen(anyList())).thenReturn(processListener);
when(processListener.join(Duration.ofHours(1))).thenReturn(processResult);
this.extractor = new DummyWhisperSubtitleExtractor(venvPath, converterProvider, processRunner, os);
this.audioInfo = Objects.requireNonNull(audioInfo);
when(audioInfo.format()).thenReturn("mp3");
this.videoInfo = Objects.requireNonNull(videoInfo);
when(videoInfo.format()).thenReturn("mp4");
this.extractionModel = Objects.requireNonNull(extractionModel);
this.collection = Objects.requireNonNull(collection);
}
@BeforeEach
void beforeEach() throws IOException {
doReturn(converter).when(converterProvider).getConverter("json");
when(processRunner.startListen(anyList())).thenReturn(processListener);
when(processListener.join(Duration.ofHours(1))).thenReturn(processResult);
when(audioInfo.format()).thenReturn("mp3");
when(videoInfo.format()).thenReturn("mp4");
this.extractor = new DummyWhisperSubtitleExtractor(venvPath, converterProvider, processRunner, os);
}
@Test
void testNotifyListeners() {
final var listener1 = mock(SubtitleExtractorListener.class);

2
whisper/whisperx/src/test/java/com/github/gtache/autosubtitle/modules/setup/whisperx/TestWhisperXSetupModule.java
View File

@@ -14,7 +14,7 @@ class TestWhisperXSetupModule {
}
@Test
void testWHisperXBundledRoot() {
void testWhisperXBundledRoot() {
final var root = Paths.get("root");
assertEquals(root.resolve("whisperx"), WhisperXSetupModule.providesWhisperXBundledRoot(root));
}

11
whisper/whisperx/src/test/java/com/github/gtache/autosubtitle/subtitle/extractor/whisperx/TestWhisperXSubtitleExtractor.java
View File

@@ -7,6 +7,7 @@ import com.github.gtache.autosubtitle.subtitle.Subtitle;
import com.github.gtache.autosubtitle.subtitle.converter.SubtitleConverter;
import com.github.gtache.autosubtitle.subtitle.converter.SubtitleConverterProvider;
import com.github.gtache.autosubtitle.whisper.WhisperModels;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
@@ -26,17 +27,23 @@ class TestWhisperXSubtitleExtractor {
private final Path venvPath;
private final SubtitleConverterProvider converterProvider;
private final SubtitleConverter<Subtitle> converter;
private final ProcessRunner processRunner;
private final OS os;
private final WhisperXSubtitleExtractor whisperXSubtitleExtractor;
private WhisperXSubtitleExtractor whisperXSubtitleExtractor;
TestWhisperXSubtitleExtractor(@Mock final SubtitleConverterProvider converterProvider, @Mock final SubtitleConverter<Subtitle> converter,
@Mock final ProcessRunner processRunner) {
this.converterProvider = Objects.requireNonNull(converterProvider);
doReturn(converter).when(converterProvider).getConverter("json");
this.converter = Objects.requireNonNull(converter);
this.processRunner = Objects.requireNonNull(processRunner);
this.venvPath = Paths.get("path");
this.os = OS.LINUX;
}
@BeforeEach
void beforeEach() {
doReturn(converter).when(converterProvider).getConverter("json");
this.whisperXSubtitleExtractor = new WhisperXSubtitleExtractor(venvPath, converterProvider, processRunner, os);
}

61
whisper/whisperx/src/test/java/com/github/gtache/autosubtitle/subtitle/parser/json/whisperx/TestJSONSubtitleConverter.java
View File

@@ -6,6 +6,7 @@ import com.github.gtache.autosubtitle.subtitle.converter.ParseException;
import com.github.gtache.autosubtitle.subtitle.impl.SubtitleCollectionImpl;
import com.github.gtache.autosubtitle.subtitle.impl.SubtitleImpl;
import com.google.gson.Gson;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
@@ -22,20 +23,22 @@ import static org.mockito.Mockito.when;
class TestJSONSubtitleConverter {
private final Gson gson;
private final Preferences preferences;
private final int defaultMaxLineLength;
private final int defaultMaxLines;
private final JSONSubtitleConverter converter;
private JSONSubtitleConverter converter;
TestJSONSubtitleConverter() {
this.gson = new Gson();
this.preferences = mock(Preferences.class);
this.defaultMaxLineLength = 100;
when(preferences.getInt("maxLineLength", defaultMaxLineLength)).thenReturn(defaultMaxLineLength);
this.defaultMaxLines = 2;
}
@BeforeEach
void beforeEach() {
when(preferences.getInt("maxLineLength", defaultMaxLineLength)).thenReturn(defaultMaxLineLength);
when(preferences.getInt("maxLines", defaultMaxLines)).thenReturn(defaultMaxLines);
this.converter = new JSONSubtitleConverter(gson, preferences, defaultMaxLineLength, defaultMaxLines);
this.converter = new JSONSubtitleConverter(new Gson(), preferences, defaultMaxLineLength, defaultMaxLines);
}
@Test
@@ -45,30 +48,46 @@ class TestJSONSubtitleConverter {
@Test
void testParseFormat() throws IOException, ParseException {
final var in = new String(getClass().getResourceAsStream("whisperx-in.json").readAllBytes(), StandardCharsets.UTF_8);
final var out = new String(getClass().getResourceAsStream("whisperx-out.json").readAllBytes(), StandardCharsets.UTF_8);
final var expected = new SubtitleCollectionImpl<Subtitle>("This is a test. Yes.", List.of(new SubtitleImpl("This is a test.", 9, 410, null, null), new SubtitleImpl("Yes.", 450, 6963, null, null)), Language.FR);
assertEquals(expected, converter.parse(in));
assertEquals(out, converter.format(expected, null));
try (final var inStream = getClass().getResourceAsStream("whisperx-in.json");
final var outStream = getClass().getResourceAsStream("whisperx-out.json")) {
if (inStream == null || outStream == null) {
throw new IOException("File not found");
}
final var in = new String(inStream.readAllBytes(), StandardCharsets.UTF_8);
final var out = new String(outStream.readAllBytes(), StandardCharsets.UTF_8);
final var expected = new SubtitleCollectionImpl<Subtitle>("This is a test. Yes.", List.of(new SubtitleImpl("This is a test.", 9, 410, null, null), new SubtitleImpl("Yes.", 450, 6963, null, null)), Language.FR);
assertEquals(expected, converter.parse(in));
assertEquals(out, converter.format(expected, null));
}
}
@Test
void testParseOverMaxWords() throws IOException, ParseException {
final var in = new String(getClass().getResourceAsStream("whisperx-max-words.json").readAllBytes(), StandardCharsets.UTF_8);
final var expected = new SubtitleCollectionImpl<Subtitle>("aaaaaaaaaa bbbbbbbbbb cccccccccc dddddddddd eeeeeeeeee ffffffffff gggggggggg hhhhhhhhhh iiiiiiiiii\njjjjjjjjjj kkkkkkkkkk llllllllll mmmmmmmmmm nnnnnnnnnn oooooooooo pppppppppp qqqqqqqqqq rrrrrrrrrr ssssssssss tttttttttt uuuuuuuuuu vvvvvvvvvv wwwwwwwwww xxxxxxxxxx yyyyyyyyyy zzzzzzzzzz Yes.",
List.of(new SubtitleImpl("aaaaaaaaaa bbbbbbbbbb cccccccccc dddddddddd eeeeeeeeee ffffffffff gggggggggg hhhhhhhhhh iiiiiiiiii\njjjjjjjjjj kkkkkkkkkk llllllllll mmmmmmmmmm nnnnnnnnnn oooooooooo pppppppppp qqqqqqqqqq rrrrrrrrrr", 0, 18000, null, null),
new SubtitleImpl("ssssssssss tttttttttt uuuuuuuuuu vvvvvvvvvv wwwwwwwwww xxxxxxxxxx yyyyyyyyyy zzzzzzzzzz", 18000, 26000, null, null),
new SubtitleImpl("Yes.", 30000, 31000, null, null)), Language.EN);
assertEquals(expected, converter.parse(in));
try (final var inStream = getClass().getResourceAsStream("whisperx-max-words.json")) {
if (inStream == null) {
throw new IOException("File not found");
}
final var in = new String(inStream.readAllBytes(), StandardCharsets.UTF_8);
final var expected = new SubtitleCollectionImpl<Subtitle>("aaaaaaaaaa bbbbbbbbbb cccccccccc dddddddddd eeeeeeeeee ffffffffff gggggggggg hhhhhhhhhh iiiiiiiiii\njjjjjjjjjj kkkkkkkkkk llllllllll mmmmmmmmmm nnnnnnnnnn oooooooooo pppppppppp qqqqqqqqqq rrrrrrrrrr ssssssssss tttttttttt uuuuuuuuuu vvvvvvvvvv wwwwwwwwww xxxxxxxxxx yyyyyyyyyy zzzzzzzzzz Yes.",
List.of(new SubtitleImpl("aaaaaaaaaa bbbbbbbbbb cccccccccc dddddddddd eeeeeeeeee ffffffffff gggggggggg hhhhhhhhhh iiiiiiiiii\njjjjjjjjjj kkkkkkkkkk llllllllll mmmmmmmmmm nnnnnnnnnn oooooooooo pppppppppp qqqqqqqqqq rrrrrrrrrr", 0, 18000, null, null),
new SubtitleImpl("ssssssssss tttttttttt uuuuuuuuuu vvvvvvvvvv wwwwwwwwww xxxxxxxxxx yyyyyyyyyy zzzzzzzzzz", 18000, 26000, null, null),
new SubtitleImpl("Yes.", 30000, 31000, null, null)), Language.EN);
assertEquals(expected, converter.parse(in));
}
}
@Test
void testParseOverMaxLines() throws IOException, ParseException {
final var in = new String(getClass().getResourceAsStream("whisperx-max-lines.json").readAllBytes(), StandardCharsets.UTF_8);
final var expected = new SubtitleCollectionImpl<Subtitle>("aaaaaaaaaa bbbbbbbbbb cccccccccc dddddddddd eeeeeeeeee ffffffffff gggggggggg hhhhhhhhhh iiiiiiiiii\njjjjjjjjjj kkkkkkkkkk llllllllll Yes.",
List.of(new SubtitleImpl("aaaaaaaaaa bbbbbbbbbb cccccccccc dddddddddd eeeeeeeeee ffffffffff gggggggggg hhhhhhhhhh iiiiiiiiii\njjjjjjjjjj kkkkkkkkkk llllllllll", 0, 18000, null, null),
new SubtitleImpl("Yes.", 30000, 31000, null, null)), Language.EN);
assertEquals(expected, converter.parse(in));
try (final var inStream = getClass().getResourceAsStream("whisperx-max-lines.json")) {
if (inStream == null) {
throw new IOException("File not found");
}
final var in = new String(inStream.readAllBytes(), StandardCharsets.UTF_8);
final var expected = new SubtitleCollectionImpl<Subtitle>("aaaaaaaaaa bbbbbbbbbb cccccccccc dddddddddd eeeeeeeeee ffffffffff gggggggggg hhhhhhhhhh iiiiiiiiii\njjjjjjjjjj kkkkkkkkkk llllllllll Yes.",
List.of(new SubtitleImpl("aaaaaaaaaa bbbbbbbbbb cccccccccc dddddddddd eeeeeeeeee ffffffffff gggggggggg hhhhhhhhhh iiiiiiiiii\njjjjjjjjjj kkkkkkkkkk llllllllll", 0, 18000, null, null),
new SubtitleImpl("Yes.", 30000, 31000, null, null)), Language.EN);
assertEquals(expected, converter.parse(in));
}
}
@ParameterizedTest