nullptr/Minint
Template
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

удалены тесты

Browse Source
This commit is contained in:
Роман Пытков
2026-04-09 19:01:44 +03:00
parent e0c4287e25
commit 4f08fdac2b
9 changed files with 0 additions and 513 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
Minint.Tests/CompositorTests.cs
View File

@@ -1,76 +0,0 @@
using Minint.Core.Models;
using Minint.Core.Services.Impl;
namespace Minint.Tests;
public class CompositorTests
{
private readonly Compositor _compositor = new();
[Fact]
public void Composite_EmptyLayer_AllTransparent()
{
var doc = new MinintDocument("test");
doc.Layers.Add(new MinintLayer("L1", 4));
uint[] result = _compositor.Composite(doc, 2, 2);
Assert.All(result, px => Assert.Equal(0u, px));
}
[Fact]
public void Composite_SingleOpaquePixel()
{
var doc = new MinintDocument("test");
var red = new RgbaColor(255, 0, 0, 255);
doc.EnsureColorCached(red);
var layer = new MinintLayer("L1", 4);
layer.Pixels[0] = 1;
doc.Layers.Add(layer);
uint[] result = _compositor.Composite(doc, 2, 2);
// ARGB packed as 0xAARRGGBB
uint expected = 0xFF_FF_00_00u;
Assert.Equal(expected, result[0]);
Assert.Equal(0u, result[1]); // rest is transparent
}
[Fact]
public void Composite_HiddenLayer_Ignored()
{
var doc = new MinintDocument("test");
doc.EnsureColorCached(new RgbaColor(0, 255, 0, 255));
var layer = new MinintLayer("L1", 4);
layer.Pixels[0] = 1;
layer.IsVisible = false;
doc.Layers.Add(layer);
uint[] result = _compositor.Composite(doc, 2, 2);
Assert.Equal(0u, result[0]);
}
[Fact]
public void Composite_TwoLayers_TopOverBottom()
{
var doc = new MinintDocument("test");
var red = new RgbaColor(255, 0, 0, 255);
var blue = new RgbaColor(0, 0, 255, 255);
int redIdx = doc.EnsureColorCached(red);
int blueIdx = doc.EnsureColorCached(blue);
var bottom = new MinintLayer("bottom", 1);
bottom.Pixels[0] = redIdx;
var top = new MinintLayer("top", 1);
top.Pixels[0] = blueIdx;
doc.Layers.Add(bottom);
doc.Layers.Add(top);
uint[] result = _compositor.Composite(doc, 1, 1);
// Blue on top, fully opaque, should overwrite red
Assert.Equal(0xFF_00_00_FFu, result[0]);
}
}

63
Minint.Tests/DrawingTests.cs
View File

@@ -1,63 +0,0 @@
using Minint.Core.Models;
using Minint.Core.Services.Impl;
namespace Minint.Tests;
public class DrawingTests
{
private readonly DrawingService _drawing = new();
[Fact]
public void ApplyBrush_Radius0_SetsSinglePixel()
{
var layer = new MinintLayer("L1", 9);
_drawing.ApplyBrush(layer, 1, 1, 0, 1, 3, 3);
Assert.Equal(1, layer.Pixels[1 * 3 + 1]);
Assert.Equal(0, layer.Pixels[0]); // (0,0) untouched
}
[Fact]
public void ApplyBrush_Radius1_SetsCircle()
{
var layer = new MinintLayer("L1", 25);
_drawing.ApplyBrush(layer, 2, 2, 1, 1, 5, 5);
// Center + 4 neighbors should be set
Assert.Equal(1, layer.Pixels[2 * 5 + 2]); // center
Assert.Equal(1, layer.Pixels[1 * 5 + 2]); // top
Assert.Equal(1, layer.Pixels[3 * 5 + 2]); // bottom
Assert.Equal(1, layer.Pixels[2 * 5 + 1]); // left
Assert.Equal(1, layer.Pixels[2 * 5 + 3]); // right
}
[Fact]
public void ApplyEraser_SetsToZero()
{
var layer = new MinintLayer("L1", 9);
Array.Fill(layer.Pixels, 5);
_drawing.ApplyEraser(layer, 1, 1, 0, 3, 3);
Assert.Equal(0, layer.Pixels[1 * 3 + 1]);
Assert.Equal(5, layer.Pixels[0]); // untouched
}
[Fact]
public void GetBrushMask_Radius0_SinglePixel()
{
var mask = _drawing.GetBrushMask(2, 2, 0, 5, 5);
Assert.Single(mask);
Assert.Equal((2, 2), mask[0]);
}
[Fact]
public void GetBrushMask_OutOfBounds_Clamped()
{
var mask = _drawing.GetBrushMask(0, 0, 2, 3, 3);
Assert.All(mask, p =>
{
Assert.InRange(p.X, 0, 2);
Assert.InRange(p.Y, 0, 2);
});
}
}

