winforms/src/System.Drawing.Common/tests/BufferedGraphicsTests.cs at main · reactapi/winforms · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using Xunit;

namespace System.Drawing.Tests
{
    public class BufferedGraphicsTests
    {
        [ConditionalFact(Helpers.IsDrawingSupported)]
        public void Dispose_TempMultipleTimes_Success()
        {
            using (var context = new BufferedGraphicsContext())
            using (var image = new Bitmap(3, 3))
            using (Graphics targetGraphics = Graphics.FromImage(image))
            {
                BufferedGraphics graphics = context.Allocate(targetGraphics, new Rectangle(0, 0, 1, 1));
                Assert.NotNull(graphics.Graphics);

                graphics.Dispose();
                Assert.Null(graphics.Graphics);

                graphics.Dispose();
            }
        }

        [ConditionalFact(Helpers.IsDrawingSupported)]
        public void Dispose_ActualMultipleTimes_Success()
        {
            using (var context = new BufferedGraphicsContext())
            using (var image = new Bitmap(3, 3))
            using (Graphics targetGraphics = Graphics.FromImage(image))
            {
                BufferedGraphics graphics = context.Allocate(targetGraphics, new Rectangle(0, 0, context.MaximumBuffer.Width + 1, context.MaximumBuffer.Height + 1));
                Assert.NotNull(graphics.Graphics);

                graphics.Dispose();
                Assert.Null(graphics.Graphics);

                graphics.Dispose();
            }
        }

        [ConditionalFact(Helpers.IsDrawingSupported)]
        public void Render_ParameterlessWithTargetGraphics_Success()
        {
            Color color = Color.FromArgb(255, 0, 0, 0);

            using (var context = new BufferedGraphicsContext())
            using (var image = new Bitmap(3, 3))
            using (Graphics graphics = Graphics.FromImage(image))
            using (var brush = new SolidBrush(Color.Red))
            {
                graphics.FillRectangle(brush, new Rectangle(0, 0, 3, 3));

                using (BufferedGraphics bufferedGraphics = context.Allocate(graphics, new Rectangle(0, 0, 3, 3)))
                {
                    bufferedGraphics.Render();

                    Helpers.VerifyBitmap(image, new Color[][]
                    {
                        new Color[] { color, color, color },
                        new Color[] { color, color, color },
                        new Color[] { color, color, color }
                    });
                }
            }
        }

        [ConditionalFact(Helpers.IsDrawingSupported)]
        public void Render_ParameterlessWithNullTargetGraphics_Success()
        {
            using (var context = new BufferedGraphicsContext())
            using (var image = new Bitmap(3, 3))
            using (Graphics graphics = Graphics.FromImage(image))
            using (var brush = new SolidBrush(Color.Red))
            {
                graphics.FillRectangle(brush, new Rectangle(0, 0, 3, 3));
                try
                {
                    IntPtr hdc = graphics.GetHdc();

                    using (BufferedGraphics bufferedGraphics = context.Allocate(hdc, new Rectangle(0, 0, 3, 3)))
                    {
                        bufferedGraphics.Render();
                    }
                }
                finally
                {
                    graphics.ReleaseHdc();
                }
            }
        }

        [ConditionalFact(Helpers.IsDrawingSupported)]
        public void Render_TargetGraphics_Success()
        {
            Color color = Color.FromArgb(255, 0, 0, 0);

            using (var context = new BufferedGraphicsContext())
            using (var originalImage = new Bitmap(3, 3))
            using (var targetImage = new Bitmap(3, 3))
            using (Graphics originalGraphics = Graphics.FromImage(originalImage))
            using (Graphics targetGraphics = Graphics.FromImage(targetImage))
            using (var brush = new SolidBrush(Color.Red))
            {
                originalGraphics.FillRectangle(brush, new Rectangle(0, 0, 3, 3));

                using (BufferedGraphics graphics = context.Allocate(originalGraphics, new Rectangle(0, 0, 3, 3)))
                {
                    graphics.Render(targetGraphics);

                    Helpers.VerifyBitmap(targetImage, new Color[][]
                    {
                        new Color[] { color, color, color },
                        new Color[] { color, color, color },
                        new Color[] { color, color, color }
                    });
                }
            }
        }

        [ConditionalFact(Helpers.IsDrawingSupported)]
        public void Render_NullGraphics_Nop()
        {
            using (var context = new BufferedGraphicsContext())
            using (var image = new Bitmap(3, 3))
            using (Graphics graphics = Graphics.FromImage(image))
            using (BufferedGraphics bufferedGraphics = context.Allocate(graphics, new Rectangle(0, 0, 1, 1)))
            {
                bufferedGraphics.Render(null);
            }
        }

        [ConditionalFact(Helpers.IsDrawingSupported)]
        public void Render_InvalidTargetDC_Nop()
        {
            using (var context = new BufferedGraphicsContext())
            using (BufferedGraphics graphics = context.Allocate(null, Rectangle.Empty))
            {
                graphics.Render(IntPtr.Zero);
                graphics.Render((IntPtr)(-1));
            }
        }
    }
}