646 lines
18 KiB
Go
646 lines
18 KiB
Go
package srt
|
||
|
||
import (
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"testing"
|
||
|
||
"sub-cli/internal/model"
|
||
)
|
||
|
||
func TestParse(t *testing.T) {
|
||
// Create a temporary test file
|
||
content := `1
|
||
00:00:01,000 --> 00:00:04,000
|
||
This is the first line.
|
||
|
||
2
|
||
00:00:05,000 --> 00:00:08,000
|
||
This is the second line.
|
||
|
||
3
|
||
00:00:09,500 --> 00:00:12,800
|
||
This is the third line
|
||
with a line break.
|
||
`
|
||
tempDir := t.TempDir()
|
||
testFile := filepath.Join(tempDir, "test.srt")
|
||
if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
|
||
t.Fatalf("Failed to create test file: %v", err)
|
||
}
|
||
|
||
// Test parsing
|
||
entries, err := Parse(testFile)
|
||
if err != nil {
|
||
t.Fatalf("Parse failed: %v", err)
|
||
}
|
||
|
||
// Verify results
|
||
if len(entries) != 3 {
|
||
t.Errorf("Expected 3 entries, got %d", len(entries))
|
||
}
|
||
|
||
// Check first entry
|
||
if entries[0].Number != 1 {
|
||
t.Errorf("First entry number: expected 1, got %d", entries[0].Number)
|
||
}
|
||
if entries[0].StartTime.Hours != 0 || entries[0].StartTime.Minutes != 0 ||
|
||
entries[0].StartTime.Seconds != 1 || entries[0].StartTime.Milliseconds != 0 {
|
||
t.Errorf("First entry start time: expected 00:00:01,000, got %+v", entries[0].StartTime)
|
||
}
|
||
if entries[0].EndTime.Hours != 0 || entries[0].EndTime.Minutes != 0 ||
|
||
entries[0].EndTime.Seconds != 4 || entries[0].EndTime.Milliseconds != 0 {
|
||
t.Errorf("First entry end time: expected 00:00:04,000, got %+v", entries[0].EndTime)
|
||
}
|
||
if entries[0].Content != "This is the first line." {
|
||
t.Errorf("First entry content: expected 'This is the first line.', got '%s'", entries[0].Content)
|
||
}
|
||
|
||
// Check third entry
|
||
if entries[2].Number != 3 {
|
||
t.Errorf("Third entry number: expected 3, got %d", entries[2].Number)
|
||
}
|
||
expectedContent := "This is the third line\nwith a line break."
|
||
if entries[2].Content != expectedContent {
|
||
t.Errorf("Third entry content: expected '%s', got '%s'", expectedContent, entries[2].Content)
|
||
}
|
||
}
|
||
|
||
func TestGenerate(t *testing.T) {
|
||
// Create test entries
|
||
entries := []model.SRTEntry{
|
||
{
|
||
Number: 1,
|
||
StartTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
|
||
EndTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 4, Milliseconds: 0},
|
||
Content: "This is the first line.",
|
||
},
|
||
{
|
||
Number: 2,
|
||
StartTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 5, Milliseconds: 0},
|
||
EndTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 8, Milliseconds: 0},
|
||
Content: "This is the second line.",
|
||
},
|
||
}
|
||
|
||
// Generate SRT file
|
||
tempDir := t.TempDir()
|
||
outputFile := filepath.Join(tempDir, "output.srt")
|
||
err := Generate(entries, outputFile)
|
||
if err != nil {
|
||
t.Fatalf("Generate failed: %v", err)
|
||
}
|
||
|
||
// Verify generated content
|
||
content, err := os.ReadFile(outputFile)
|
||
if err != nil {
|
||
t.Fatalf("Failed to read output file: %v", err)
|
||
}
|
||
|
||
// Check content
|
||
lines := strings.Split(string(content), "\n")
|
||
if len(lines) < 6 {
|
||
t.Fatalf("Expected at least 6 lines, got %d", len(lines))
|
||
}
|
||
|
||
if lines[0] != "1" {
|
||
t.Errorf("Expected first line to be '1', got '%s'", lines[0])
|
||
}
|
||
|
||
if lines[1] != "00:00:01,000 --> 00:00:04,000" {
|
||
t.Errorf("Expected second line to be time range, got '%s'", lines[1])
|
||
}
|
||
|
||
if lines[2] != "This is the first line." {
|
||
t.Errorf("Expected third line to be content, got '%s'", lines[2])
|
||
}
|
||
}
|
||
|
||
func TestConvertToSubtitle(t *testing.T) {
|
||
// Create a temporary test file
|
||
content := `1
|
||
00:00:01,000 --> 00:00:04,000
|
||
This is the first line.
|
||
|
||
2
|
||
00:00:05,000 --> 00:00:08,000
|
||
This is the second line.
|
||
`
|
||
tempDir := t.TempDir()
|
||
testFile := filepath.Join(tempDir, "test.srt")
|
||
if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
|
||
t.Fatalf("Failed to create test file: %v", err)
|
||
}
|
||
|
||
// Convert to subtitle
|
||
subtitle, err := ConvertToSubtitle(testFile)
|
||
if err != nil {
|
||
t.Fatalf("ConvertToSubtitle failed: %v", err)
|
||
}
|
||
|
||
// Check result
|
||
if subtitle.Format != "srt" {
|
||
t.Errorf("Expected format 'srt', got '%s'", subtitle.Format)
|
||
}
|
||
|
||
if len(subtitle.Entries) != 2 {
|
||
t.Errorf("Expected 2 entries, got %d", len(subtitle.Entries))
|
||
}
|
||
|
||
// Check first entry
|
||
if subtitle.Entries[0].Text != "This is the first line." {
|
||
t.Errorf("Expected first entry text 'This is the first line.', got '%s'", subtitle.Entries[0].Text)
|
||
}
|
||
}
|
||
|
||
func TestConvertFromSubtitle(t *testing.T) {
|
||
// Create test subtitle
|
||
subtitle := model.NewSubtitle()
|
||
subtitle.Format = "srt"
|
||
|
||
entry1 := model.NewSubtitleEntry()
|
||
entry1.Index = 1
|
||
entry1.StartTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0}
|
||
entry1.EndTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 4, Milliseconds: 0}
|
||
entry1.Text = "This is the first line."
|
||
|
||
entry2 := model.NewSubtitleEntry()
|
||
entry2.Index = 2
|
||
entry2.StartTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 5, Milliseconds: 0}
|
||
entry2.EndTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 8, Milliseconds: 0}
|
||
entry2.Text = "This is the second line."
|
||
|
||
subtitle.Entries = append(subtitle.Entries, entry1, entry2)
|
||
|
||
// Convert from subtitle to SRT
|
||
tempDir := t.TempDir()
|
||
outputFile := filepath.Join(tempDir, "output.srt")
|
||
err := ConvertFromSubtitle(subtitle, outputFile)
|
||
if err != nil {
|
||
t.Fatalf("ConvertFromSubtitle failed: %v", err)
|
||
}
|
||
|
||
// Verify by parsing back
|
||
entries, err := Parse(outputFile)
|
||
if err != nil {
|
||
t.Fatalf("Failed to parse output file: %v", err)
|
||
}
|
||
|
||
if len(entries) != 2 {
|
||
t.Errorf("Expected 2 entries, got %d", len(entries))
|
||
}
|
||
|
||
if entries[0].Content != "This is the first line." {
|
||
t.Errorf("Expected first entry content 'This is the first line.', got '%s'", entries[0].Content)
|
||
}
|
||
}
|
||
|
||
func TestFormat(t *testing.T) {
|
||
// Create test file with non-sequential numbers
|
||
content := `2
|
||
00:00:01,000 --> 00:00:04,000
|
||
This is the first line.
|
||
|
||
5
|
||
00:00:05,000 --> 00:00:08,000
|
||
This is the second line.
|
||
`
|
||
tempDir := t.TempDir()
|
||
testFile := filepath.Join(tempDir, "test.srt")
|
||
if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
|
||
t.Fatalf("Failed to create test file: %v", err)
|
||
}
|
||
|
||
// Format the file
|
||
err := Format(testFile)
|
||
if err != nil {
|
||
t.Fatalf("Format failed: %v", err)
|
||
}
|
||
|
||
// Verify by parsing back
|
||
entries, err := Parse(testFile)
|
||
if err != nil {
|
||
t.Fatalf("Failed to parse formatted file: %v", err)
|
||
}
|
||
|
||
// Check that numbers are sequential
|
||
if entries[0].Number != 1 {
|
||
t.Errorf("Expected first entry number to be 1, got %d", entries[0].Number)
|
||
}
|
||
if entries[1].Number != 2 {
|
||
t.Errorf("Expected second entry number to be 2, got %d", entries[1].Number)
|
||
}
|
||
}
|
||
|
||
func TestParseSRTTimestamp(t *testing.T) {
|
||
testCases := []struct {
|
||
name string
|
||
input string
|
||
expected model.Timestamp
|
||
}{
|
||
{
|
||
name: "Standard format",
|
||
input: "00:00:01,000",
|
||
expected: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
|
||
},
|
||
{
|
||
name: "With milliseconds",
|
||
input: "00:00:01,500",
|
||
expected: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 500},
|
||
},
|
||
{
|
||
name: "Full hours, minutes, seconds",
|
||
input: "01:02:03,456",
|
||
expected: model.Timestamp{Hours: 1, Minutes: 2, Seconds: 3, Milliseconds: 456},
|
||
},
|
||
{
|
||
name: "With dot instead of comma",
|
||
input: "00:00:01.000", // Should auto-convert . to ,
|
||
expected: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
|
||
},
|
||
{
|
||
name: "Invalid format",
|
||
input: "invalid",
|
||
expected: model.Timestamp{}, // Should return zero timestamp
|
||
},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
result := parseSRTTimestamp(tc.input)
|
||
if result != tc.expected {
|
||
t.Errorf("For input '%s', expected %+v, got %+v", tc.input, tc.expected, result)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestFormatSRTTimestamp(t *testing.T) {
|
||
testCases := []struct {
|
||
name string
|
||
input model.Timestamp
|
||
expected string
|
||
}{
|
||
{
|
||
name: "Zero timestamp",
|
||
input: model.Timestamp{},
|
||
expected: "00:00:00,000",
|
||
},
|
||
{
|
||
name: "Simple seconds",
|
||
input: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
|
||
expected: "00:00:01,000",
|
||
},
|
||
{
|
||
name: "With milliseconds",
|
||
input: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 500},
|
||
expected: "00:00:01,500",
|
||
},
|
||
{
|
||
name: "Full timestamp",
|
||
input: model.Timestamp{Hours: 1, Minutes: 2, Seconds: 3, Milliseconds: 456},
|
||
expected: "01:02:03,456",
|
||
},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
result := formatSRTTimestamp(tc.input)
|
||
if result != tc.expected {
|
||
t.Errorf("For timestamp %+v, expected '%s', got '%s'", tc.input, tc.expected, result)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestIsEntryTimeStampUnset(t *testing.T) {
|
||
testCases := []struct {
|
||
name string
|
||
entry model.SRTEntry
|
||
expected bool
|
||
}{
|
||
{
|
||
name: "Unset timestamp",
|
||
entry: model.SRTEntry{Number: 1},
|
||
expected: true,
|
||
},
|
||
{
|
||
name: "Set timestamp",
|
||
entry: model.SRTEntry{
|
||
Number: 1,
|
||
StartTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
|
||
},
|
||
expected: false,
|
||
},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
result := isEntryTimeStampUnset(tc.entry)
|
||
if result != tc.expected {
|
||
t.Errorf("For entry %+v, expected isEntryTimeStampUnset to be %v, got %v", tc.entry, tc.expected, result)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestConvertToLyrics(t *testing.T) {
|
||
// Create test entries
|
||
entries := []model.SRTEntry{
|
||
{
|
||
Number: 1,
|
||
StartTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
|
||
EndTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 4, Milliseconds: 0},
|
||
Content: "This is the first line.",
|
||
},
|
||
{
|
||
Number: 2,
|
||
StartTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 5, Milliseconds: 0},
|
||
EndTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 8, Milliseconds: 0},
|
||
Content: "This is the second line.",
|
||
},
|
||
}
|
||
|
||
// Convert to lyrics
|
||
lyrics := ConvertToLyrics(entries)
|
||
|
||
// Check result
|
||
if len(lyrics.Timeline) != 2 {
|
||
t.Errorf("Expected 2 timeline entries, got %d", len(lyrics.Timeline))
|
||
}
|
||
if len(lyrics.Content) != 2 {
|
||
t.Errorf("Expected 2 content entries, got %d", len(lyrics.Content))
|
||
}
|
||
|
||
// Check timeline entries
|
||
if lyrics.Timeline[0] != entries[0].StartTime {
|
||
t.Errorf("First timeline entry: expected %+v, got %+v", entries[0].StartTime, lyrics.Timeline[0])
|
||
}
|
||
if lyrics.Timeline[1] != entries[1].StartTime {
|
||
t.Errorf("Second timeline entry: expected %+v, got %+v", entries[1].StartTime, lyrics.Timeline[1])
|
||
}
|
||
|
||
// Check content entries
|
||
if lyrics.Content[0] != entries[0].Content {
|
||
t.Errorf("First content entry: expected '%s', got '%s'", entries[0].Content, lyrics.Content[0])
|
||
}
|
||
if lyrics.Content[1] != entries[1].Content {
|
||
t.Errorf("Second content entry: expected '%s', got '%s'", entries[1].Content, lyrics.Content[1])
|
||
}
|
||
}
|
||
|
||
func TestParse_EdgeCases(t *testing.T) {
|
||
// Test with empty file
|
||
tempDir := t.TempDir()
|
||
emptyFile := filepath.Join(tempDir, "empty.srt")
|
||
if err := os.WriteFile(emptyFile, []byte{}, 0644); err != nil {
|
||
t.Fatalf("Failed to create empty test file: %v", err)
|
||
}
|
||
|
||
entries, err := Parse(emptyFile)
|
||
if err != nil {
|
||
t.Fatalf("Parse failed on empty file: %v", err)
|
||
}
|
||
|
||
if len(entries) != 0 {
|
||
t.Errorf("Expected 0 entries for empty file, got %d", len(entries))
|
||
}
|
||
|
||
// Test with malformed file (missing timestamp line)
|
||
malformedFile := filepath.Join(tempDir, "malformed.srt")
|
||
content := `1
|
||
This is missing a timestamp line.
|
||
|
||
2
|
||
00:00:05,000 --> 00:00:08,000
|
||
This is valid.
|
||
`
|
||
if err := os.WriteFile(malformedFile, []byte(content), 0644); err != nil {
|
||
t.Fatalf("Failed to create malformed test file: %v", err)
|
||
}
|
||
|
||
entries, err = Parse(malformedFile)
|
||
if err != nil {
|
||
t.Fatalf("Parse failed on malformed file: %v", err)
|
||
}
|
||
|
||
// SRT解析器更宽容，可能会解析出两个条目
|
||
if len(entries) != 2 {
|
||
t.Errorf("Expected 2 entries, got %d", len(entries))
|
||
}
|
||
|
||
// Test with incomplete last entry
|
||
incompleteFile := filepath.Join(tempDir, "incomplete.srt")
|
||
content = `1
|
||
00:00:01,000 --> 00:00:04,000
|
||
This is complete.
|
||
|
||
2
|
||
00:00:05,000 --> 00:00:08,000
|
||
`
|
||
if err := os.WriteFile(incompleteFile, []byte(content), 0644); err != nil {
|
||
t.Fatalf("Failed to create incomplete test file: %v", err)
|
||
}
|
||
|
||
entries, err = Parse(incompleteFile)
|
||
if err != nil {
|
||
t.Fatalf("Parse failed on incomplete file: %v", err)
|
||
}
|
||
|
||
// Should have one complete entry, the incomplete one is discarded due to empty content
|
||
if len(entries) != 1 {
|
||
t.Errorf("Expected 1 entry (only the completed one), got %d", len(entries))
|
||
}
|
||
}
|
||
|
||
func TestParse_FileError(t *testing.T) {
|
||
// Test with non-existent file
|
||
_, err := Parse("/nonexistent/file.srt")
|
||
if err == nil {
|
||
t.Error("Expected error when parsing non-existent file, got nil")
|
||
}
|
||
}
|
||
|
||
func TestGenerate_FileError(t *testing.T) {
|
||
// Create test entries
|
||
entries := []model.SRTEntry{
|
||
{
|
||
Number: 1,
|
||
StartTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
|
||
EndTime: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 4, Milliseconds: 0},
|
||
Content: "This is a test line.",
|
||
},
|
||
}
|
||
|
||
// Test with invalid path
|
||
err := Generate(entries, "/nonexistent/directory/file.srt")
|
||
if err == nil {
|
||
t.Error("Expected error when generating to invalid path, got nil")
|
||
}
|
||
}
|
||
|
||
func TestFormat_FileError(t *testing.T) {
|
||
// Test with non-existent file
|
||
err := Format("/nonexistent/file.srt")
|
||
if err == nil {
|
||
t.Error("Expected error when formatting non-existent file, got nil")
|
||
}
|
||
}
|
||
|
||
func TestConvertToSubtitle_WithHTMLTags(t *testing.T) {
|
||
// Create a temporary test file with HTML tags
|
||
content := `1
|
||
00:00:01,000 --> 00:00:04,000
|
||
<i>This is in italic.</i>
|
||
|
||
2
|
||
00:00:05,000 --> 00:00:08,000
|
||
<b>This is in bold.</b>
|
||
|
||
3
|
||
00:00:09,000 --> 00:00:12,000
|
||
<u>This is underlined.</u>
|
||
`
|
||
tempDir := t.TempDir()
|
||
testFile := filepath.Join(tempDir, "styles.srt")
|
||
if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
|
||
t.Fatalf("Failed to create test file with HTML tags: %v", err)
|
||
}
|
||
|
||
// Convert to subtitle
|
||
subtitle, err := ConvertToSubtitle(testFile)
|
||
if err != nil {
|
||
t.Fatalf("ConvertToSubtitle failed: %v", err)
|
||
}
|
||
|
||
// Check if HTML tags were detected
|
||
if value, ok := subtitle.Entries[0].FormatData["has_html_tags"]; !ok || value != true {
|
||
t.Errorf("Expected FormatData to contain has_html_tags=true for entry with italic")
|
||
}
|
||
if value, ok := subtitle.Entries[0].Styles["italic"]; !ok || value != "true" {
|
||
t.Errorf("Expected Styles to contain italic=true for entry with <i> tag")
|
||
}
|
||
|
||
if value, ok := subtitle.Entries[1].Styles["bold"]; !ok || value != "true" {
|
||
t.Errorf("Expected Styles to contain bold=true for entry with <b> tag")
|
||
}
|
||
|
||
if value, ok := subtitle.Entries[2].Styles["underline"]; !ok || value != "true" {
|
||
t.Errorf("Expected Styles to contain underline=true for entry with <u> tag")
|
||
}
|
||
}
|
||
|
||
func TestConvertToSubtitle_FileError(t *testing.T) {
|
||
// Test with non-existent file
|
||
_, err := ConvertToSubtitle("/nonexistent/file.srt")
|
||
if err == nil {
|
||
t.Error("Expected error when converting non-existent file, got nil")
|
||
}
|
||
}
|
||
|
||
func TestConvertFromSubtitle_WithStyling(t *testing.T) {
|
||
// Create a subtitle with style attributes
|
||
subtitle := model.NewSubtitle()
|
||
subtitle.Format = "srt"
|
||
|
||
// Create an entry with italics
|
||
entry1 := model.NewSubtitleEntry()
|
||
entry1.Index = 1
|
||
entry1.StartTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0}
|
||
entry1.EndTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 4, Milliseconds: 0}
|
||
entry1.Text = "This should be italic."
|
||
entry1.Styles["italic"] = "true"
|
||
|
||
// Create an entry with bold
|
||
entry2 := model.NewSubtitleEntry()
|
||
entry2.Index = 2
|
||
entry2.StartTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 5, Milliseconds: 0}
|
||
entry2.EndTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 8, Milliseconds: 0}
|
||
entry2.Text = "This should be bold."
|
||
entry2.Styles["bold"] = "true"
|
||
|
||
// Create an entry with underline
|
||
entry3 := model.NewSubtitleEntry()
|
||
entry3.Index = 3
|
||
entry3.StartTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 9, Milliseconds: 0}
|
||
entry3.EndTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 12, Milliseconds: 0}
|
||
entry3.Text = "This should be underlined."
|
||
entry3.Styles["underline"] = "true"
|
||
|
||
subtitle.Entries = append(subtitle.Entries, entry1, entry2, entry3)
|
||
|
||
// Convert from subtitle to SRT
|
||
tempDir := t.TempDir()
|
||
outputFile := filepath.Join(tempDir, "styled.srt")
|
||
err := ConvertFromSubtitle(subtitle, outputFile)
|
||
if err != nil {
|
||
t.Fatalf("ConvertFromSubtitle failed: %v", err)
|
||
}
|
||
|
||
// Verify by reading the file directly
|
||
content, err := os.ReadFile(outputFile)
|
||
if err != nil {
|
||
t.Fatalf("Failed to read output file: %v", err)
|
||
}
|
||
|
||
// Check that HTML tags were applied
|
||
contentStr := string(content)
|
||
if !strings.Contains(contentStr, "<i>This should be italic.</i>") {
|
||
t.Errorf("Expected italic HTML tags to be applied")
|
||
}
|
||
if !strings.Contains(contentStr, "<b>This should be bold.</b>") {
|
||
t.Errorf("Expected bold HTML tags to be applied")
|
||
}
|
||
if !strings.Contains(contentStr, "<u>This should be underlined.</u>") {
|
||
t.Errorf("Expected underline HTML tags to be applied")
|
||
}
|
||
}
|
||
|
||
func TestConvertFromSubtitle_FileError(t *testing.T) {
|
||
// Create simple subtitle
|
||
subtitle := model.NewSubtitle()
|
||
subtitle.Entries = append(subtitle.Entries, model.NewSubtitleEntry())
|
||
|
||
// Test with invalid path
|
||
err := ConvertFromSubtitle(subtitle, "/nonexistent/directory/file.srt")
|
||
if err == nil {
|
||
t.Error("Expected error when converting to invalid path, got nil")
|
||
}
|
||
}
|
||
|
||
func TestConvertFromSubtitle_WithExistingHTMLTags(t *testing.T) {
|
||
// Create a subtitle with text that already contains HTML tags
|
||
subtitle := model.NewSubtitle()
|
||
subtitle.Format = "srt"
|
||
|
||
// Create an entry with existing italic tags but also style attribute
|
||
entry := model.NewSubtitleEntry()
|
||
entry.Index = 1
|
||
entry.StartTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0}
|
||
entry.EndTime = model.Timestamp{Hours: 0, Minutes: 0, Seconds: 4, Milliseconds: 0}
|
||
entry.Text = "<i>Already italic text.</i>"
|
||
entry.Styles["italic"] = "true" // Should not double-wrap with <i> tags
|
||
|
||
subtitle.Entries = append(subtitle.Entries, entry)
|
||
|
||
// Convert from subtitle to SRT
|
||
tempDir := t.TempDir()
|
||
outputFile := filepath.Join(tempDir, "existing_tags.srt")
|
||
err := ConvertFromSubtitle(subtitle, outputFile)
|
||
if err != nil {
|
||
t.Fatalf("ConvertFromSubtitle failed: %v", err)
|
||
}
|
||
|
||
// Verify by reading the file directly
|
||
content, err := os.ReadFile(outputFile)
|
||
if err != nil {
|
||
t.Fatalf("Failed to read output file: %v", err)
|
||
}
|
||
|
||
// Should not have double tags
|
||
contentStr := string(content)
|
||
if strings.Contains(contentStr, "<i><i>") {
|
||
t.Errorf("Expected no duplicate italic tags, but found them")
|
||
}
|
||
}
|