68
Minint.Tests/ExportTests.cs
View File

@@ -1,68 +0,0 @@
using System.Text;
using Minint.Core.Models;
using Minint.Core.Services.Impl;
using Minint.Infrastructure.Export;
namespace Minint.Tests;
public class ExportTests
{
[Fact]
public void BmpExport_WritesValidBmp()
{
var exporter = new BmpExporter();
var pixels = new uint[] { 0xFF_FF_00_00, 0xFF_00_FF_00, 0xFF_00_00_FF, 0xFF_FF_FF_FF };
var ms = new MemoryStream();
exporter.Export(ms, pixels, 2, 2);
ms.Position = 0;
byte[] data = ms.ToArray();
Assert.True(data.Length > 0);
Assert.Equal((byte)'B', data[0]);
Assert.Equal((byte)'M', data[1]);
int fileSize = BitConverter.ToInt32(data, 2);
Assert.Equal(data.Length, fileSize);
}
[Fact]
public void GifExport_WritesValidGif()
{
var exporter = new GifExporter();
var frame1 = new uint[16]; // 4x4 transparent
var frame2 = new uint[16];
Array.Fill(frame2, 0xFF_FF_00_00u);
var frames = new List<(uint[] Pixels, uint DelayMs)>
{
(frame1, 100),
(frame2, 200),
};
var ms = new MemoryStream();
exporter.Export(ms, frames, 4, 4);
ms.Position = 0;
byte[] data = ms.ToArray();
Assert.True(data.Length > 0);
string sig = Encoding.ASCII.GetString(data, 0, 6);
Assert.Equal("GIF89a", sig);
Assert.Equal(0x3B, data[^1]); // GIF trailer
}
[Fact]
public void BmpExport_DimensionMismatch_Throws()
{
var exporter = new BmpExporter();
var pixels = new uint[3]; // does not match 2x2
Assert.Throws<ArgumentException>(() =>
{
var ms = new MemoryStream();
exporter.Export(ms, pixels, 2, 2);
});
}
}

52
Minint.Tests/FloodFillTests.cs
View File

@@ -1,52 +0,0 @@
using Minint.Core.Models;
using Minint.Core.Services.Impl;
namespace Minint.Tests;
public class FloodFillTests
{
private readonly FloodFillService _fill = new();
[Fact]
public void Fill_EmptyLayer_FillsAll()
{
var layer = new MinintLayer("L1", 9); // 3x3, all zeros
_fill.Fill(layer, 0, 0, 1, 3, 3);
Assert.All(layer.Pixels, px => Assert.Equal(1, px));
}
[Fact]
public void Fill_SameColor_NoOp()
{
var layer = new MinintLayer("L1", 4);
Array.Fill(layer.Pixels, 2);
_fill.Fill(layer, 0, 0, 2, 2, 2);
Assert.All(layer.Pixels, px => Assert.Equal(2, px));
}
[Fact]
public void Fill_Bounded_DoesNotCrossBorder()
{
// 3x3 grid with a wall:
// 0 0 0
// 1 1 1
// 0 0 0
var layer = new MinintLayer("L1", 9);
layer.Pixels[3] = 1; // (0,1)
layer.Pixels[4] = 1; // (1,1)
layer.Pixels[5] = 1; // (2,1)
_fill.Fill(layer, 0, 0, 2, 3, 3);
// Top row should be filled
Assert.Equal(2, layer.Pixels[0]);
Assert.Equal(2, layer.Pixels[1]);
Assert.Equal(2, layer.Pixels[2]);
// Wall untouched
Assert.Equal(1, layer.Pixels[3]);
// Bottom row untouched (blocked by wall)
Assert.Equal(0, layer.Pixels[6]);
}
}

65
Minint.Tests/ImageEffectsTests.cs
View File

