// Copyright (c) Six Labors.
// Licensed under the Six Labors Split License.

// <auto-generated />

using SixLabors.ImageSharp.PixelFormats;
using Xunit;
using Xunit.Abstractions;


namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelOperations;

public partial class PixelOperationsTests
{
        
    public partial class A8_OperationsTests : PixelOperationsTests<A8>
    {
        public A8_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<A8> Operations => A8.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<A8.PixelOperations>(PixelOperations<A8>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Argb32_OperationsTests : PixelOperationsTests<Argb32>
    {
        public Argb32_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Argb32> Operations => Argb32.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Argb32.PixelOperations>(PixelOperations<Argb32>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Abgr32_OperationsTests : PixelOperationsTests<Abgr32>
    {
        public Abgr32_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Abgr32> Operations => Abgr32.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Abgr32.PixelOperations>(PixelOperations<Abgr32>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Bgr24_OperationsTests : PixelOperationsTests<Bgr24>
    {
        public Bgr24_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Bgr24> Operations => Bgr24.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Bgr24.PixelOperations>(PixelOperations<Bgr24>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class Bgr565_OperationsTests : PixelOperationsTests<Bgr565>
    {
        public Bgr565_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Bgr565> Operations => Bgr565.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Bgr565.PixelOperations>(PixelOperations<Bgr565>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class Bgra32_OperationsTests : PixelOperationsTests<Bgra32>
    {
        public Bgra32_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Bgra32> Operations => Bgra32.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Bgra32.PixelOperations>(PixelOperations<Bgra32>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Bgra4444_OperationsTests : PixelOperationsTests<Bgra4444>
    {
        public Bgra4444_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Bgra4444> Operations => Bgra4444.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Bgra4444.PixelOperations>(PixelOperations<Bgra4444>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Bgra5551_OperationsTests : PixelOperationsTests<Bgra5551>
    {
        public Bgra5551_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Bgra5551> Operations => Bgra5551.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Bgra5551.PixelOperations>(PixelOperations<Bgra5551>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Byte4_OperationsTests : PixelOperationsTests<Byte4>
    {
        public Byte4_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Byte4> Operations => Byte4.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Byte4.PixelOperations>(PixelOperations<Byte4>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class HalfSingle_OperationsTests : PixelOperationsTests<HalfSingle>
    {
        public HalfSingle_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<HalfSingle> Operations => HalfSingle.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<HalfSingle.PixelOperations>(PixelOperations<HalfSingle>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class HalfVector2_OperationsTests : PixelOperationsTests<HalfVector2>
    {
        public HalfVector2_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<HalfVector2> Operations => HalfVector2.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<HalfVector2.PixelOperations>(PixelOperations<HalfVector2>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class HalfVector4_OperationsTests : PixelOperationsTests<HalfVector4>
    {
        public HalfVector4_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<HalfVector4> Operations => HalfVector4.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<HalfVector4.PixelOperations>(PixelOperations<HalfVector4>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class L16_OperationsTests : PixelOperationsTests<L16>
    {
        public L16_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<L16> Operations => L16.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<L16.PixelOperations>(PixelOperations<L16>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class L8_OperationsTests : PixelOperationsTests<L8>
    {
        public L8_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<L8> Operations => L8.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<L8.PixelOperations>(PixelOperations<L8>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class La16_OperationsTests : PixelOperationsTests<La16>
    {
        public La16_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<La16> Operations => La16.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<La16.PixelOperations>(PixelOperations<La16>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class La32_OperationsTests : PixelOperationsTests<La32>
    {
        public La32_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<La32> Operations => La32.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<La32.PixelOperations>(PixelOperations<La32>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class NormalizedByte2_OperationsTests : PixelOperationsTests<NormalizedByte2>
    {
        public NormalizedByte2_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<NormalizedByte2> Operations => NormalizedByte2.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<NormalizedByte2.PixelOperations>(PixelOperations<NormalizedByte2>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class NormalizedByte4_OperationsTests : PixelOperationsTests<NormalizedByte4>
    {
        public NormalizedByte4_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<NormalizedByte4> Operations => NormalizedByte4.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<NormalizedByte4.PixelOperations>(PixelOperations<NormalizedByte4>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class NormalizedShort2_OperationsTests : PixelOperationsTests<NormalizedShort2>
    {
        public NormalizedShort2_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<NormalizedShort2> Operations => NormalizedShort2.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<NormalizedShort2.PixelOperations>(PixelOperations<NormalizedShort2>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class NormalizedShort4_OperationsTests : PixelOperationsTests<NormalizedShort4>
    {
        public NormalizedShort4_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<NormalizedShort4> Operations => NormalizedShort4.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<NormalizedShort4.PixelOperations>(PixelOperations<NormalizedShort4>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Rg32_OperationsTests : PixelOperationsTests<Rg32>
    {
        public Rg32_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Rg32> Operations => Rg32.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Rg32.PixelOperations>(PixelOperations<Rg32>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class Rgb24_OperationsTests : PixelOperationsTests<Rgb24>
    {
        public Rgb24_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Rgb24> Operations => Rgb24.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Rgb24.PixelOperations>(PixelOperations<Rgb24>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class Rgb48_OperationsTests : PixelOperationsTests<Rgb48>
    {
        public Rgb48_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Rgb48> Operations => Rgb48.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Rgb48.PixelOperations>(PixelOperations<Rgb48>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class Rgba1010102_OperationsTests : PixelOperationsTests<Rgba1010102>
    {
        public Rgba1010102_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Rgba1010102> Operations => Rgba1010102.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Rgba1010102.PixelOperations>(PixelOperations<Rgba1010102>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Rgba32_OperationsTests : PixelOperationsTests<Rgba32>
    {
        public Rgba32_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Rgba32> Operations => Rgba32.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Rgba32.PixelOperations>(PixelOperations<Rgba32>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Rgba64_OperationsTests : PixelOperationsTests<Rgba64>
    {
        public Rgba64_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Rgba64> Operations => Rgba64.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Rgba64.PixelOperations>(PixelOperations<Rgba64>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class RgbaVector_OperationsTests : PixelOperationsTests<RgbaVector>
    {
        public RgbaVector_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<RgbaVector> Operations => RgbaVector.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<RgbaVector.PixelOperations>(PixelOperations<RgbaVector>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
    
    public partial class Short2_OperationsTests : PixelOperationsTests<Short2>
    {
        public Short2_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Short2> Operations => Short2.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Short2.PixelOperations>(PixelOperations<Short2>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
        }
    }
    
    public partial class Short4_OperationsTests : PixelOperationsTests<Short4>
    {
        public Short4_OperationsTests(ITestOutputHelper output)
            : base(output)
        {
        }

        protected override PixelOperations<Short4> Operations => Short4.PixelOperations.Instance;

        [Fact]
        public void IsSpecialImplementation() => Assert.IsType<Short4.PixelOperations>(PixelOperations<Short4>.Instance);

        [Fact]
        public void PixelTypeInfoHasCorrectAlphaRepresentation()
        {
            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
            Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
        }
    }
}