Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.
C# audio-converteravaloniabatch-conversionconvertercsharpdocument-converterdocx-to-pdfdotnetdrag-and-dropfile-conversionfile-converterheic-converterhwphwpximage-converterlinuxmacospdf-convertervideo-converterwindows
// "Size limit" (#553): only the result has to fit, so only the step that writes it sees the limit; and the
// ready-made presets for where a file goes are offered by Add only, never put in the library on their own.
using Filee.Core.Conversion;
using Filee.Core.Localization;
using Filee.Core.Presets;
namespace Filee.Core.Tests;
public class SizeLimitTests
{
[Fact]
public async Task Only_the_step_that_writes_the_result_gets_the_size_limit()
{
using var dir = new TempDir();
var photo = dir.File("photo.jpg");
var first = new FakeConverter("magick", new ConversionEdge("jpg", "png"));
var second = new FakeConverter("other", new ConversionEdge("png", "webp"));
await using var queue = new JobQueue(new ConverterCatalog([first, second]));
var preset = new Preset { TargetFormat = "webp", Image = { MaxSizeMb = 2 }, Media = { MaxSizeMb = 5 } };
await queue.RunAsync(new ConversionJob([photo], preset, "WEBP"));
var middle = Assert.Single(first.Presets);
Assert.Equal((0.0, 0.0), (middle.Image.MaxSizeMb, middle.Media.MaxSizeMb));
var last = Assert.Single(second.Presets);
Assert.Equal((2.0, 5.0), (last.Image.MaxSizeMb, last.Media.MaxSizeMb));
Assert.Equal(2, preset.Image.MaxSizeMb); // the user's preset itself is never changed
}
[Fact]
public async Task A_result_no_engine_fitted_is_refused_rather_than_handed_over_too_large()
{
// The fake engine writes its result as it is (like HEIC, a CAD render or an animation): the queue checks it.
using var dir = new TempDir();
var photo = dir.File("photo.jpg");
await using var queue = new JobQueue(new ConverterCatalog([new FakeConverter("magick", new ConversionEdge("jpg", "png"))]));
var job = new ConversionJob([photo], new Preset { TargetFormat = "png", Image = { MaxSizeMb = 0.000001 } }, "PNG");
await queue.RunAsync(job);
var file = Assert.Single(job.Files);
Assert.Equal(FileState.Failed, file.State);
Assert.Equal("error.over_size_limit", file.ErrorKey);
Assert.Empty(job.Outputs);
Assert.Equal([photo], Directory.GetFiles(dir.Path)); // nothing too large is left behind
}
[Fact]
public async Task A_result_within_the_limit_or_without_one_is_kept()
{
using var dir = new TempDir();
var photo = dir.File("photo.jpg");
await using var queue = new JobQueue(new ConverterCatalog([new FakeConverter("magick", new ConversionEdge("jpg", "png"))]));
var fits = new ConversionJob([photo], new Preset { TargetFormat = "png", Image = { MaxSizeMb = 1 } }, "PNG");
await queue.RunAsync(fits);
// A video limit says nothing about a picture.
var other = new ConversionJob([photo], new Preset { TargetFormat = "png", Media = { MaxSizeMb = 0.000001 }, Output = { FileNamePattern = "{name}_2" } }, "PNG");
await queue.RunAsync(other);
Assert.Equal(JobState.Completed, fits.State);
Assert.Equal(JobState.Completed, other.State);
}
[Fact]
public async Task A_minimum_alone_is_also_only_for_the_step_that_writes_the_result()
{
// No maximum at all: the minimum on its own must be taken off the steps on the way (#662).
using var dir = new TempDir();
var photo = dir.File("photo.jpg");
var first = new FakeConverter("magick", new ConversionEdge("jpg", "png"));
var second = new FakeConverter("other", new ConversionEdge("png", "webp"));
await using var queue = new JobQueue(new ConverterCatalog([first, second]));
await queue.RunAsync(new ConversionJob([photo], new Preset { TargetFormat = "webp", Image = { MinSizeMb = 0.06 } }, "WEBP"));
Assert.Equal(0, Assert.Single(first.Presets).Image.MinSizeMb);
Assert.Equal(0.06, Assert.Single(second.Presets).Image.MinSizeMb);
}
[Theory]
[InlineData(0.001, true)] // 1,000 bytes: the fake result is a few dozen
[InlineData(0.00001, false)] // 10 bytes
[InlineData(0, false)] // no minimum
public async Task A_picture_under_the_minimum_is_kept_with_a_notice(double minimum, bool under)
{
using var dir = new TempDir();
var photo = dir.File("photo.jpg");
await using var queue = new JobQueue(new ConverterCatalog([new FakeConverter("magick", new ConversionEdge("jpg", "png"))]));
var job = new ConversionJob([photo], new Preset { TargetFormat = "png", Image = { MinSizeMb = minimum } }, "PNG");
await queue.RunAsync(job);
var file = Assert.Single(job.Files);
Assert.Equal(FileState.Done, file.State);
Assert.Single(file.Outputs);
Assert.Equal(under, file.UnderMinimumSize);
Assert.Equal(under, file.HasNotice);
}
[Theory]
[InlineData(1)]
[InlineData(2)]
public async Task Under_save_as_zip_the_pictures_are_measured_not_the_zip(int pictures)
{
using var dir = new TempDir();
var photo = dir.File("photo.jpg");
var big = new string('a', 5_000); // packs into a ZIP far under 4,000 bytes
var converter = new FakeConverter("magick", new ConversionEdge("jpg", "png")) { OutputsPerInput = pictures, Content = _ => big };
await using var queue = new JobQueue(new ConverterCatalog([converter]));
var preset = new Preset { TargetFormat = "png", Image = { MinSizeMb = 0.004 }, Output = { ZipResult = true } };
var fits = new ConversionJob([photo], preset, "PNG");
await queue.RunAsync(fits);
var zip = Assert.Single(fits.Files[0].Outputs);
Assert.EndsWith(".zip", zip);
Assert.True(new FileInfo(zip).Length < 4_000);
Assert.False(fits.Files[0].UnderMinimumSize);
// One picture short (the last one) is enough for the notice.
converter.Content = i => i == pictures - 1 ? "short" : big;
preset.Output.FileNamePattern = "{name}_2";
var shortJob = new ConversionJob([photo], preset, "PNG");
await queue.RunAsync(shortJob);
Assert.Equal(FileState.Done, shortJob.Files[0].State);
Assert.True(shortJob.Files[0].UnderMinimumSize);
}
[Fact]
public async Task One_page_under_the_minimum_is_enough_for_the_notice()
{
using var dir = new TempDir();
var scan = dir.File("scan.pdf");
var converter = new FakeConverter("pdfium", new ConversionEdge("pdf", "png")) { OutputsPerInput = 3, Content = i => i == 1 ? "short" : new string('a', 2_000) };
await using var queue = new JobQueue(new ConverterCatalog([converter]));
var job = new ConversionJob([scan], new Preset { TargetFormat = "png", Image = { MinSizeMb = 0.001 } }, "PNG");
await queue.RunAsync(job);
Assert.Equal(3, job.Files[0].Outputs.Count);
Assert.True(job.Files[0].UnderMinimumSize);
}
[Fact]
public async Task The_original_kept_as_it_was_smaller_still_tells_that_it_is_under_the_minimum()
{
using var dir = new TempDir();
var tiny = dir.File("tiny.jpg", "x");
var preset = BuiltInData.CreatePresets().Single(p => p.Id == "compress-image").Clone();
preset.Image.MinSizeMb = 0.0001; // 100 bytes
await using var queue = new JobQueue(new ConverterCatalog([new FakeConverter("magick", new ConversionEdge("jpg", "jpg"))]));
var job = new ConversionJob([tiny], preset, "JPG");
await queue.RunAsync(job);
var file = Assert.Single(job.Files);
Assert.Equal("notice.pdf_not_smaller", file.NoticeKey);
Assert.True(file.UnderMinimumSize);
Assert.Equal("notice.with_under_min_size(notice.pdf_not_smaller|notice.under_min_size)", new KeyLocalizer().Notice(file));
}
[Fact]
public async Task A_multi_page_tiff_under_the_minimum_gets_the_notice_on_the_first_file()
{
using var dir = new TempDir();
var photo = dir.File("photo.jpg");
var other = dir.File("other.jpg");
await using var queue = new JobQueue(new ConverterCatalog([new FakeConverter("magick", new ConversionEdge("jpg", "tiff"))]),
tiffMerger: new FakeTiffMerger());
var job = new ConversionJob([photo, other], new Preset { TargetFormat = "tiff", Image = { MultiPageTiff = true, MinSizeMb = 0.001 } }, "TIFF");
await queue.RunAsync(job);
Assert.Equal(JobState.Completed, job.State);
Assert.Single(job.Files[0].Outputs);
Assert.True(job.Files[0].UnderMinimumSize);
Assert.False(job.Files[1].UnderMinimumSize);
}
[Fact]
public async Task A_folder_result_is_not_measured()
{
// Named like a picture, but a folder (video frames): left alone, not failed.
using var dir = new TempDir();
var clip = dir.File("clip.mp4");
await using var queue = new JobQueue(new ConverterCatalog([new FakeConverter("ffmpeg", new ConversionEdge("mp4", "jpg")) { OutputIsFolder = true }]));
var job = new ConversionJob([clip], new Preset { TargetFormat = "jpg", Image = { MinSizeMb = 0.001 } }, "JPG");
await queue.RunAsync(job);
var file = Assert.Single(job.Files);
Assert.Equal(FileState.Done, file.State);
Assert.True(Directory.Exists(Assert.Single(file.Outputs)));
Assert.False(file.UnderMinimumSize);
}
[Fact]
public void A_picture_limit_under_a_megabyte_reads_in_kilobytes_and_a_minimum_counts_every_byte()
{
Assert.EndsWith("KB", SizeLimit.Describe(61_200, 50_000, image: true));
Assert.EndsWith("MB", SizeLimit.Describe(2_500_000, 2_000_000, image: true));
Assert.EndsWith("MB", SizeLimit.Describe(600_000, 500_000)); // a video's limit stays in MB
Assert.Equal(1_001_000, SizeLimit.MinimumBytes(1.001)); // truncated, it would be 1,000,999
Assert.Equal([50_000L, 999_000L, 4_096_000_000L], new[] { 0.05, 0.999, 4096 }.Select(SizeLimit.MinimumBytes));
using var dir = new TempDir();
var preset = new Preset { Image = { MinSizeMb = 1.001 } };
bool Under(int bytes) => SizeLimit.IsUnderMinimum(preset, [dir.File($"{bytes}.png", new string('a', bytes))]);
Assert.Equal((true, false, false), (Under(1_000_999), Under(1_001_000), Under(1_001_001)));
}
[Fact]
public void A_notice_shows_the_minimum_alone_or_beside_the_other_note()
{
var loc = new KeyLocalizer();
Assert.Equal("notice.under_min_size", loc.Notice(new FileResult { SourcePath = "a.png", UnderMinimumSize = true }));
Assert.Equal("", loc.Notice(new FileResult { SourcePath = "a.png" }));
Assert.Equal("notice.pdf_not_smaller", loc.Notice(new FileResult { SourcePath = "a.png", NoticeKey = "notice.pdf_not_smaller" }));
Assert.Equal("notice.with_under_min_size(notice.original_kept (trash.cannot_place)|notice.under_min_size)",
loc.Notice(new FileResult { SourcePath = "a.png", NoticeKey = "notice.original_kept", NoticeReasonKey = "trash.cannot_place", UnderMinimumSize = true }));
}
/// <summary>Gives keys back as they are, so a test sees which sentences went into a notice.</summary>
private sealed class KeyLocalizer : ILocalizer
{
public string Language => "en";
public string this[string key] => key;
public string Format(string key, params object[] args) => $"{key}({string.Join("|", args)})";
public event EventHandler? LanguageChanged { add { } remove { } }
}
[Fact]
public void The_presets_for_where_a_file_goes_are_offered_but_not_installed()
{
var places = BuiltInData.PlacePresets();
var library = BuiltInData.CreatePresets().Select(p => p.Id).ToHashSet();
Assert.Equal(["for-email", "for-discord", "for-whatsapp", "for-instagram"], places.Select(p => p.Id));
Assert.DoesNotContain(places, p => library.Contains(p.Id));
Assert.All(places.Where(p => p.TargetFormat == "mp4"), p => Assert.True(p.Media.MaxSizeMb > 0));
Assert.Equal(720, places.Single(p => p.Id == "for-whatsapp").Media.MaxHeight);
Assert.Equal((ResizeMode.Width, 1080), places.Single(p => p.Id == "for-instagram").Image is var i ? (i.Resize, i.Width) : default);
// A new list each time: adding one never changes the next.
Assert.NotSame(places[0], BuiltInData.PlacePresets()[0]);
}
[Fact]
public void A_percentage_limit_computes_correct_bytes()
{
Assert.Equal(25_000_000, SizeLimit.Bytes(100_000_000L, 25));
Assert.Equal(5_000_000, SizeLimit.Bytes(10_000_000L, 50));
Assert.Equal(12_345_678, SizeLimit.Bytes(123_456_789L, 10));
}
[Fact]
public void ForVideo_calculates_limit_from_percent_or_megabytes()
{
var percentPreset = new MediaOptions { MaxSizePercent = 25 };
Assert.Equal(25_000_000, SizeLimit.ForVideo(percentPreset, 100_000_000L));
var mbPreset = new MediaOptions { MaxSizeMb = 10 };
Assert.Equal(10_000_000, SizeLimit.ForVideo(mbPreset, 100_000_000L));
var nonePreset = new MediaOptions();
Assert.Equal(0, SizeLimit.ForVideo(nonePreset, 100_000_000L));
using var dir = new TempDir();
var video = dir.File("source.mp4", new string('v', 10_000));
Assert.Equal(2_500, SizeLimit.ForVideo(percentPreset, video));
}
[Fact]
public void ForVideo_refuses_when_source_is_missing_or_cannot_be_measured()
{
var percentPreset = new MediaOptions { MaxSizePercent = 25 };
var exNull = Assert.Throws<ConversionRefusedException>(() => SizeLimit.ForVideo(percentPreset, (string?)null));
Assert.Equal("error.over_size_limit", exNull.ErrorKey);
var exMissing = Assert.Throws<ConversionRefusedException>(() => SizeLimit.ForVideo(percentPreset, "C:/does_not_exist.mp4"));
Assert.Equal("error.over_size_limit", exMissing.ErrorKey);
var exZero = Assert.Throws<ConversionRefusedException>(() => SizeLimit.ForVideo(percentPreset, 0L));
Assert.Equal("error.over_size_limit", exZero.ErrorKey);
}
[Fact]
public void ForVideo_calculates_combined_limit_for_joined_sources()
{
var percentPreset = new MediaOptions { MaxSizePercent = 50 };
using var dir = new TempDir();
var video1 = dir.File("video1.mp4", new string('a', 10_000));
var video2 = dir.File("video2.mp4", new string('b', 30_000));
// Total source size is 40,000 bytes. 50% = 20,000 bytes.
Assert.Equal(20_000, SizeLimit.ForVideo(percentPreset, [video1, video2]));
// Missing source among joined sources refuses
var ex = Assert.Throws<ConversionRefusedException>(() => SizeLimit.ForVideo(percentPreset, [video1, "C:/missing.mp4"]));
Assert.Equal("error.over_size_limit", ex.ErrorKey);
var exEmpty = Assert.Throws<ConversionRefusedException>(() => SizeLimit.ForVideo(percentPreset, (IEnumerable<string>?)null));
Assert.Equal("error.over_size_limit", exEmpty.ErrorKey);
}
[Fact]
public async Task Video_percentage_limit_clears_on_intermediate_steps()
{
using var dir = new TempDir();
var clip = dir.File("clip.avi");
var first = new FakeConverter("first", new ConversionEdge("avi", "mkv"));
var second = new FakeConverter("second", new ConversionEdge("mkv", "mp4"));
await using var queue = new JobQueue(new ConverterCatalog([first, second]));
var preset = new Preset { TargetFormat = "mp4", Media = { MaxSizePercent = 50 } };
await queue.RunAsync(new ConversionJob([clip], preset, "MP4"));
var middle = Assert.Single(first.Presets);
Assert.Equal(0, middle.Media.MaxSizePercent);
var last = Assert.Single(second.Presets);
Assert.Equal(50, last.Media.MaxSizePercent);
Assert.Equal(50, preset.Media.MaxSizePercent);
}
[Fact]
public async Task A_video_result_over_percentage_limit_is_refused()
{
using var dir = new TempDir();
// Source is 10,000 bytes. With 20% limit, max allowed is 2,000 bytes.
var source = dir.File("source.mp4", new string('a', 10_000));
// FakeConverter writes 3,000 bytes output, which exceeds 2,000 bytes.
var fake = new FakeConverter("ffmpeg", new ConversionEdge("mp4", "mp4"))
{
Content = _ => new string('x', 3_000),
};
await using var queue = new JobQueue(new ConverterCatalog([fake]));
var job = new ConversionJob([source], new Preset { TargetFormat = "mp4", Media = { MaxSizePercent = 20 } }, "MP4");
await queue.RunAsync(job);
var file = Assert.Single(job.Files);
Assert.Equal(FileState.Failed, file.State);
Assert.Equal("error.over_size_limit", file.ErrorKey);
Assert.Empty(job.Outputs);
}
}