@@ -1,65 +0,0 @@
using Minint.Core.Models;
using Minint.Core.Services.Impl;
namespace Minint.Tests;
public class ImageEffectsTests
{
private readonly ImageEffectsService _effects = new();
[Fact]
public void ApplyGrayscale_ConvertsColors()
{
var doc = new MinintDocument("test");
var red = new RgbaColor(255, 0, 0, 255);
doc.EnsureColorCached(red);
_effects.ApplyGrayscale(doc);
var gray = doc.Palette[1];
Assert.Equal(gray.R, gray.G);
Assert.Equal(gray.G, gray.B);
Assert.Equal(255, gray.A);
// BT.601: 0.299*255 ≈ 76
Assert.InRange(gray.R, 74, 78);
}
[Fact]
public void ApplyGrayscale_PreservesTransparentIndex()
{
var doc = new MinintDocument("test");
doc.EnsureColorCached(new RgbaColor(100, 200, 50, 255));
_effects.ApplyGrayscale(doc);
Assert.Equal(RgbaColor.Transparent, doc.Palette[0]);
}
[Fact]
public void ApplyContrast_IncreasesContrast()
{
var doc = new MinintDocument("test");
var midGray = new RgbaColor(128, 128, 128, 255);
var lightGray = new RgbaColor(192, 192, 192, 255);
doc.EnsureColorCached(midGray);
doc.EnsureColorCached(lightGray);
_effects.ApplyContrast(doc, 2.0);
// midGray (128) stays ~128: factor*(128-128)+128 = 128
Assert.InRange(doc.Palette[1].R, 126, 130);
// lightGray (192): factor*(192-128)+128 = 2*64+128 = 256 → clamped to 255
Assert.Equal(255, doc.Palette[2].R);
}
[Fact]
public void ApplyContrast_PreservesAlpha()
{
var doc = new MinintDocument("test");
doc.EnsureColorCached(new RgbaColor(100, 100, 100, 200));
_effects.ApplyContrast(doc, 1.5);
Assert.Equal(200, doc.Palette[1].A);
}
}

26
Minint.Tests/Minint.Tests.csproj
View File

@@ -1,26 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<OutputType>Exe</OutputType>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
<TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
<UseMicrosoftTestingPlatformRunner>true</UseMicrosoftTestingPlatformRunner>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="xunit.v3" Version="3.2.2" />
</ItemGroup>
<ItemGroup>
<Using Include="Xunit" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Minint.Core\Minint.Core.csproj" />
<ProjectReference Include="..\Minint.Infrastructure\Minint.Infrastructure.csproj" />
</ItemGroup>
</Project>

41
Minint.Tests/PatternGeneratorTests.cs
View File

@@ -1,41 +0,0 @@
using Minint.Core.Models;
using Minint.Core.Services;
using Minint.Core.Services.Impl;
namespace Minint.Tests;
public class PatternGeneratorTests
{
private readonly PatternGenerator _gen = new();
[Theory]
[InlineData(PatternType.Checkerboard)]
[InlineData(PatternType.HorizontalGradient)]
[InlineData(PatternType.VerticalGradient)]
[InlineData(PatternType.HorizontalStripes)]
[InlineData(PatternType.VerticalStripes)]
[InlineData(PatternType.ConcentricCircles)]
[InlineData(PatternType.Tile)]
public void Generate_AllTypes_ProducesValidDocument(PatternType type)
{
var colors = new[] { new RgbaColor(255, 0, 0, 255), new RgbaColor(0, 0, 255, 255) };
var doc = _gen.Generate(type, 16, 16, colors, 4, 4);
Assert.Equal($"Pattern ({type})", doc.Name);
Assert.Single(doc.Layers);
Assert.Equal(256, doc.Layers[0].Pixels.Length);
Assert.True(doc.Palette.Count >= 2);
}
[Fact]
public void Generate_Checkerboard_AlternatesColors()
{
var colors = new[] { new RgbaColor(255, 0, 0, 255), new RgbaColor(0, 255, 0, 255) };
var doc = _gen.Generate(PatternType.Checkerboard, 4, 4, colors, 2);
var layer = doc.Layers[0];
int topLeft = layer.Pixels[0];
int topRight = layer.Pixels[2]; // cellSize=2, so (2,0) is next cell
Assert.NotEqual(topLeft, topRight);
}
}

121
Minint.Tests/SerializerTests.cs
View File

@@ -1,121 +0,0 @@
using Minint.Core.Models;
using Minint.Infrastructure.Serialization;
namespace Minint.Tests;
public class SerializerTests
{
private readonly MinintSerializer _serializer = new();
[Fact]
public void RoundTrip_EmptyDocument_PreservesStructure()
{
var container = new MinintContainer(32, 16);
container.AddNewDocument("Doc1");
var result = RoundTrip(container);
Assert.Equal(32, result.Width);
Assert.Equal(16, result.Height);
Assert.Single(result.Documents);
Assert.Equal("Doc1", result.Documents[0].Name);
Assert.Single(result.Documents[0].Layers);
Assert.Equal(32 * 16, result.Documents[0].Layers[0].Pixels.Length);
}
[Fact]
public void RoundTrip_MultipleDocuments_PreservesAll()
{
var container = new MinintContainer(8, 8);
var doc1 = container.AddNewDocument("Frame1");
doc1.FrameDelayMs = 200;
var doc2 = container.AddNewDocument("Frame2");
doc2.FrameDelayMs = 500;
var result = RoundTrip(container);
Assert.Equal(2, result.Documents.Count);
Assert.Equal("Frame1", result.Documents[0].Name);
Assert.Equal(200u, result.Documents[0].FrameDelayMs);
Assert.Equal("Frame2", result.Documents[1].Name);
Assert.Equal(500u, result.Documents[1].FrameDelayMs);
}
[Fact]
public void RoundTrip_PaletteAndPixels_Preserved()
{
var container = new MinintContainer(4, 4);
var doc = container.AddNewDocument("Test");
var red = new RgbaColor(255, 0, 0, 255);
doc.EnsureColorCached(red);
var layer = doc.Layers[0];
layer.Pixels[0] = 1; // red
var result = RoundTrip(container);
var rdoc = result.Documents[0];
Assert.Equal(2, rdoc.Palette.Count); // transparent + red
Assert.Equal(RgbaColor.Transparent, rdoc.Palette[0]);
Assert.Equal(red, rdoc.Palette[1]);
Assert.Equal(1, rdoc.Layers[0].Pixels[0]);
Assert.Equal(0, rdoc.Layers[0].Pixels[1]);
}
[Fact]
public void RoundTrip_LayerProperties_Preserved()
{
var container = new MinintContainer(2, 2);
var doc = container.AddNewDocument("Test");
doc.Layers[0].Name = "Background";
doc.Layers[0].IsVisible = false;
doc.Layers[0].Opacity = 128;
var result = RoundTrip(container);
var layer = result.Documents[0].Layers[0];
Assert.Equal("Background", layer.Name);
Assert.False(layer.IsVisible);
Assert.Equal(128, layer.Opacity);
}
[Fact]
public void RoundTrip_LargePalette_Uses2ByteIndices()
{
var container = new MinintContainer(2, 2);
var doc = container.AddNewDocument("BigPalette");
for (int i = 0; i < 300; i++)
doc.EnsureColorCached(new RgbaColor((byte)(i % 256), (byte)(i / 256), 0, 255));
Assert.Equal(2, doc.IndexByteWidth);
int lastIdx = doc.Palette.Count - 1;
doc.Layers[0].Pixels[0] = lastIdx;
var result = RoundTrip(container);
Assert.Equal(lastIdx, result.Documents[0].Layers[0].Pixels[0]);
}
[Fact]
public void Read_InvalidSignature_Throws()
{
var ms = new MemoryStream("BADDATA"u8.ToArray());
Assert.Throws<InvalidDataException>(() => _serializer.Read(ms));
}
[Fact]
public void Read_TruncatedStream_Throws()
{
var ms = new MemoryStream("MINI"u8.ToArray());
Assert.Throws<InvalidDataException>(() => _serializer.Read(ms));
}
private MinintContainer RoundTrip(MinintContainer container)
{
var ms = new MemoryStream();
_serializer.Write(ms, container);
ms.Position = 0;
return _serializer.Read(ms);
}
}

1
Minint.slnx
View File

@@ -1,6 +1,5 @@
<Solution> <Solution>
<Project Path="Minint.Core/Minint.Core.csproj" /> <Project Path="Minint.Core/Minint.Core.csproj" />
<Project Path="Minint.Infrastructure/Minint.Infrastructure.csproj" /> <Project Path="Minint.Infrastructure/Minint.Infrastructure.csproj" />
<Project Path="Minint.Tests/Minint.Tests.csproj" />
<Project Path="Minint/Minint.csproj" /> <Project Path="Minint/Minint.csproj" />
</Solution> </Solution>