|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.ComponentModel;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms.Automation;
using System.Windows.Forms.TestUtilities;
using Moq;
using Moq.Protected;
using Windows.Win32.System.Ole;
using Windows.Win32.UI.Controls.RichEdit;
using static Interop.Richedit;
using Point = System.Drawing.Point;
using Size = System.Drawing.Size;
namespace System.Windows.Forms.Tests;
public partial class RichTextBoxTests
{
private static readonly int s_preferredHeight = Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3;
[WinFormsFact]
public void RichTextBox_Ctor_Default()
{
using SubRichTextBox control = new();
Assert.False(control.AcceptsTab);
Assert.Null(control.AccessibleDefaultActionDescription);
Assert.Null(control.AccessibleDescription);
Assert.Null(control.AccessibleName);
Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
Assert.False(control.AllowDrop);
Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
Assert.False(control.AutoSize);
Assert.False(control.AutoWordSelection);
Assert.Equal(SystemColors.Window, control.BackColor);
Assert.Null(control.BackgroundImage);
Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
Assert.Null(control.BindingContext);
Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
Assert.Equal(96, control.Bottom);
Assert.Equal(new Rectangle(0, 0, 100, 96), control.Bounds);
Assert.Equal(0, control.BulletIndent);
Assert.True(control.CanEnableIme);
Assert.False(control.CanFocus);
Assert.True(control.CanRaiseEvents);
Assert.False(control.CanRedo);
Assert.True(control.CanSelect);
Assert.False(control.CanUndo);
Assert.False(control.Capture);
Assert.True(control.CausesValidation);
Assert.Equal(new Size(96, 92), control.ClientSize);
Assert.Equal(new Rectangle(0, 0, 96, 92), control.ClientRectangle);
Assert.Null(control.Container);
Assert.False(control.ContainsFocus);
Assert.Null(control.ContextMenuStrip);
Assert.Empty(control.Controls);
Assert.Same(control.Controls, control.Controls);
Assert.False(control.Created);
Assert.Same(Cursors.IBeam, control.Cursor);
Assert.Same(Cursors.IBeam, control.DefaultCursor);
Assert.Equal(ImeMode.Inherit, control.DefaultImeMode);
Assert.Equal(new Padding(3), control.DefaultMargin);
Assert.Equal(Size.Empty, control.DefaultMaximumSize);
Assert.Equal(Size.Empty, control.DefaultMinimumSize);
Assert.Equal(Padding.Empty, control.DefaultPadding);
Assert.Equal(new Size(100, 96), control.DefaultSize);
Assert.False(control.DesignMode);
Assert.True(control.DetectUrls);
Assert.Equal(new Rectangle(0, 0, 96, 92), control.DisplayRectangle);
Assert.Equal(DockStyle.None, control.Dock);
Assert.False(control.DoubleBuffered);
Assert.False(control.EnableAutoDragDrop);
Assert.True(control.Enabled);
Assert.False(control.EnableAutoDragDrop);
Assert.NotNull(control.Events);
Assert.Same(control.Events, control.Events);
Assert.False(control.Focused);
Assert.Equal(Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.Equal(SystemColors.WindowText, control.ForeColor);
Assert.False(control.HasChildren);
Assert.Equal(96, control.Height);
Assert.True(control.HideSelection);
Assert.Equal(ImeMode.NoControl, control.ImeMode);
Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
Assert.False(control.IsAccessible);
Assert.False(control.IsMirrored);
Assert.Equal(RichTextBoxLanguageOptions.AutoFont | RichTextBoxLanguageOptions.DualFont, control.LanguageOption);
Assert.NotNull(control.LayoutEngine);
Assert.Same(control.LayoutEngine, control.LayoutEngine);
Assert.Equal(0, control.Left);
Assert.Empty(control.Lines);
Assert.Equal(Point.Empty, control.Location);
Assert.Equal(new Padding(3), control.Margin);
Assert.Equal(Size.Empty, control.MaximumSize);
Assert.Equal(int.MaxValue, control.MaxLength);
Assert.Equal(Size.Empty, control.MinimumSize);
Assert.False(control.Modified);
Assert.True(control.Multiline);
Assert.Equal(Padding.Empty, control.Padding);
Assert.Null(control.Parent);
Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
Assert.True(control.PreferredSize.Width > 0);
Assert.True(control.PreferredSize.Height > 0);
Assert.Equal(control.PreferredSize.Height, control.PreferredHeight);
Assert.Empty(control.RedoActionName);
Assert.False(control.ReadOnly);
Assert.False(control.RecreatingHandle);
Assert.Null(control.Region);
Assert.False(control.ResizeRedraw);
Assert.Equal(0, control.RightMargin);
Assert.True(control.RichTextShortcutsEnabled);
Assert.Equal(100, control.Right);
Assert.Equal(RightToLeft.No, control.RightToLeft);
Assert.Null(control.Rtf);
Assert.Equal(RichTextBoxScrollBars.Both, control.ScrollBars);
Assert.Equal(Color.Empty, control.SelectionBackColor);
Assert.False(control.ShowSelectionMargin);
Assert.True(control.ShowFocusCues);
Assert.True(control.ShowKeyboardCues);
Assert.Null(control.Site);
Assert.Equal(new Size(100, 96), control.Size);
Assert.Equal(0, control.TabIndex);
Assert.True(control.TabStop);
Assert.Empty(control.Text);
Assert.Equal(0, control.Top);
Assert.Null(control.TopLevelControl);
Assert.Empty(control.UndoActionName);
Assert.False(control.UseWaitCursor);
Assert.True(control.Visible);
Assert.Equal(100, control.Width);
Assert.True(control.WordWrap);
Assert.Equal(1.0f, control.ZoomFactor);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_CreateParams_GetDefault_ReturnsExpected()
{
using SubRichTextBox control = new();
CreateParams createParams = control.CreateParams;
Assert.Null(createParams.Caption);
Assert.Equal("RICHEDIT50W", createParams.ClassName);
Assert.Equal(0x8, createParams.ClassStyle);
Assert.Equal(0x200, createParams.ExStyle);
Assert.Equal(96, createParams.Height);
Assert.Equal(IntPtr.Zero, createParams.Parent);
Assert.Null(createParams.Param);
Assert.Equal(0x56210044, createParams.Style);
Assert.Equal(100, createParams.Width);
Assert.Equal(0, createParams.X);
Assert.Equal(0, createParams.Y);
Assert.Same(createParams, control.CreateParams);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(BorderStyle.None, 0x56210044, 0)]
[InlineData(BorderStyle.Fixed3D, 0x56210044, 0x200)]
[InlineData(BorderStyle.FixedSingle, 0x56210044, 0x200)]
public void RichTextBox_CreateParams_GetBorderStyle_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
{
using SubRichTextBox control = new()
{
BorderStyle = borderStyle
};
CreateParams createParams = control.CreateParams;
Assert.Equal("RICHEDIT50W", createParams.ClassName);
Assert.Equal(0x8, createParams.ClassStyle);
Assert.Equal(expectedExStyle, createParams.ExStyle);
Assert.Equal(control.Height, createParams.Height);
Assert.Equal(IntPtr.Zero, createParams.Parent);
Assert.Null(createParams.Param);
Assert.Equal(expectedStyle, createParams.Style);
Assert.Equal(100, createParams.Width);
Assert.Equal(0, createParams.X);
Assert.Equal(0, createParams.Y);
Assert.Same(createParams, control.CreateParams);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(true, true, RichTextBoxScrollBars.Both, 0x56210044)]
[InlineData(true, true, RichTextBoxScrollBars.ForcedBoth, 0x56212044)]
[InlineData(true, true, RichTextBoxScrollBars.ForcedHorizontal, 0x56010044)]
[InlineData(true, true, RichTextBoxScrollBars.ForcedVertical, 0x56212044)]
[InlineData(true, true, RichTextBoxScrollBars.Horizontal, 0x56010044)]
[InlineData(true, true, RichTextBoxScrollBars.None, 0x56010044)]
[InlineData(true, true, RichTextBoxScrollBars.Vertical, 0x56210044)]
[InlineData(true, false, RichTextBoxScrollBars.Both, 0x563100C4)]
[InlineData(true, false, RichTextBoxScrollBars.ForcedBoth, 0x563120C4)]
[InlineData(true, false, RichTextBoxScrollBars.ForcedHorizontal, 0x561120C4)]
[InlineData(true, false, RichTextBoxScrollBars.ForcedVertical, 0x562120C4)]
[InlineData(true, false, RichTextBoxScrollBars.Horizontal, 0x561100C4)]
[InlineData(true, false, RichTextBoxScrollBars.None, 0x560100C4)]
[InlineData(true, false, RichTextBoxScrollBars.Vertical, 0x562100C4)]
[InlineData(false, true, RichTextBoxScrollBars.Both, 0x560100C0)]
[InlineData(false, true, RichTextBoxScrollBars.ForcedBoth, 0x560100C0)]
[InlineData(false, true, RichTextBoxScrollBars.ForcedHorizontal, 0x560100C0)]
[InlineData(false, true, RichTextBoxScrollBars.ForcedVertical, 0x560100C0)]
[InlineData(false, true, RichTextBoxScrollBars.Horizontal, 0x560100C0)]
[InlineData(false, true, RichTextBoxScrollBars.None, 0x560100C0)]
[InlineData(false, true, RichTextBoxScrollBars.Vertical, 0x560100C0)]
[InlineData(false, false, RichTextBoxScrollBars.Both, 0x560100C0)]
[InlineData(false, false, RichTextBoxScrollBars.ForcedBoth, 0x560100C0)]
[InlineData(false, false, RichTextBoxScrollBars.ForcedHorizontal, 0x560100C0)]
[InlineData(false, false, RichTextBoxScrollBars.ForcedVertical, 0x560100C0)]
[InlineData(false, false, RichTextBoxScrollBars.Horizontal, 0x560100C0)]
[InlineData(false, false, RichTextBoxScrollBars.None, 0x560100C0)]
[InlineData(false, false, RichTextBoxScrollBars.Vertical, 0x560100C0)]
public void RichTextBox_CreateParams_GetMultiline_ReturnsExpected(bool multiline, bool wordWrap, RichTextBoxScrollBars scrollBars, int expectedStyle)
{
using SubRichTextBox control = new()
{
Multiline = multiline,
WordWrap = wordWrap,
ScrollBars = scrollBars
};
CreateParams createParams = control.CreateParams;
Assert.Null(createParams.Caption);
Assert.Equal("RICHEDIT50W", createParams.ClassName);
Assert.Equal(0x8, createParams.ClassStyle);
Assert.Equal(0x200, createParams.ExStyle);
Assert.Equal(96, createParams.Height);
Assert.Equal(IntPtr.Zero, createParams.Parent);
Assert.Null(createParams.Param);
Assert.Equal(expectedStyle, createParams.Style);
Assert.Equal(100, createParams.Width);
Assert.Equal(0, createParams.X);
Assert.Equal(0, createParams.Y);
Assert.Same(createParams, control.CreateParams);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_AllowDrop_Set_GetReturnsExpected(bool value)
{
using RichTextBox control = new()
{
AllowDrop = value
};
Assert.Equal(value, control.AllowDrop);
Assert.False(control.IsHandleCreated);
// Set same.
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.False(control.IsHandleCreated);
// Set different.
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_AllowDrop_SetWithHandle_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_AllowDrop_SetWithHandleAlreadyRegistered_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
DropTargetMock dropTarget = new();
Assert.Equal(ApartmentState.STA, Application.OleRequired());
Assert.Equal(HRESULT.DRAGDROP_E_ALREADYREGISTERED, PInvoke.RegisterDragDrop(control, dropTarget));
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[Theory]
[BoolData]
public void RichTextBox_AllowDrop_SetWithHandleNonSTAThread_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.AllowDrop = value;
Assert.Equal(value, control.AllowDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_AutoSize_Set_GetReturnsExpected(bool value)
{
using SubRichTextBox control = new();
int layoutCallCount = 0;
control.Layout += (sender, e) => layoutCallCount++;
control.AutoSize = value;
Assert.Equal(value, control.AutoSize);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.Multiline);
Assert.Equal(0, layoutCallCount);
Assert.False(control.IsHandleCreated);
// Set same.
control.AutoSize = value;
Assert.Equal(value, control.AutoSize);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.Multiline);
Assert.Equal(0, layoutCallCount);
Assert.False(control.IsHandleCreated);
// Set different.
control.AutoSize = !value;
Assert.Equal(!value, control.AutoSize);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.Multiline);
Assert.Equal(0, layoutCallCount);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> AutoSize_SetNotMultiline_TestData()
{
yield return new object[] { true, s_preferredHeight, 96, 1 };
yield return new object[] { false, 96, s_preferredHeight, 0 };
}
[WinFormsTheory]
[MemberData(nameof(AutoSize_SetNotMultiline_TestData))]
public void RichTextBox_AutoSize_SetNotMultiline_GetReturnsExpected(bool value, int expectedHeight, int expectedHeight2, int expectedLayoutCallCount)
{
using SubRichTextBox control = new()
{
Multiline = false
};
int layoutCallCount = 0;
control.Layout += (sender, e) => layoutCallCount++;
control.AutoSize = value;
Assert.Equal(value, control.AutoSize);
Assert.Equal(expectedHeight, control.Height);
Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.Multiline);
Assert.Equal(expectedLayoutCallCount, layoutCallCount);
Assert.False(control.IsHandleCreated);
// Set same.
control.AutoSize = value;
Assert.Equal(value, control.AutoSize);
Assert.Equal(expectedHeight, control.Height);
Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.Multiline);
Assert.Equal(expectedLayoutCallCount, layoutCallCount);
Assert.False(control.IsHandleCreated);
// Set different.
control.AutoSize = !value;
Assert.Equal(!value, control.AutoSize);
Assert.Equal(expectedHeight2, control.Height);
Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.Multiline);
Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_AutoSize_SetWithParent_GetReturnsExpected(bool value)
{
using Control parent = new();
using SubRichTextBox control = new()
{
Parent = parent
};
int layoutCallCount = 0;
control.Layout += (sender, e) => layoutCallCount++;
int parentLayoutCallCount = 0;
void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
parent.Layout += parentHandler;
try
{
control.AutoSize = value;
Assert.Equal(value, control.AutoSize);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.Equal(0, layoutCallCount);
Assert.Equal(0, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
// Set same.
control.AutoSize = value;
Assert.Equal(value, control.AutoSize);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.Equal(0, layoutCallCount);
Assert.Equal(0, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
// Set different.
control.AutoSize = !value;
Assert.Equal(!value, control.AutoSize);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.Equal(0, layoutCallCount);
Assert.Equal(0, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
}
finally
{
parent.Layout -= parentHandler;
}
}
[WinFormsFact]
public void RichTextBox_AutoSize_SetWithHandler_CallsAutoSizeChanged()
{
using RichTextBox control = new()
{
AutoSize = true
};
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
callCount++;
};
control.AutoSizeChanged += handler;
// Set different.
control.AutoSize = false;
Assert.False(control.AutoSize);
Assert.Equal(1, callCount);
// Set same.
control.AutoSize = false;
Assert.False(control.AutoSize);
Assert.Equal(1, callCount);
// Set different.
control.AutoSize = true;
Assert.True(control.AutoSize);
Assert.Equal(2, callCount);
// Remove handler.
control.AutoSizeChanged -= handler;
control.AutoSize = false;
Assert.False(control.AutoSize);
Assert.Equal(2, callCount);
}
[WinFormsFact]
public void RichTextBox_AutoWordSelection_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.False(control.AutoWordSelection);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call EM_SETOPTIONS.
PInvoke.SendMessage(control, PInvoke.EM_SETOPTIONS, (WPARAM)(int)PInvoke.ECOOP_OR, (LPARAM)(int)PInvoke.ECO_AUTOWORDSELECTION);
Assert.False(control.AutoWordSelection);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_AutoWordSelection_Set_GetReturnsExpected(bool value)
{
using RichTextBox control = new()
{
AutoWordSelection = value
};
Assert.Equal(value, control.AutoWordSelection);
Assert.False(control.IsHandleCreated);
// Set same.
control.AutoWordSelection = value;
Assert.Equal(value, control.AutoWordSelection);
Assert.False(control.IsHandleCreated);
// Set different.
control.AutoWordSelection = !value;
Assert.Equal(!value, control.AutoWordSelection);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_AutoWordSelection_SetWithHandle_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.AutoWordSelection = value;
Assert.Equal(value, control.AutoWordSelection);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.AutoWordSelection = value;
Assert.Equal(value, control.AutoWordSelection);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.AutoWordSelection = !value;
Assert.Equal(!value, control.AutoWordSelection);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(true, 65)]
[InlineData(false, 64)]
public void RichTextBox_AutoWordSelection_GetOptions_Success(bool value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.AutoWordSelection = value;
Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETOPTIONS));
}
public static IEnumerable<object[]> BackColor_Set_TestData()
{
yield return new object[] { Color.Empty, SystemColors.Window };
yield return new object[] { Color.Red, Color.Red };
}
[WinFormsTheory]
[MemberData(nameof(BackColor_Set_TestData))]
public void RichTextBox_BackColor_Set_GetReturnsExpected(Color value, Color expected)
{
using RichTextBox control = new()
{
BackColor = value
};
Assert.Equal(expected, control.BackColor);
Assert.False(control.IsHandleCreated);
// Set same.
control.BackColor = value;
Assert.Equal(expected, control.BackColor);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
{
yield return new object[] { Color.Empty, Control.DefaultBackColor, 0 };
yield return new object[] { Color.Red, Color.Red, 1 };
}
[WinFormsTheory]
[MemberData(nameof(BackColor_SetWithHandle_TestData))]
public void Control_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
{
using Control control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.BackColor = value;
Assert.Equal(expected, control.BackColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.BackColor = value;
Assert.Equal(expected, control.BackColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_BackColor_SetWithHandler_CallsBackColorChanged()
{
using RichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
callCount++;
};
control.BackColorChanged += handler;
// Set different.
control.BackColor = Color.Red;
Assert.Equal(Color.Red, control.BackColor);
Assert.Equal(1, callCount);
// Set same.
control.BackColor = Color.Red;
Assert.Equal(Color.Red, control.BackColor);
Assert.Equal(1, callCount);
// Set different.
control.BackColor = Color.Empty;
Assert.Equal(SystemColors.Window, control.BackColor);
Assert.Equal(2, callCount);
// Remove handler.
control.BackColorChanged -= handler;
control.BackColor = Color.Red;
Assert.Equal(Color.Red, control.BackColor);
Assert.Equal(2, callCount);
}
[WinFormsTheory]
[CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
public void RichTextBox_BackgroundImage_Set_GetReturnsExpected(Image value)
{
using RichTextBox control = new()
{
BackgroundImage = value
};
Assert.Same(value, control.BackgroundImage);
Assert.False(control.IsHandleCreated);
// Set same.
control.BackgroundImage = value;
Assert.Same(value, control.BackgroundImage);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
{
using RichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
callCount++;
};
control.BackgroundImageChanged += handler;
// Set different.
using Bitmap image1 = new(10, 10);
control.BackgroundImage = image1;
Assert.Same(image1, control.BackgroundImage);
Assert.Equal(1, callCount);
// Set same.
control.BackgroundImage = image1;
Assert.Same(image1, control.BackgroundImage);
Assert.Equal(1, callCount);
// Set different.
using Bitmap image2 = new(10, 10);
control.BackgroundImage = image2;
Assert.Same(image2, control.BackgroundImage);
Assert.Equal(2, callCount);
// Set null.
control.BackgroundImage = null;
Assert.Null(control.BackgroundImage);
Assert.Equal(3, callCount);
// Remove handler.
control.BackgroundImageChanged -= handler;
control.BackgroundImage = image1;
Assert.Same(image1, control.BackgroundImage);
Assert.Equal(3, callCount);
}
[WinFormsTheory]
[EnumData<ImageLayout>]
public void RichTextBox_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
{
using SubRichTextBox control = new()
{
BackgroundImageLayout = value
};
Assert.Equal(value, control.BackgroundImageLayout);
Assert.False(control.DoubleBuffered);
Assert.False(control.IsHandleCreated);
// Set same.
control.BackgroundImageLayout = value;
Assert.Equal(value, control.BackgroundImageLayout);
Assert.False(control.DoubleBuffered);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
{
using RichTextBox control = new();
int callCount = 0;
void handler(object sender, EventArgs e)
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
callCount++;
}
control.BackgroundImageLayoutChanged += handler;
// Set different.
control.BackgroundImageLayout = ImageLayout.Center;
Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
Assert.Equal(1, callCount);
// Set same.
control.BackgroundImageLayout = ImageLayout.Center;
Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
Assert.Equal(1, callCount);
// Set different.
control.BackgroundImageLayout = ImageLayout.Stretch;
Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
Assert.Equal(2, callCount);
// Remove handler.
control.BackgroundImageLayoutChanged -= handler;
control.BackgroundImageLayout = ImageLayout.Center;
Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
Assert.Equal(2, callCount);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
[InlineData(2000)]
[InlineData(2001)]
[InlineData(int.MaxValue)]
public void RichTextBox_BulletIndent_Set_GetReturnsExpected(int value)
{
using RichTextBox control = new()
{
BulletIndent = value
};
Assert.Equal(value, control.BulletIndent);
Assert.False(control.IsHandleCreated);
// Set same.
control.BulletIndent = value;
Assert.Equal(value, control.BulletIndent);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
[InlineData(2000)]
[InlineData(2001)]
[InlineData(int.MaxValue)]
public void RichTextBox_BulletIndent_SetWithHandle_GetReturnsExpected(int value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.BulletIndent = value;
Assert.Equal(value, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.BulletIndent = value;
Assert.Equal(value, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0, 0)]
[InlineData(1, 1)]
[InlineData(2000, 2000)]
[InlineData(2001, 2001)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_BulletIndent_SetSelectionBulletWithHandle_GetReturnsExpected(int value, int selectionHangingIndent)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionBullet = true;
control.BulletIndent = value;
Assert.Equal(value, control.BulletIndent);
Assert.Equal(selectionHangingIndent, control.SelectionHangingIndent);
Assert.True(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.BulletIndent = value;
Assert.Equal(value, control.BulletIndent);
Assert.Equal(selectionHangingIndent, control.SelectionHangingIndent);
Assert.True(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(-1)]
public void RichTextBox_BulletIndent_SetInvalidValue_ThrowsArgumentOutOfRangeException(int value)
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("value", () => control.BulletIndent = value);
}
[WinFormsFact]
public void RichTextBox_CanRedo_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.False(control.CanRedo);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> CanRedo_CustomCanRedo_TestData()
{
yield return new object[] { IntPtr.Zero, false };
yield return new object[] { (IntPtr)1, true };
}
[WinFormsTheory]
[MemberData(nameof(CanRedo_CustomCanRedo_TestData))]
public void RichTextBox_CanRedo_CustomCanRedo_ReturnsExpected(IntPtr result, bool expected)
{
using CustomCanRedoRichTextBox control = new()
{
Result = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(expected, control.CanRedo);
}
private class CustomCanRedoRichTextBox : RichTextBox
{
public IntPtr Result { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_CANREDO)
{
m.Result = Result;
return;
}
base.WndProc(ref m);
}
}
[WinFormsFact]
public void RichTextBox_CanRedo_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.False(control.CanRedo);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_CanRedo_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.False(control.CanRedo);
}
[WinFormsFact]
public void RichTextBox_CanUndo_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> CanUndo_CustomCanUndo_TestData()
{
yield return new object[] { IntPtr.Zero, false };
yield return new object[] { (IntPtr)1, true };
}
[WinFormsTheory]
[MemberData(nameof(CanUndo_CustomCanUndo_TestData))]
public void RichTextBox_CanUndo_CustomCanUndo_ReturnsExpected(IntPtr result, bool expected)
{
using CustomCanUndoRichTextBox control = new()
{
Result = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(expected, control.CanUndo);
}
private class CustomCanUndoRichTextBox : RichTextBox
{
public IntPtr Result { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_CANUNDO)
{
m.Result = Result;
return;
}
base.WndProc(ref m);
}
}
[WinFormsFact]
public void RichTextBox_CanUndo_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.False(control.CanUndo);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_CanUndo_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.False(control.CanUndo);
}
[WinFormsFact]
public void RichTextBox_DetectUrls_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.True(control.DetectUrls);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call EM_AUTOURLDETECT.
PInvoke.SendMessage(control, PInvoke.EM_AUTOURLDETECT, 0);
Assert.True(control.DetectUrls);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_DetectUrls_Set_GetReturnsExpected(bool value)
{
using RichTextBox control = new()
{
DetectUrls = value
};
Assert.Equal(value, control.DetectUrls);
Assert.False(control.IsHandleCreated);
// Set same.
control.DetectUrls = value;
Assert.Equal(value, control.DetectUrls);
Assert.False(control.IsHandleCreated);
// Set different.
control.DetectUrls = !value;
Assert.Equal(!value, control.DetectUrls);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(true, 0)]
[InlineData(false, 1)]
public void RichTextBox_DetectUrls_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.DetectUrls = value;
Assert.Equal(value, control.DetectUrls);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
// Set same.
control.DetectUrls = value;
Assert.Equal(value, control.DetectUrls);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
// Set different.
control.DetectUrls = !value;
Assert.Equal(!value, control.DetectUrls);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
}
[WinFormsTheory]
[InlineData(true, 1)]
[InlineData(false, 0)]
public void RichTextBox_DetectUrls_GetAutoUrlDetect_Success(bool value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.DetectUrls = value;
Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETAUTOURLDETECT));
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_EnableAutoDragDrop_Set_GetReturnsExpected(bool value)
{
using RichTextBox control = new()
{
EnableAutoDragDrop = value
};
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.False(control.IsHandleCreated);
// Set same.
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.False(control.IsHandleCreated);
// Set different.
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_EnableAutoDragDrop_SetWithHandle_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_EnableAutoDragDrop_SetWithHandleAlreadyRegistered_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
DropTargetMock dropTarget = new();
Assert.Equal(ApartmentState.STA, Application.OleRequired());
Assert.Equal(HRESULT.DRAGDROP_E_ALREADYREGISTERED, PInvoke.RegisterDragDrop(control, dropTarget));
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[Theory]
[BoolData]
public void RichTextBox_EnableAutoDragDrop_SetWithHandleNonSTAThread_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.EnableAutoDragDrop = value;
Assert.Equal(value, control.EnableAutoDragDrop);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
public void RichTextBox_Font_Set_GetReturnsExpected(Font value)
{
using SubRichTextBox control = new()
{
Font = value
};
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.False(control.IsHandleCreated);
// Set same.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
public void RichTextBox_Font_SetWithText_GetReturnsExpected(Font value)
{
using SubRichTextBox control = new()
{
Text = "text",
Font = value
};
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.False(control.IsHandleCreated);
// Set same.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
public void RichTextBox_Font_SetWithNonNullOldValue_GetReturnsExpected(Font value)
{
using Font oldValue = new("Arial", 1);
using SubRichTextBox control = new()
{
Font = oldValue
};
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.False(control.IsHandleCreated);
// Set same.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
public void RichTextBox_Font_SetWithNonNullOldValueWithText_GetReturnsExpected(Font value)
{
using Font oldValue = new("Arial", 1);
using SubRichTextBox control = new()
{
Font = oldValue,
Text = "text"
};
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.False(control.IsHandleCreated);
// Set same.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> Font_SetWithHandle_TestData()
{
foreach (bool userPaint in new bool[] { true, false })
{
yield return new object[] { userPaint, new Font("Arial", 8.25f), 1 };
yield return new object[] { userPaint, null, 0 };
}
}
[WinFormsTheory]
[MemberData(nameof(Font_SetWithHandle_TestData))]
public void RichTextBox_Font_SetWithHandle_GetReturnsExpected(bool userPaint, Font value, int expectedInvalidatedCallCount)
{
using SubRichTextBox control = new();
control.SetStyle(ControlStyles.UserPaint, userPaint);
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
// Set different.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.True(control.IsHandleCreated);
Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.True(control.IsHandleCreated);
Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(Font_SetWithHandle_TestData))]
public void RichTextBox_Font_SetWithTextWithHandle_GetReturnsExpected(bool userPaint, Font value, int expectedInvalidatedCallCount)
{
using SubRichTextBox control = new()
{
Text = "text"
};
control.SetStyle(ControlStyles.UserPaint, userPaint);
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
// Set different.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.True(control.IsHandleCreated);
Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.True(control.IsHandleCreated);
Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> Font_SetWithNonNullOldValueWithHandle_TestData()
{
foreach (bool userPaint in new bool[] { true, false })
{
yield return new object[] { userPaint, new Font("Arial", 8.25f) };
yield return new object[] { userPaint, null };
}
}
[WinFormsTheory]
[MemberData(nameof(Font_SetWithNonNullOldValueWithHandle_TestData))]
public void RichTextBox_Font_SetWithNonNullOldValueWithHandle_GetReturnsExpected(bool userPaint, Font value)
{
using Font oldValue = new("Arial", 1);
using SubRichTextBox control = new()
{
Font = oldValue
};
control.SetStyle(ControlStyles.UserPaint, userPaint);
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
// Set different.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.True(control.IsHandleCreated);
Assert.Equal(1, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.True(control.IsHandleCreated);
Assert.Equal(1, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(Font_SetWithNonNullOldValueWithHandle_TestData))]
public void RichTextBox_Font_SetWithNonNullOldValueWithTextWithHandle_GetReturnsExpected(bool userPaint, Font value)
{
using Font oldValue = new("Arial", 1);
using SubRichTextBox control = new()
{
Font = oldValue,
Text = "text"
};
control.SetStyle(ControlStyles.UserPaint, userPaint);
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
// Set different.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.True(control.IsHandleCreated);
Assert.Equal(1, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Font = value;
Assert.Equal(value ?? Control.DefaultFont, control.Font);
Assert.Equal(control.Font.Height, control.FontHeight);
Assert.True(control.IsHandleCreated);
Assert.Equal(1, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> Font_GetCharFormat_TestData()
{
yield return new object[] { "Arial", 8.25f, FontStyle.Regular, GraphicsUnit.Point, 1, 165, 0 };
yield return new object[] { "Arial", 8.25f, FontStyle.Bold, GraphicsUnit.Point, 1, 165, CFE_EFFECTS.CFE_BOLD };
yield return new object[] { "Arial", 8.25f, FontStyle.Italic, GraphicsUnit.Point, 1, 165, CFE_EFFECTS.CFE_ITALIC };
yield return new object[] { "Arial", 8.25f, FontStyle.Strikeout, GraphicsUnit.Point, 1, 165, CFE_EFFECTS.CFE_STRIKEOUT };
yield return new object[] { "Arial", 8.25f, FontStyle.Underline, GraphicsUnit.Point, 1, 165, CFE_EFFECTS.CFE_UNDERLINE };
yield return new object[] { "Arial", 8.25f, FontStyle.Bold | FontStyle.Italic | FontStyle.Regular | FontStyle.Strikeout | FontStyle.Underline, GraphicsUnit.Point, 10, 165, CFE_EFFECTS.CFE_BOLD | CFE_EFFECTS.CFE_ITALIC | CFE_EFFECTS.CFE_UNDERLINE | CFE_EFFECTS.CFE_STRIKEOUT };
}
[WinFormsTheory]
[MemberData(nameof(Font_GetCharFormat_TestData))]
public unsafe void RichTextBox_Font_GetCharFormat_Success(string familyName, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet, int expectedYHeight, int expectedEffects)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
var format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W),
dwMask = (CFM_MASK)int.MaxValue
};
nint result;
using (Font font = new(familyName, emSize, style, unit, gdiCharSet))
{
control.Font = font;
result = PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_ALL, ref format);
Assert.NotEqual(0, result);
Assert.Equal(familyName, format.FaceName.ToString());
Assert.Equal(expectedYHeight, format.yHeight);
Assert.Equal(CFE_EFFECTS.CFE_AUTOBACKCOLOR | CFE_EFFECTS.CFE_AUTOCOLOR | (CFE_EFFECTS)expectedEffects, format.dwEffects);
Assert.Equal(0, format.bPitchAndFamily);
// Set null.
control.Font = null;
}
var format1 = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W),
dwMask = (CFM_MASK)int.MaxValue
};
result = PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_ALL, ref format1);
Assert.NotEqual(0, result);
Assert.Equal(Control.DefaultFont.Name, format1.FaceName.ToString());
Assert.Equal((int)(Control.DefaultFont.SizeInPoints * 20), format1.yHeight);
Assert.True(format1.dwEffects.HasFlag(CFE_EFFECTS.CFE_AUTOBACKCOLOR));
Assert.True(format1.dwEffects.HasFlag(CFE_EFFECTS.CFE_AUTOCOLOR));
Assert.Equal(0, format1.bPitchAndFamily);
}
[WinFormsFact]
public void RichTextBox_Font_SetWithHandler_CallsFontChanged()
{
using RichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
callCount++;
};
control.FontChanged += handler;
// Set different.
using Font font1 = new("Arial", 8.25f);
control.Font = font1;
Assert.Same(font1, control.Font);
Assert.Equal(1, callCount);
// Set same.
control.Font = font1;
Assert.Same(font1, control.Font);
Assert.Equal(1, callCount);
// Set different.
using var font2 = SystemFonts.DialogFont;
control.Font = font2;
Assert.Same(font2, control.Font);
Assert.Equal(2, callCount);
// Set null.
control.Font = null;
Assert.Equal(Control.DefaultFont, control.Font);
Assert.Equal(3, callCount);
// Remove handler.
control.FontChanged -= handler;
control.Font = font1;
Assert.Same(font1, control.Font);
Assert.Equal(3, callCount);
}
public static IEnumerable<object[]> ForeColor_Set_TestData()
{
yield return new object[] { Color.Empty, SystemColors.WindowText };
yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
yield return new object[] { Color.White, Color.White };
yield return new object[] { Color.Black, Color.Black };
yield return new object[] { Color.Red, Color.Red };
}
[WinFormsTheory]
[MemberData(nameof(ForeColor_Set_TestData))]
public void RichTextBox_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
{
using RichTextBox control = new()
{
ForeColor = value
};
Assert.Equal(expected, control.ForeColor);
Assert.False(control.IsHandleCreated);
// Set same.
control.ForeColor = value;
Assert.Equal(expected, control.ForeColor);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
{
yield return new object[] { Color.Empty, SystemColors.WindowText, 0 };
yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
yield return new object[] { Color.White, Color.White, 1 };
yield return new object[] { Color.Black, Color.Black, 1 };
yield return new object[] { Color.Red, Color.Red, 1 };
}
[WinFormsTheory]
[MemberData(nameof(ForeColor_SetWithHandle_TestData))]
public void RichTextBox_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.ForeColor = value;
Assert.Equal(expected, control.ForeColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.ForeColor = value;
Assert.Equal(expected, control.ForeColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public unsafe void RichTextBox_ForeColor_GetCharFormat_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.ForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
var format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_ALL, ref format));
Assert.Equal(0x785634, format.crTextColor);
}
[WinFormsFact]
public unsafe void RichTextBox_ForeColor_GetCharFormatWithTextColor_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.ForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
var format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_ALL, ref format));
Assert.Equal(0x785634, format.crTextColor);
// Set different.
control.ForeColor = Color.FromArgb(0x34, 0x56, 0x78, 0x90);
format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_ALL, ref format));
Assert.Equal(0x907856, format.crTextColor);
}
[WinFormsFact]
public void RichTextBox_ForeColor_SetWithHandler_CallsForeColorChanged()
{
using RichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
callCount++;
};
control.ForeColorChanged += handler;
// Set different.
control.ForeColor = Color.Red;
Assert.Equal(Color.Red, control.ForeColor);
Assert.Equal(1, callCount);
// Set same.
control.ForeColor = Color.Red;
Assert.Equal(Color.Red, control.ForeColor);
Assert.Equal(1, callCount);
// Set different.
control.ForeColor = Color.Empty;
Assert.Equal(SystemColors.WindowText, control.ForeColor);
Assert.Equal(2, callCount);
// Remove handler.
control.ForeColorChanged -= handler;
control.ForeColor = Color.Red;
Assert.Equal(Color.Red, control.ForeColor);
Assert.Equal(2, callCount);
}
public static IEnumerable<object[]> LanguageOption_CustomGetLangOptions_TestData()
{
foreach (RichTextBoxLanguageOptions options in Enum.GetValues(typeof(RichTextBoxLanguageOptions)))
{
yield return new object[] { (IntPtr)options, options };
}
yield return new object[] { IntPtr.Zero, 0 };
yield return new object[] { (IntPtr)(-1), -1 };
}
[WinFormsTheory]
[MemberData(nameof(LanguageOption_CustomGetLangOptions_TestData))]
public void RichTextBox_LanguageOption_CustomGetLangOptions_ReturnsExpected(IntPtr result, RichTextBoxLanguageOptions expected)
{
using CustomGetLangOptionsRichTextBox control = new()
{
GetLangOptionsResult = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.LanguageOption);
}
private class CustomGetLangOptionsRichTextBox : RichTextBox
{
public bool MakeCustom { get; set; }
public IntPtr GetLangOptionsResult { get; set; }
protected override void WndProc(ref Message m)
{
if (MakeCustom && m.Msg == (int)PInvoke.EM_GETLANGOPTIONS)
{
m.Result = GetLangOptionsResult;
return;
}
base.WndProc(ref m);
}
}
[WinFormsTheory]
[EnumData<RichTextBoxLanguageOptions>]
public void RichTextBox_LanguageOption_Set_GetReturnsExpected(RichTextBoxLanguageOptions value)
{
using RichTextBox control = new()
{
LanguageOption = value
};
Assert.Equal(value, control.LanguageOption);
Assert.False(control.IsHandleCreated);
// Set same.
control.LanguageOption = value;
Assert.Equal(value, control.LanguageOption);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[EnumData<RichTextBoxLanguageOptions>]
public void RichTextBox_LanguageOption_SetWithHandle_GetReturnsExpected(RichTextBoxLanguageOptions value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.LanguageOption = value;
Assert.Equal(value, control.LanguageOption);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.LanguageOption = value;
Assert.Equal(value, control.LanguageOption);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[EnumData<RichTextBoxLanguageOptions>]
public unsafe void RichTextBox_LanguageOption_GetCharFormat_Success(RichTextBoxLanguageOptions value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.LanguageOption = value;
Assert.Equal(value, (RichTextBoxLanguageOptions)(int)PInvoke.SendMessage(control, PInvoke.EM_GETLANGOPTIONS));
}
[WinFormsFact]
public void RichTextBox_MaxLength_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0x7FFFFFFF, control.MaxLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call EM_LIMITTEXT.
PInvoke.SendMessage(control, PInvoke.EM_LIMITTEXT, 0, 1);
Assert.Equal(0x7FFFFFFF, control.MaxLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call EM_EXLIMITTEXT.
PInvoke.SendMessage(control, PInvoke.EM_EXLIMITTEXT, 0, 2);
Assert.Equal(0x7FFFFFFF, control.MaxLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
[InlineData(64000)]
[InlineData(0x7FFFFFFE)]
[InlineData(int.MaxValue)]
public void RichTextBox_MaxLength_Set_GetReturnsExpected(int value)
{
using RichTextBox control = new()
{
MaxLength = value
};
Assert.Equal(value, control.MaxLength);
Assert.False(control.IsHandleCreated);
// Set same.
control.MaxLength = value;
Assert.Equal(value, control.MaxLength);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_MaxLength_SetWithLongText_Success()
{
using RichTextBox control = new()
{
Text = "Text",
MaxLength = 2
};
Assert.Equal(2, control.MaxLength);
Assert.Equal("Text", control.Text);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
[InlineData(64000)]
[InlineData(0x7FFFFFFE)]
[InlineData(int.MaxValue)]
public void RichTextBox_MaxLength_SetWithHandle_GetReturnsExpected(int value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.MaxLength = value;
Assert.Equal(value, control.MaxLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.MaxLength = value;
Assert.Equal(value, control.MaxLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_MaxLength_SetWithLongTextWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.Text = "Text";
control.MaxLength = 2;
Assert.Equal(2, control.MaxLength);
Assert.Equal("Text", control.Text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0, 0x10000)]
[InlineData(1, 1)]
[InlineData(64000, 64000)]
[InlineData(0x7FFFFFFE, 0x7FFFFFFE)]
[InlineData(int.MaxValue, 0x7FFFFFFF)]
public void RichTextBox_MaxLength_GetLimitText_Success(int value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MaxLength = value;
Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETLIMITTEXT));
}
[WinFormsFact]
public void RichTextBox_MaxLength_SetNegative_ThrowsArgumentOutOfRangeException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("value", () => control.MaxLength = -1);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_Multiline_Set_GetReturnsExpected(bool value)
{
using SubRichTextBox control = new()
{
AutoSize = false,
Multiline = value
};
Assert.Equal(value, control.Multiline);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.AutoSize);
Assert.False(control.IsHandleCreated);
// Set same.
control.Multiline = value;
Assert.Equal(value, control.Multiline);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.AutoSize);
Assert.False(control.IsHandleCreated);
// Set different.
control.Multiline = !value;
Assert.Equal(!value, control.Multiline);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.AutoSize);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> Multiline_SetAutoSize_TestData()
{
yield return new object[] { true, 96, s_preferredHeight };
yield return new object[] { false, s_preferredHeight, 96 };
}
[WinFormsTheory]
[MemberData(nameof(Multiline_SetAutoSize_TestData))]
public void RichTextBox_Multiline_SetAutoSize_GetReturnsExpected(bool value, int expectedHeight1, int expectedHeight2)
{
using SubRichTextBox control = new()
{
AutoSize = true,
Multiline = value
};
Assert.Equal(value, control.Multiline);
Assert.Equal(expectedHeight1, control.Height);
Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.AutoSize);
Assert.False(control.IsHandleCreated);
// Set same.
control.Multiline = value;
Assert.Equal(value, control.Multiline);
Assert.Equal(expectedHeight1, control.Height);
Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.AutoSize);
Assert.False(control.IsHandleCreated);
// Set different.
control.Multiline = !value;
Assert.Equal(!value, control.Multiline);
Assert.Equal(expectedHeight2, control.Height);
Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.AutoSize);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_Multiline_SetWithParent_GetReturnsExpected(bool value)
{
using Control parent = new();
using SubRichTextBox control = new()
{
Parent = parent
};
int parentLayoutCallCount = 0;
void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
parent.Layout += parentHandler;
try
{
control.Multiline = value;
Assert.Equal(value, control.Multiline);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.AutoSize);
Assert.Equal(0, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
// Set same.
control.Multiline = value;
Assert.Equal(value, control.Multiline);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.AutoSize);
Assert.Equal(0, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
// Set different.
control.Multiline = !value;
Assert.Equal(!value, control.Multiline);
Assert.Equal(96, control.Height);
Assert.False(control.GetStyle(ControlStyles.FixedHeight));
Assert.False(control.AutoSize);
Assert.Equal(0, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
}
finally
{
parent.Layout -= parentHandler;
}
}
public static IEnumerable<object[]> Multiline_SetAutoSizeWithParent_TestData()
{
yield return new object[] { true, 96, 0, s_preferredHeight };
yield return new object[] { false, s_preferredHeight, 1, 96 };
}
[WinFormsTheory]
[MemberData(nameof(Multiline_SetAutoSizeWithParent_TestData))]
public void RichTextBox_Multiline_SetAutoSizeWithParent_GetReturnsExpected(bool value, int expectedHeight1, int expectedParentLayoutCallCount, int expectedHeight2)
{
using Control parent = new();
using SubRichTextBox control = new()
{
AutoSize = true,
Parent = parent
};
int parentLayoutCallCount = 0;
void parentHandler(object sender, LayoutEventArgs e)
{
Assert.Same(parent, sender);
Assert.Same(control, e.AffectedControl);
Assert.Equal("Bounds", e.AffectedProperty);
parentLayoutCallCount++;
}
parent.Layout += parentHandler;
try
{
control.Multiline = value;
Assert.Equal(value, control.Multiline);
Assert.Equal(expectedHeight1, control.Height);
Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.AutoSize);
Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
// Set same.
control.Multiline = value;
Assert.Equal(value, control.Multiline);
Assert.Equal(expectedHeight1, control.Height);
Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.AutoSize);
Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
// Set different.
control.Multiline = !value;
Assert.Equal(!value, control.Multiline);
Assert.Equal(expectedHeight2, control.Height);
Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
Assert.True(control.AutoSize);
Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
Assert.False(parent.IsHandleCreated);
}
finally
{
parent.Layout -= parentHandler;
}
}
[WinFormsTheory]
[InlineData(true, 0)]
[InlineData(false, 1)]
public void RichTextBox_Multiline_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.Multiline = value;
Assert.Equal(value, control.Multiline);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
// Set same.
control.Multiline = value;
Assert.Equal(value, control.Multiline);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
// Set different.
control.Multiline = !value;
Assert.Equal(!value, control.Multiline);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_Multiline_SetWithHandler_CallsMultilineChanged()
{
using RichTextBox control = new()
{
Multiline = true
};
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
callCount++;
};
control.MultilineChanged += handler;
// Set different.
control.Multiline = false;
Assert.False(control.Multiline);
Assert.Equal(1, callCount);
// Set same.
control.Multiline = false;
Assert.False(control.Multiline);
Assert.Equal(1, callCount);
// Set different.
control.Multiline = true;
Assert.True(control.Multiline);
Assert.Equal(2, callCount);
// Remove handler.
control.MultilineChanged -= handler;
control.Multiline = false;
Assert.False(control.Multiline);
Assert.Equal(2, callCount);
}
[WinFormsFact]
public void RichTextBox_RedoActionName_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Empty(control.RedoActionName);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> RedoActionName_CustomGetRedoName_TestData()
{
yield return new object[] { IntPtr.Zero, IntPtr.Zero, string.Empty };
yield return new object[] { (IntPtr)1, IntPtr.Zero, "Unknown" };
yield return new object[] { (IntPtr)1, (IntPtr)1, "Typing" };
yield return new object[] { (IntPtr)1, (IntPtr)2, "Delete" };
yield return new object[] { (IntPtr)1, (IntPtr)3, "Drag and Drop" };
yield return new object[] { (IntPtr)1, (IntPtr)4, "Cut" };
yield return new object[] { (IntPtr)1, (IntPtr)5, "Paste" };
yield return new object[] { (IntPtr)1, (IntPtr)6, "Unknown" };
yield return new object[] { (IntPtr)1, (IntPtr)7, "Unknown" };
}
[WinFormsTheory]
[MemberData(nameof(RedoActionName_CustomGetRedoName_TestData))]
public void RichTextBox_RedoActionName_CustomGetRedoName_ReturnsExpected(IntPtr canRedoResult, IntPtr getRedoNameResult, string expected)
{
using CustomGetRedoNameRichTextBox control = new()
{
CanRedoResult = canRedoResult,
GetRedoNameResult = getRedoNameResult
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(expected, control.RedoActionName);
}
private class CustomGetRedoNameRichTextBox : RichTextBox
{
public IntPtr CanRedoResult { get; set; }
public IntPtr GetRedoNameResult { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_CANREDO)
{
m.Result = CanRedoResult;
return;
}
else if (m.Msg == (int)PInvoke.EM_GETREDONAME)
{
m.Result = GetRedoNameResult;
return;
}
base.WndProc(ref m);
}
}
[WinFormsFact]
public void RichTextBox_RedoActionName_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Empty(control.RedoActionName);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_RedoActionName_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Empty(control.RedoActionName);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_RichTextShortcutsEnabled_Set_GetReturnsExpected(bool value)
{
using RichTextBox control = new()
{
RichTextShortcutsEnabled = value
};
Assert.Equal(value, control.RichTextShortcutsEnabled);
Assert.False(control.IsHandleCreated);
// Set same.
control.RichTextShortcutsEnabled = value;
Assert.Equal(value, control.RichTextShortcutsEnabled);
Assert.False(control.IsHandleCreated);
// Set different.
control.RichTextShortcutsEnabled = !value;
Assert.Equal(!value, control.RichTextShortcutsEnabled);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_RichTextShortcutsEnabled_SetWithHandle_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.RichTextShortcutsEnabled = value;
Assert.Equal(value, control.RichTextShortcutsEnabled);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.RichTextShortcutsEnabled = value;
Assert.Equal(value, control.RichTextShortcutsEnabled);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.RichTextShortcutsEnabled = !value;
Assert.Equal(!value, control.RichTextShortcutsEnabled);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_RightMargin_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.RightMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
[InlineData(64000)]
[InlineData(0x7FFFFFFE)]
[InlineData(int.MaxValue)]
public void RichTextBox_RightMargin_Set_GetReturnsExpected(int value)
{
using RichTextBox control = new()
{
RightMargin = value
};
Assert.Equal(value, control.RightMargin);
Assert.False(control.IsHandleCreated);
// Set same.
control.RightMargin = value;
Assert.Equal(value, control.RightMargin);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
[InlineData(64000)]
[InlineData(0x7FFFFFFE)]
[InlineData(int.MaxValue)]
public void RichTextBox_RightMargin_SetWithCustomOldValue_GetReturnsExpected(int value)
{
using RichTextBox control = new()
{
RightMargin = 1
};
control.RightMargin = value;
Assert.Equal(value, control.RightMargin);
Assert.False(control.IsHandleCreated);
// Set same.
control.RightMargin = value;
Assert.Equal(value, control.RightMargin);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
[InlineData(64000)]
[InlineData(0x7FFFFFFE)]
[InlineData(int.MaxValue)]
public void RichTextBox_RightMargin_SetWithHandle_GetReturnsExpected(int value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.RightMargin = value;
Assert.Equal(value, control.RightMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.RightMargin = value;
Assert.Equal(value, control.RightMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0, 1)]
[InlineData(1, 0)]
[InlineData(64000, 0)]
[InlineData(0x7FFFFFFE, 0)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_RightMargin_SetWithCustomOldValueWithHandle_GetReturnsExpected(int value, int expectedCreatedCallCount)
{
using RichTextBox control = new()
{
RightMargin = 1
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.RightMargin = value;
Assert.Equal(value, control.RightMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
// Set same.
control.RightMargin = value;
Assert.Equal(value, control.RightMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_RightMargin_SetNegative_ThrowsArgumentOutOfRangeException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("value", () => control.RightMargin = -1);
}
[WinFormsFact]
public void RichTextBox_Rtf_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
string rtf1 = control.Rtf;
Assert.StartsWith("{\\rtf", rtf1);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Get again.
string rtf2 = control.Rtf;
Assert.Equal(rtf1, rtf2);
Assert.NotSame(rtf1, rtf2);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_Rtf_GetWithPlainText_ReturnsExpected()
{
using RichTextBox control = new()
{
Text = "Text"
};
string rtf1 = control.Rtf;
Assert.Contains("Text", rtf1);
Assert.StartsWith("{\\rtf", rtf1);
Assert.True(control.IsHandleCreated);
// Get again.
string rtf2 = control.Rtf;
Assert.Equal(rtf1, rtf2);
Assert.NotSame(rtf1, rtf2);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_Rtf_GetWithPlainTextWithHandle_ReturnsExpected()
{
using RichTextBox control = new()
{
Text = "Text"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
string rtf1 = control.Rtf;
Assert.Contains("Text", rtf1);
Assert.StartsWith("{\\rtf", rtf1);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Get again.
string rtf2 = control.Rtf;
Assert.Equal(rtf1, rtf2);
Assert.NotSame(rtf1, rtf2);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_Rtf_GetCantCreateHandle_ReturnsNull()
{
using CantCreateHandleRichTextBox control = new();
Assert.Null(control.Rtf);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_Rtf_GetDisposed_ReturnsNull()
{
using RichTextBox control = new();
control.Dispose();
Assert.Null(control.Rtf);
}
[WinFormsFact]
public void RichTextBox_Rtf_GetDisposedWithText_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
control.Text = "text";
Assert.Throws<ObjectDisposedException>(() => control.Rtf);
}
[WinFormsTheory]
[NullAndEmptyStringData]
public void RichTextBox_Rtf_Set_GetReturnsExpected(string nullOrEmpty)
{
using RichTextBox control = new()
{
Rtf = "{\\rtf1Hello World}"
};
string rtf = control.Rtf;
Assert.StartsWith("{\\rtf", rtf);
Assert.NotSame(rtf, control.Rtf);
Assert.Equal("Hello World", control.Text);
Assert.True(control.IsHandleCreated);
control.Rtf = nullOrEmpty;
rtf = control.Rtf;
Assert.StartsWith("{\\rtf", rtf);
Assert.Empty(control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData("{\\rtf1Hello World}", "Hello World")]
[InlineData(@"{\rtf1\ansi{Sample for {\v HIDDEN }text}}", "Sample for HIDDEN text")]
public void RichTextBox_Rtf_Set_GetTextExpected(string rtf, string plainText)
{
using RichTextBox control = new()
{
Rtf = rtf
};
string readRtf = control.Rtf;
Assert.StartsWith("{\\rtf", readRtf);
Assert.NotSame(readRtf, control.Rtf);
Assert.Equal(plainText, control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[NullAndEmptyStringData]
public void RichTextBox_Rtf_SetWithHandle_GetReturnsExpected(string nullOrEmpty)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.Rtf = "{\\rtf1Hello World}";
string rtf = control.Rtf;
Assert.StartsWith("{\\rtf", rtf);
Assert.NotSame(rtf, control.Rtf);
Assert.Equal("Hello World", control.Text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
control.Rtf = nullOrEmpty;
rtf = control.Rtf;
Assert.StartsWith("{\\rtf", rtf);
Assert.Empty(control.Text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_Rtf_SetWithHandler_CallsTextChanged()
{
using RichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Equal(EventArgs.Empty, e);
callCount++;
};
control.TextChanged += handler;
// Set different.
control.Rtf = "{\\rtf1text}";
Assert.Equal("text", control.Text);
Assert.Equal(2, callCount);
// Set same.
control.Rtf = "{\\rtf1text}";
Assert.Equal("text", control.Text);
Assert.Equal(4, callCount);
// Set different.
control.Text = null;
Assert.Empty(control.Text);
Assert.Equal(5, callCount);
// Remove handler.
control.TextChanged -= handler;
control.Rtf = "{\\rtf1text}";
Assert.Equal("text", control.Text);
Assert.Equal(5, callCount);
}
[WinFormsFact]
public void RichTextBox_Rtf_SetWithHandlerWithHandle_CallsTextChanged()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Equal(EventArgs.Empty, e);
callCount++;
};
control.TextChanged += handler;
// Set different.
control.Rtf = "{\\rtf1text}";
Assert.Equal("text", control.Text);
Assert.Equal(2, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Rtf = "{\\rtf1text}";
Assert.Equal("text", control.Text);
Assert.Equal(4, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.Rtf = null;
Assert.Empty(control.Text);
Assert.Equal(6, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Remove handler.
control.TextChanged -= handler;
control.Rtf = "{\\rtf1text}";
Assert.Equal("text", control.Text);
Assert.Equal(6, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_Rtf_SetInvalidValue_ThrowsArgumentException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentException>(() => control.Rtf = "text");
Assert.True(control.IsHandleCreated);
Assert.DoesNotContain("text", control.Rtf);
Assert.Empty(control.Text);
}
[WinFormsTheory]
[InlineData(null, "")]
[InlineData("", "")]
[InlineData("{\\rtf Hello World}", "{\\rtf Hello World}")]
public void RichTextBox_Rtf_SetCantCreateHandle_GetReturnsExpected(string value, string expected)
{
using CantCreateHandleRichTextBox control = new();
control.Rtf = value;
Assert.Equal(expected, control.Rtf);
Assert.False(control.IsHandleCreated);
// Set same.
control.Rtf = value;
Assert.Equal(expected, control.Rtf);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[StringWithNullData]
public void RichTextBox_Rtf_SetDisposed_ThrowsObjectDisposedException(string value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.Rtf = value);
}
public static IEnumerable<object[]> ScrollBars_Set_TestData()
{
foreach (bool autoSize in new bool[] { true, false })
{
foreach (RichTextBoxScrollBars value in Enum.GetValues(typeof(RichTextBoxScrollBars)))
{
yield return new object[] { autoSize, value };
}
}
}
[WinFormsTheory]
[MemberData(nameof(ScrollBars_Set_TestData))]
public void RichTextBox_ScrollBars_Set_GetReturnsExpected(bool autoSize, RichTextBoxScrollBars value)
{
using RichTextBox control = new()
{
AutoSize = autoSize
};
int layoutCallCount = 0;
control.Layout += (sender, e) => layoutCallCount++;
control.ScrollBars = value;
Assert.Equal(value, control.ScrollBars);
Assert.Equal(autoSize, control.AutoSize);
Assert.Equal(0, layoutCallCount);
Assert.False(control.IsHandleCreated);
// Set same.
control.ScrollBars = value;
Assert.Equal(value, control.ScrollBars);
Assert.Equal(autoSize, control.AutoSize);
Assert.Equal(0, layoutCallCount);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> ScrollBars_SetWithParent_TestData()
{
yield return new object[] { false, RichTextBoxScrollBars.Both, 0 };
yield return new object[] { false, RichTextBoxScrollBars.ForcedBoth, 0 };
yield return new object[] { false, RichTextBoxScrollBars.ForcedHorizontal, 0 };
yield return new object[] { false, RichTextBoxScrollBars.ForcedVertical, 0 };
yield return new object[] { false, RichTextBoxScrollBars.Horizontal, 0 };
yield return new object[] { false, RichTextBoxScrollBars.None, 0 };
yield return new object[] { false, RichTextBoxScrollBars.Vertical, 0 };
yield return new object[] { true, RichTextBoxScrollBars.Both, 0 };
yield return new object[] { true, RichTextBoxScrollBars.ForcedBoth, 1 };
yield return new object[] { true, RichTextBoxScrollBars.ForcedHorizontal, 1 };
yield return new object[] { true, RichTextBoxScrollBars.ForcedVertical, 1 };
yield return new object[] { true, RichTextBoxScrollBars.Horizontal, 1 };
yield return new object[] { true, RichTextBoxScrollBars.None, 1 };
yield return new object[] { true, RichTextBoxScrollBars.Vertical, 1 };
}
[WinFormsTheory]
[MemberData(nameof(ScrollBars_SetWithParent_TestData))]
public void RichTextBox_ScrollBars_SetWithParent_GetReturnsExpected(bool autoSize, RichTextBoxScrollBars value, int expectedParentLayoutCallCount)
{
using Control parent = new();
using RichTextBox control = new()
{
AutoSize = autoSize,
Parent = parent
};
int layoutCallCount = 0;
control.Layout += (sender, e) => layoutCallCount++;
int parentLayoutCallCount = 0;
void parentHandler(object sender, LayoutEventArgs e)
{
Assert.Same(parent, sender);
Assert.Same(control, e.AffectedControl);
Assert.Equal("ScrollBars", e.AffectedProperty);
parentLayoutCallCount++;
}
parent.Layout += parentHandler;
try
{
control.ScrollBars = value;
Assert.Equal(value, control.ScrollBars);
Assert.Equal(autoSize, control.AutoSize);
Assert.Equal(0, layoutCallCount);
Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
// Set same.
control.ScrollBars = value;
Assert.Equal(value, control.ScrollBars);
Assert.Equal(autoSize, control.AutoSize);
Assert.Equal(0, layoutCallCount);
Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
}
finally
{
parent.Layout -= parentHandler;
}
}
public static IEnumerable<object[]> ScrollBars_SetWithHandle_TestData()
{
foreach (bool autoSize in new bool[] { true, false })
{
yield return new object[] { autoSize, RichTextBoxScrollBars.Both, 0, 0 };
yield return new object[] { autoSize, RichTextBoxScrollBars.ForcedBoth, 1, 1 };
yield return new object[] { autoSize, RichTextBoxScrollBars.ForcedHorizontal, 0, 1 };
yield return new object[] { autoSize, RichTextBoxScrollBars.ForcedVertical, 1, 1 };
yield return new object[] { autoSize, RichTextBoxScrollBars.Horizontal, 0, 1 };
yield return new object[] { autoSize, RichTextBoxScrollBars.None, 0, 1 };
yield return new object[] { autoSize, RichTextBoxScrollBars.Vertical, 0, 1 };
}
}
[WinFormsTheory]
[MemberData(nameof(ScrollBars_SetWithHandle_TestData))]
public void RichTextBox_ScrollBars_SetWithHandle_GetReturnsExpected(bool autoSize, RichTextBoxScrollBars value, int expectedLayoutCallCount, int expectedCreatedCallCount)
{
using RichTextBox control = new()
{
AutoSize = autoSize
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int layoutCallCount = 0;
control.Layout += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(control, e.AffectedControl);
Assert.Equal("Bounds", e.AffectedProperty);
layoutCallCount++;
};
control.ScrollBars = value;
Assert.Equal(value, control.ScrollBars);
Assert.Equal(autoSize, control.AutoSize);
Assert.Equal(expectedLayoutCallCount, layoutCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
// Set same.
control.ScrollBars = value;
Assert.Equal(value, control.ScrollBars);
Assert.Equal(autoSize, control.AutoSize);
Assert.Equal(expectedLayoutCallCount, layoutCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
}
public static IEnumerable<object[]> ScrollBars_SetWithParentWithHandle_TestData()
{
yield return new object[] { false, RichTextBoxScrollBars.Both, 0, 0, 0 };
yield return new object[] { false, RichTextBoxScrollBars.ForcedBoth, 1, 1, 1 };
yield return new object[] { false, RichTextBoxScrollBars.ForcedHorizontal, 0, 0, 1 };
yield return new object[] { false, RichTextBoxScrollBars.ForcedVertical, 1, 1, 1 };
yield return new object[] { false, RichTextBoxScrollBars.Horizontal, 0, 0, 1 };
yield return new object[] { false, RichTextBoxScrollBars.None, 0, 0, 1 };
yield return new object[] { false, RichTextBoxScrollBars.Vertical, 0, 0, 1 };
yield return new object[] { true, RichTextBoxScrollBars.Both, 0, 0, 0 };
yield return new object[] { true, RichTextBoxScrollBars.ForcedBoth, 1, 1, 1 };
yield return new object[] { true, RichTextBoxScrollBars.ForcedHorizontal, 0, 1, 1 };
yield return new object[] { true, RichTextBoxScrollBars.ForcedVertical, 1, 1, 1 };
yield return new object[] { true, RichTextBoxScrollBars.Horizontal, 0, 1, 1 };
yield return new object[] { true, RichTextBoxScrollBars.None, 0, 1, 1 };
yield return new object[] { true, RichTextBoxScrollBars.Vertical, 0, 1, 1 };
}
[WinFormsTheory]
[MemberData(nameof(ScrollBars_SetWithParentWithHandle_TestData))]
public void RichTextBox_ScrollBars_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, RichTextBoxScrollBars value, int expectedLayoutCallCount, int expectedParentLayoutCallCount, int expectedCreatedCallCount)
{
using Control parent = new();
using RichTextBox control = new()
{
AutoSize = autoSize,
Parent = parent
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int layoutCallCount = 0;
control.Layout += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(control, e.AffectedControl);
Assert.Equal("Bounds", e.AffectedProperty);
layoutCallCount++;
};
int parentLayoutCallCount = 0;
void parentHandler(object sender, LayoutEventArgs e)
{
Assert.Same(parent, sender);
Assert.Same(control, e.AffectedControl);
parentLayoutCallCount++;
}
parent.Layout += parentHandler;
try
{
control.ScrollBars = value;
Assert.Equal(value, control.ScrollBars);
Assert.Equal(autoSize, control.AutoSize);
Assert.Equal(expectedLayoutCallCount, layoutCallCount);
Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
// Set same.
control.ScrollBars = value;
Assert.Equal(value, control.ScrollBars);
Assert.Equal(autoSize, control.AutoSize);
Assert.Equal(expectedLayoutCallCount, layoutCallCount);
Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(expectedCreatedCallCount, createdCallCount);
}
finally
{
parent.Layout -= parentHandler;
}
}
[WinFormsTheory]
[InvalidEnumData<RichTextBoxScrollBars>]
[InlineData(RichTextBoxScrollBars.Both + 1)]
[InlineData(RichTextBoxScrollBars.ForcedHorizontal - 1)]
public void RichTextBox_ScrollBars_SetInvalidValue_ThrowsInvalidEnumArgumentException(RichTextBoxScrollBars value)
{
using RichTextBox control = new();
Assert.Throws<InvalidEnumArgumentException>("value", () => control.ScrollBars = value);
}
[WinFormsFact]
public void RichTextBox_SelectedRtf_Get_ReturnsExpected()
{
using RichTextBox control = new();
string rtf1 = control.SelectedRtf;
Assert.Empty(rtf1);
Assert.True(control.IsHandleCreated);
// Get again.
string rtf2 = control.SelectedRtf;
Assert.Equal(rtf1, rtf2);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectedRtf_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
string rtf1 = control.SelectedRtf;
Assert.Empty(rtf1);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Get again.
string rtf2 = control.SelectedRtf;
Assert.Equal(rtf1, rtf2);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SelectedRtf_GetWithPlainText_ReturnsExpected()
{
using RichTextBox control = new()
{
Text = "Text",
SelectedText = "ex"
};
string rtf1 = control.SelectedRtf;
Assert.Empty(rtf1);
Assert.True(control.IsHandleCreated);
// Get again.
string rtf2 = control.SelectedRtf;
Assert.Equal(rtf1, rtf2);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectedRtf_GetWithPlainTextWithHandle_ReturnsExpected()
{
using RichTextBox control = new()
{
Text = "Text",
SelectedText = "ex"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
string rtf1 = control.SelectedRtf;
Assert.Empty(rtf1);
Assert.DoesNotContain("ex", rtf1);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Get again.
string rtf2 = control.SelectedRtf;
Assert.Equal(rtf1, rtf2);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SelectedRtf_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Empty(control.SelectedRtf);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectedRtf_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectedRtf);
}
[WinFormsTheory]
[NullAndEmptyStringData]
public void RichTextBox_SelectedRtf_Set_GetReturnsExpected(string nullOrEmpty)
{
using RichTextBox control = new()
{
SelectedRtf = "{\\rtf1Hell}"
};
string rtf = control.SelectedRtf;
Assert.Empty(rtf);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
control.SelectedRtf = nullOrEmpty;
rtf = control.SelectedRtf;
Assert.Empty(rtf);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[NullAndEmptyStringData]
public void RichTextBox_SelectedRtf_SetWithHandle_GetReturnsExpected(string nullOrEmpty)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectedRtf = "{\\rtf1Hell}";
string rtf = control.SelectedRtf;
Assert.Empty(rtf);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
control.SelectedRtf = nullOrEmpty;
rtf = control.SelectedRtf;
Assert.Empty(rtf);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[NullAndEmptyStringData]
public void RichTextBox_SelectedRtf_SetWithRtf_GetReturnsExpected(string nullOrEmpty)
{
using RichTextBox control = new()
{
Rtf = "{\\rtf1Hello World}",
SelectedRtf = "{\\rtf1Hell}"
};
string rtf = control.SelectedRtf;
Assert.Empty(rtf);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
control.SelectedRtf = nullOrEmpty;
rtf = control.SelectedRtf;
Assert.Empty(rtf);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[NullAndEmptyStringData]
public void RichTextBox_SelectedRtf_SetWithRtfWithHandle_GetReturnsExpected(string nullOrEmpty)
{
using RichTextBox control = new()
{
Rtf = "{\\rtf1Hello World}"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectedRtf = "{\\rtf1Hell}";
string rtf = control.SelectedRtf;
Assert.Empty(rtf);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
control.SelectedRtf = nullOrEmpty;
rtf = control.SelectedRtf;
Assert.Empty(rtf);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SelectedRtf_SetInvalidValue_ThrowsArgumentException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentException>(() => control.SelectedRtf = "text");
Assert.True(control.IsHandleCreated);
Assert.DoesNotContain("text", control.Rtf);
Assert.Empty(control.Text);
}
[WinFormsTheory]
[InlineData(null)]
[InlineData("")]
[InlineData("{\\rtf Hello World}")]
public void RichTextBox_SelectedRtf_SetCantCreateHandle_GetReturnsExpected(string value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectedRtf = value;
Assert.Empty(control.SelectedRtf);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectedRtf = value;
Assert.Empty(control.SelectedRtf);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[StringWithNullData]
public void RichTextBox_SelectedRtf_SetDisposed_ThrowsObjectDisposedException(string value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectedRtf = value);
}
[WinFormsFact]
public void RichTextBox_SelectedText_Get_ReturnsExpected()
{
using RichTextBox control = new();
string text1 = control.SelectedText;
Assert.Empty(text1);
Assert.True(control.IsHandleCreated);
// Get again.
string text2 = control.SelectedText;
Assert.Equal(text1, text2);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectedText_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
string text1 = control.SelectedText;
Assert.Empty(text1);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Get again.
string text2 = control.SelectedText;
Assert.Equal(text1, text2);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SelectedText_GetWithPlainText_ReturnsExpected()
{
using RichTextBox control = new()
{
Text = "Text",
SelectedText = "ex"
};
string text1 = control.SelectedText;
Assert.Empty(text1);
Assert.True(control.IsHandleCreated);
// Get again.
string text2 = control.SelectedText;
Assert.Equal(text1, text2);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectedText_GetWithPlainTextWithHandle_ReturnsExpected()
{
using RichTextBox control = new()
{
Text = "Text",
SelectedText = "ex"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
string text1 = control.SelectedText;
Assert.Empty(text1);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Get again.
string text2 = control.SelectedText;
Assert.Equal(text1, text2);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SelectedText_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectedText);
}
[WinFormsTheory]
[StringData]
public void RichTextBox_SelectedText_Set_GetReturnsExpected(string value)
{
using RichTextBox control = new()
{
SelectedText = value
};
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectedText = value;
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[StringData]
public void RichTextBox_SelectedText_SetWithHandle_GetReturnsExpected(string value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectedText = value;
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectedText = value;
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[StringData]
public void RichTextBox_SelectedText_SetWithRtf_GetReturnsExpected(string value)
{
using RichTextBox control = new()
{
Rtf = "{\\rtf1Hello World}",
SelectedText = value
};
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectedText = value;
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[StringData]
public void RichTextBox_SelectedText_SetWithText_GetReturnsExpected(string value)
{
using RichTextBox control = new()
{
Text = "Hello World",
SelectedText = value
};
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectedText = value;
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[StringData]
public void RichTextBox_SelectedText_SetWithTextWithHandle_GetReturnsExpected(string value)
{
using RichTextBox control = new()
{
Text = "Hello World"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectedText = value;
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectedText = value;
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[StringWithNullData]
public void RichTextBox_SelectedText_SetDisposed_ThrowsObjectDisposedException(string value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectedText = value);
}
[WinFormsFact]
public void RichTextBox_SelectionAlignment_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionAlignment_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionAlignment_CustomGetParamFormat_TestData()
{
yield return new object[] { 0, 0, HorizontalAlignment.Left };
yield return new object[] { 0, PFA.CENTER, HorizontalAlignment.Left };
yield return new object[] { PFM.ALIGNMENT, PFA.LEFT, HorizontalAlignment.Left };
yield return new object[] { PFM.ALIGNMENT, PFA.CENTER, HorizontalAlignment.Center };
yield return new object[] { PFM.ALIGNMENT, PFA.RIGHT, HorizontalAlignment.Right };
yield return new object[] { PFM.ALIGNMENT, PFA.JUSTIFY, HorizontalAlignment.Left };
yield return new object[] { PFM.ALIGNMENT, PFA.FULL_INTERWORD, HorizontalAlignment.Left };
yield return new object[] { PFM.ALIGNMENT | PFM.ALIGNMENT, PFA.CENTER, HorizontalAlignment.Center };
yield return new object[] { PFM.NUMBERING, PFA.CENTER, HorizontalAlignment.Left };
}
[WinFormsTheory]
[MemberData(nameof(SelectionAlignment_CustomGetParamFormat_TestData))]
public void RichTextBox_SelectionAlignment_CustomGetParaFormat_ReturnsExpected(uint mask, uint alignment, HorizontalAlignment expected)
{
using CustomGetParaFormatRichTextBox control = new()
{
GetParaFormatResult = new PARAFORMAT
{
dwMask = (PFM)mask,
wAlignment = (PFA)alignment
}
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionAlignment);
}
[WinFormsFact]
public void RichTextBox_SelectionAlignment_GetCantCreateHandle_ReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionAlignment_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionAlignment);
}
[WinFormsTheory]
[EnumData<HorizontalAlignment>]
public void RichTextBox_SelectionAlignment_Set_GetReturnsExpected(HorizontalAlignment value)
{
using RichTextBox control = new()
{
SelectionAlignment = value
};
Assert.Equal(value, control.SelectionAlignment);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionAlignment = value;
Assert.Equal(value, control.SelectionAlignment);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[EnumData<HorizontalAlignment>]
public void RichTextBox_SelectionAlignment_SetWithHandle_GetReturnsExpected(HorizontalAlignment value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionAlignment = value;
Assert.Equal(value, control.SelectionAlignment);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionAlignment = value;
Assert.Equal(value, control.SelectionAlignment);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(HorizontalAlignment.Left, 1)]
[InlineData(HorizontalAlignment.Center, 3)]
[InlineData(HorizontalAlignment.Right, 2)]
public unsafe void RichTextBox_SelectionAlignment_GetCharFormat_Success(HorizontalAlignment value, int expected)
{
using RichTextBox control = new()
{
BulletIndent = 11,
SelectionHangingIndent = 10
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionAlignment = value;
PARAFORMAT format = new()
{
cbSize = (uint)sizeof(PARAFORMAT)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(expected, (int)format.wAlignment);
}
[WinFormsTheory]
[InvalidEnumData<HorizontalAlignment>]
public void RichTextBox_SelectionAlignment_SetInvalidValue_ThrowsInvalidEnumArgumentException(HorizontalAlignment value)
{
using RichTextBox control = new();
Assert.Throws<InvalidEnumArgumentException>("value", () => control.SelectionAlignment = value);
}
[WinFormsTheory]
[EnumData<HorizontalAlignment>]
public void RichTextBox_SelectionAlignment_SetCantCreateHandle_GetReturnsExpected(HorizontalAlignment value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionAlignment = value;
Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionAlignment = value;
Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[EnumData<HorizontalAlignment>]
public void RichTextBox_SelectionAlignment_SetDisposed_ThrowsObjectDisposedException(HorizontalAlignment value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionAlignment = value);
}
[WinFormsFact]
public void RichTextBox_SelectionBackColor_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(SystemColors.Window, control.SelectionBackColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionBackColor_CustomGetCharFormat_TestData()
{
yield return new object[] { 0, 0, 0x78563412, Color.Empty };
yield return new object[] { 0, CFE_EFFECTS.CFE_AUTOBACKCOLOR, 0x78563412, Color.Red };
yield return new object[] { 0, CFE_EFFECTS.CFE_AUTOBACKCOLOR | CFE_EFFECTS.CFE_ALLCAPS, 0x78563412, Color.Red };
yield return new object[] { CFM_MASK.CFM_BACKCOLOR, 0, 0x78563412, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
yield return new object[] { CFM_MASK.CFM_BACKCOLOR, 0, 0x785634, Color.FromArgb(0xFF, 0x34, 0x56, 0x78) };
yield return new object[] { CFM_MASK.CFM_BACKCOLOR | CFM_MASK.CFM_ANIMATION, 0, 0x78563412, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
yield return new object[] { CFM_MASK.CFM_BACKCOLOR, CFE_EFFECTS.CFE_AUTOBACKCOLOR, 0x78563412, Color.Red };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, 0, 0x78563412, Color.Empty };
}
[WinFormsTheory]
[MemberData(nameof(SelectionBackColor_CustomGetCharFormat_TestData))]
public void RichTextBox_SelectionBackColor_CustomGetCharFormat_ReturnsExpected(uint mask, uint effects, int backColor, Color expected)
{
using CustomGetCharFormatRichTextBox control = new()
{
ExpectedWParam = (IntPtr)PInvoke.SCF_SELECTION,
GetCharFormatResult = new CHARFORMAT2W
{
dwMask = (CFM_MASK)mask,
dwEffects = (CFE_EFFECTS)effects,
crBackColor = backColor
},
BackColor = Color.Red
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionBackColor);
}
[WinFormsTheory]
[MemberData(nameof(SelectionBackColor_CustomGetCharFormat_TestData))]
public void RichTextBox_SelectionBackColor_CustomGetCharFormatWithBackColor_ReturnsExpected(uint mask, uint effects, int backColor, Color expected)
{
using CustomGetCharFormatRichTextBox control = new()
{
ExpectedWParam = (IntPtr)PInvoke.SCF_SELECTION,
GetCharFormatResult = new CHARFORMAT2W
{
dwMask = (CFM_MASK)mask,
dwEffects = (CFE_EFFECTS)effects,
crBackColor = backColor
},
BackColor = Color.Red
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionBackColor = Color.Yellow;
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionBackColor);
}
[WinFormsFact]
public void RichTextBox_SelectionBackColor_GetCantCreateHandle_ReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(Color.Empty, control.SelectionBackColor);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionBackColor_GetDisposed_ReturnsExpected()
{
using RichTextBox control = new();
control.Dispose();
Assert.Equal(Color.Empty, control.SelectionBackColor);
}
public static IEnumerable<object[]> SelectionBackColor_Set_TestData()
{
yield return new object[] { Color.Empty };
yield return new object[] { Color.Red };
yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78) };
}
[WinFormsTheory]
[MemberData(nameof(SelectionBackColor_Set_TestData))]
public void RichTextBox_SelectionBackColor_Set_GetReturnsExpected(Color value)
{
using RichTextBox control = new()
{
SelectionBackColor = value
};
Assert.Equal(value, control.SelectionBackColor);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionBackColor = value;
Assert.Equal(value, control.SelectionBackColor);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> SelectionBackColor_SetWithHandle_TestData()
{
yield return new object[] { Color.Empty, SystemColors.Window };
yield return new object[] { Color.Red, Color.Red };
yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.FromArgb(0xFF, 0x34, 0x56, 0x78) };
}
[WinFormsTheory]
[MemberData(nameof(SelectionBackColor_SetWithHandle_TestData))]
public void RichTextBox_SelectionBackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionBackColor = value;
Assert.Equal(expected, control.SelectionBackColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionBackColor = value;
Assert.Equal(expected, control.SelectionBackColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public unsafe void RichTextBox_SelectionBackColor_GetCharFormat_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionBackColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
var format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(0x785634, format.crBackColor);
}
public static IEnumerable<object[]> SelectionBackColor_SetCantCreate_TestData()
{
yield return new object[] { Color.Empty };
yield return new object[] { Color.Red };
yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78) };
}
[WinFormsTheory]
[MemberData(nameof(SelectionBackColor_SetCantCreate_TestData))]
public void RichTextBox_SelectionBackColor_SetCantCreateHandle_GetReturnsExpected(Color value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionBackColor = value;
Assert.Equal(value, control.SelectionBackColor);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionBackColor = value;
Assert.Equal(value, control.SelectionBackColor);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(SelectionBackColor_SetCantCreate_TestData))]
public void RichTextBox_SelectionBackColor_SetDisposed_ThrowsObjectDisposedException(Color value)
{
using RichTextBox control = new();
control.Dispose();
control.SelectionBackColor = value;
Assert.Equal(value, control.SelectionBackColor);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionBackColor = value;
Assert.Equal(value, control.SelectionBackColor);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionBullet_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionBullet_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionBullet_CustomGetParamFormat_TestData()
{
yield return new object[] { 0, 0, false };
yield return new object[] { 0, PARAFORMAT_NUMBERING.PFN_BULLET, false };
yield return new object[] { PFM.NUMBERING, PARAFORMAT_NUMBERING.PFN_BULLET, true };
yield return new object[] { PFM.NUMBERING, 0, false };
yield return new object[] { PFM.NUMBERING, PARAFORMAT_NUMBERING.PFN_ARABIC, false };
yield return new object[] { PFM.NUMBERING, PARAFORMAT_NUMBERING.PFN_LCLETTER, false };
yield return new object[] { PFM.NUMBERING, PARAFORMAT_NUMBERING.PFN_LCROMAN, false };
yield return new object[] { PFM.NUMBERING, PARAFORMAT_NUMBERING.PFN_UCLETTER, false };
yield return new object[] { PFM.NUMBERING, PARAFORMAT_NUMBERING.PFN_UCROMAN, false };
yield return new object[] { PFM.NUMBERING, PARAFORMAT_NUMBERING.PFN_UCROMAN + 1, false };
yield return new object[] { PFM.NUMBERING | PFM.ALIGNMENT, PARAFORMAT_NUMBERING.PFN_BULLET, true };
yield return new object[] { PFM.ALIGNMENT, PARAFORMAT_NUMBERING.PFN_BULLET, false };
}
[WinFormsTheory]
[MemberData(nameof(SelectionBullet_CustomGetParamFormat_TestData))]
public void RichTextBox_SelectionBullet_CustomGetParaFormat_ReturnsExpected(uint mask, uint numbering, bool expected)
{
using CustomGetParaFormatRichTextBox control = new()
{
GetParaFormatResult = new PARAFORMAT
{
dwMask = (PFM)mask,
wNumbering = (PARAFORMAT_NUMBERING)numbering
}
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionBullet);
}
[WinFormsFact]
public void RichTextBox_SelectionBullet_GetCantCreateHandle_ReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.False(control.SelectionBullet);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionBullet_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionBullet);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionBullet_Set_GetReturnsExpected(bool value)
{
using RichTextBox control = new()
{
SelectionBullet = value
};
Assert.Equal(value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionBullet = value;
Assert.Equal(value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
// Set different.
control.SelectionBullet = !value;
Assert.Equal(!value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionBullet_SetWithHandle_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionBullet = value;
Assert.Equal(value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionBullet = value;
Assert.Equal(value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.SelectionBullet = !value;
Assert.Equal(!value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionBullet_SetWithSelectionHangingIndentWithHandle_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionHangingIndent = 10;
control.SelectionBullet = value;
Assert.Equal(value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionBullet = value;
Assert.Equal(value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.SelectionBullet = !value;
Assert.Equal(!value, control.SelectionBullet);
Assert.Equal(0, control.BulletIndent);
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(true, 1, 165)]
[InlineData(false, 0, 0)]
public unsafe void RichTextBox_SelectionBullet_GetParaFormat_Success(bool value, int expected, int expectedOffset)
{
using RichTextBox control = new()
{
BulletIndent = 11,
SelectionHangingIndent = 10
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionBullet = value;
PARAFORMAT format = new()
{
cbSize = (uint)sizeof(PARAFORMAT)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(expectedOffset, format.dxOffset);
Assert.Equal(expected, (int)format.wNumbering);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionBullet_SetCantCreateHandle_GetReturnExpected(bool value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionBullet = value;
Assert.False(control.SelectionBullet);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionBullet = value;
Assert.False(control.SelectionBullet);
Assert.False(control.IsHandleCreated);
// Set different.
control.SelectionBullet = !value;
Assert.False(control.SelectionBullet);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionBullet_SetDisposed_ThrowsObjectDisposedException(bool value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionBullet = value);
}
[WinFormsFact]
public void RichTextBox_SelectionCharOffset_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(0, control.SelectionCharOffset);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Equal(0, control.SelectionCharOffset);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionCharOffset_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.SelectionCharOffset);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(0, control.SelectionCharOffset);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionCharOffset_CustomGetCharFormat_TestData()
{
yield return new object[] { 0, 0, 0 };
yield return new object[] { 0, 900, 60 };
yield return new object[] { 0, 30000, 2000 };
yield return new object[] { 0, 60000, 4000 };
yield return new object[] { 0, -900, -60 };
yield return new object[] { CFM_MASK.CFM_OFFSET, 0, 0 };
yield return new object[] { CFM_MASK.CFM_OFFSET, 900, 60 };
yield return new object[] { CFM_MASK.CFM_OFFSET, 30000, 2000 };
yield return new object[] { CFM_MASK.CFM_OFFSET, 60000, 4000 };
yield return new object[] { CFM_MASK.CFM_OFFSET, -900, -60 };
yield return new object[] { CFM_MASK.CFM_OFFSET | CFM_MASK.CFM_ALLCAPS, -900, -60 };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, 0, 0 };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, 900, 60 };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, 30000, 2000 };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, 60000, 4000 };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, -900, -60 };
}
[WinFormsTheory]
[MemberData(nameof(SelectionCharOffset_CustomGetCharFormat_TestData))]
public void RichTextBox_SelectionCharOffset_CustomGetCharFormat_Success(uint mask, int yOffset, int expected)
{
using CustomGetCharFormatRichTextBox control = new()
{
ExpectedWParam = (IntPtr)PInvoke.SCF_SELECTION,
GetCharFormatResult = new CHARFORMAT2W
{
dwMask = (CFM_MASK)mask,
yOffset = yOffset
}
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionCharOffset);
}
[WinFormsFact]
public void RichTextBox_SelectionCharOffset_GetCantCreateHandle_ReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(0, control.SelectionCharOffset);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionCharOffset_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionCharOffset);
}
[WinFormsTheory]
[InlineData(2000)]
[InlineData(10)]
[InlineData(0)]
[InlineData(-10)]
[InlineData(-2000)]
public void RichTextBox_SelectionCharOffset_Set_GetReturnsExpected(int value)
{
using RichTextBox control = new()
{
SelectionCharOffset = value
};
Assert.Equal(value, control.SelectionCharOffset);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionCharOffset = value;
Assert.Equal(value, control.SelectionCharOffset);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(2000)]
[InlineData(10)]
[InlineData(0)]
[InlineData(-10)]
[InlineData(-2000)]
public void RichTextBox_SelectionCharOffset_SetWithHandle_GetReturnsExpected(int value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionCharOffset = value;
Assert.Equal(value, control.SelectionCharOffset);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionCharOffset = value;
Assert.Equal(value, control.SelectionCharOffset);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public unsafe void RichTextBox_SelectionCharOffset_GetCharFormat_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionCharOffset = 60;
var format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(900, format.yOffset);
}
[WinFormsTheory]
[InlineData(2001)]
[InlineData(-20001)]
public void RichTextBox_SelectionCharOffset_SetInvalidValue_ThrowsArgumentOutOfRangeException(int value)
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionCharOffset = value);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionCharOffset_SetCantCreateHandle_GetReturnsExpected(int value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionCharOffset = value;
Assert.Equal(0, control.SelectionCharOffset);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionCharOffset = value;
Assert.Equal(0, control.SelectionCharOffset);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionCharOffset_SetDisposed_ThrowsObjectDisposedException(int value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionCharOffset = value);
}
[WinFormsFact]
public void RichTextBox_SelectionColor_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(Color.Black, control.SelectionColor);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Equal(Color.Black, control.SelectionColor);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionColor_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(Color.Black, control.SelectionColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(Color.Black, control.SelectionColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionColor_CustomGetCharFormat_TestData()
{
yield return new object[] { CFM_MASK.CFM_COLOR, 0x785634, Color.FromArgb(0xFF, 0x34, 0x56, 0x78) };
yield return new object[] { CFM_MASK.CFM_COLOR, 0x78563412, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
yield return new object[] { CFM_MASK.CFM_COLOR, 0, Color.Black };
yield return new object[] { 0, 0x785634, Color.Empty };
yield return new object[] { 0, 0x78563412, Color.Empty };
yield return new object[] { 0, 0, Color.Empty };
}
[WinFormsTheory]
[MemberData(nameof(SelectionColor_CustomGetCharFormat_TestData))]
public void RichTextBox_SelectionColor_CustomGetCharFormat_Success(uint mask, int textColor, Color expected)
{
using CustomGetCharFormatRichTextBox control = new()
{
ExpectedWParam = (IntPtr)PInvoke.SCF_SELECTION,
GetCharFormatResult = new CHARFORMAT2W
{
dwMask = (CFM_MASK)mask,
crTextColor = textColor
}
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionColor);
}
[WinFormsFact]
public void RichTextBox_SelectionColor_GetCantCreateHandle_ReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(Color.Empty, control.SelectionColor);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionColor_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionColor);
}
public static IEnumerable<object[]> SelectionColor_Set_TestData()
{
yield return new object[] { Color.Empty, Color.Black };
yield return new object[] { Color.Red, Color.Red };
yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.FromArgb(0xFF, 0x34, 0x56, 0x78) };
}
[WinFormsTheory]
[MemberData(nameof(SelectionColor_Set_TestData))]
public void RichTextBox_SelectionColor_Set_GetReturnsExpected(Color value, Color expected)
{
using RichTextBox control = new()
{
SelectionColor = value
};
Assert.Equal(expected, control.SelectionColor);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionColor = value;
Assert.Equal(expected, control.SelectionColor);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(SelectionColor_Set_TestData))]
public void RichTextBox_SelectionColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionColor = value;
Assert.Equal(expected, control.SelectionColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionColor = value;
Assert.Equal(expected, control.SelectionColor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public unsafe void RichTextBox_SelectionColor_GetCharFormat_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
var format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(0x785634, format.crTextColor);
}
public static IEnumerable<object[]> SelectionColor_SetCantCreate_TestData()
{
yield return new object[] { Color.Empty };
yield return new object[] { Color.Red };
yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78) };
}
[WinFormsTheory]
[MemberData(nameof(SelectionColor_SetCantCreate_TestData))]
public void RichTextBox_SelectionColor_SetCantCreateHandle_GetReturnsExpected(Color value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionColor = value;
Assert.Equal(Color.Empty, control.SelectionColor);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionColor = value;
Assert.Equal(Color.Empty, control.SelectionColor);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(SelectionColor_SetCantCreate_TestData))]
public void RichTextBox_SelectionColor_SetDisposed_ThrowsObjectDisposedException(Color value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionColor = value);
}
[WinFormsFact]
public void RichTextBox_SelectionFont_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Font result1 = control.SelectionFont;
Assert.NotNull(result1);
Assert.True(control.IsHandleCreated);
// Call again.
Font result2 = control.SelectionFont;
Assert.NotNull(result2);
Assert.NotSame(result1, result2);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionFont_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Font result1 = control.SelectionFont;
Assert.NotNull(result1);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Font result2 = control.SelectionFont;
Assert.NotNull(result2);
Assert.NotSame(result1, result2);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionFont_CustomGetCharFormat_TestData()
{
char[] arial = ['A', 'r', 'i', 'a', 'l'];
yield return new object[] { 0, 0, 0, Array.Empty<char>(), string.Empty, 13, FontStyle.Regular };
yield return new object[] { 0, 0, 0, arial, "Arial", 13, FontStyle.Regular };
yield return new object[] { 0, 0, 0, new char[] { 'A', 'r', 'i', 'a', 'l', '\0', 'm' }, "Arial", 13, FontStyle.Regular };
yield return new object[] { 0, 0, 0, new char[] { 'N', 'r', 'i', 'a', 'l', '\0', 'm' }, "Nrial", 13, FontStyle.Regular };
yield return new object[] { 0, 0, 200, arial, "Arial", 13, FontStyle.Regular };
yield return new object[] { CFM_MASK.CFM_SIZE, 0, 200, arial, "Arial", 10, FontStyle.Regular };
yield return new object[] { CFM_MASK.CFM_SIZE, 0, 250, arial, "Arial", 12.5f, FontStyle.Regular };
yield return new object[] { CFM_MASK.CFM_SIZE | CFM_MASK.CFM_ALLCAPS, 0, 250, arial, "Arial", 12.5f, FontStyle.Regular };
yield return new object[] { CFM_MASK.CFM_BOLD, CFE_EFFECTS.CFE_BOLD, 0, arial, "Arial", 13, FontStyle.Bold };
yield return new object[] { CFM_MASK.CFM_BOLD, CFE_EFFECTS.CFE_BOLD | CFE_EFFECTS.CFE_ALLCAPS, 0, arial, "Arial", 13, FontStyle.Bold };
yield return new object[] { CFM_MASK.CFM_ITALIC, CFE_EFFECTS.CFE_ITALIC, 0, arial, "Arial", 13, FontStyle.Italic };
yield return new object[] { CFM_MASK.CFM_ITALIC, CFE_EFFECTS.CFE_ITALIC | CFE_EFFECTS.CFE_ALLCAPS, 0, arial, "Arial", 13, FontStyle.Italic };
yield return new object[] { CFM_MASK.CFM_STRIKEOUT, CFE_EFFECTS.CFE_STRIKEOUT, 0, arial, "Arial", 13, FontStyle.Strikeout };
yield return new object[] { CFM_MASK.CFM_STRIKEOUT, CFE_EFFECTS.CFE_STRIKEOUT | CFE_EFFECTS.CFE_STRIKEOUT, 0, arial, "Arial", 13, FontStyle.Strikeout };
yield return new object[] { CFM_MASK.CFM_UNDERLINE, CFE_EFFECTS.CFE_UNDERLINE, 0, arial, "Arial", 13, FontStyle.Underline };
yield return new object[] { CFM_MASK.CFM_UNDERLINE, CFE_EFFECTS.CFE_UNDERLINE | CFE_EFFECTS.CFE_UNDERLINE, 0, arial, "Arial", 13, FontStyle.Underline };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, CFE_EFFECTS.CFE_BOLD, 0, arial, "Arial", 13, FontStyle.Regular };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, CFE_EFFECTS.CFE_BOLD | CFE_EFFECTS.CFE_ALLCAPS, 0, arial, "Arial", 13, FontStyle.Regular };
}
[WinFormsTheory]
[MemberData(nameof(SelectionFont_CustomGetCharFormat_TestData))]
public unsafe void RichTextBox_SelectionFont_CustomGetCharFormat_ReturnsExpected(uint mask, uint effects, int yHeight, char[] faceName, string expectedFontName, float expectedSize, FontStyle expectedStyle)
{
var result = new CHARFORMAT2W
{
dwMask = CFM_MASK.CFM_FACE | (CFM_MASK)mask,
dwEffects = (CFE_EFFECTS)effects,
yHeight = yHeight,
bCharSet = 2
};
for (int i = 0; i < faceName.Length; i++)
{
result._szFaceName[i] = faceName[i];
}
using CustomGetCharFormatRichTextBox control = new()
{
ExpectedWParam = (IntPtr)PInvoke.SCF_SELECTION,
GetCharFormatResult = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Font font = control.SelectionFont;
Assert.Equal(expectedFontName, font.OriginalFontName);
Assert.Equal(expectedSize, font.Size);
Assert.Equal(expectedStyle, font.Style);
Assert.Equal(GraphicsUnit.Point, font.Unit);
Assert.Equal(2, font.GdiCharSet);
}
public static IEnumerable<object[]> SelectionFont_InvalidCustomGetCharFormat_TestData()
{
char[] arial = ['A', 'r', 'i', 'a', 'l'];
yield return new object[] { 0, 0, arial };
yield return new object[] { CFM_MASK.CFM_ANIMATION, 0, arial };
yield return new object[] { CFM_MASK.CFM_SIZE, -200, arial };
yield return new object[] { CFM_MASK.CFM_SIZE, 0, arial };
}
[WinFormsTheory]
[MemberData(nameof(SelectionFont_InvalidCustomGetCharFormat_TestData))]
public unsafe void RichTextBox_SelectionFont_InvalidCustomGetCharFormat_ReturnsExpected(uint mask, int yHeight, char[] faceName)
{
var result = new CHARFORMAT2W
{
dwMask = (CFM_MASK)mask,
yHeight = yHeight
};
for (int i = 0; i < faceName.Length; i++)
{
result._szFaceName[i] = faceName[i];
}
using CustomGetCharFormatRichTextBox control = new()
{
ExpectedWParam = (IntPtr)PInvoke.SCF_SELECTION,
GetCharFormatResult = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Null(control.SelectionFont);
}
[WinFormsFact]
public void RichTextBox_SelectionFont_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Null(control.SelectionFont);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionFont_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionFont);
}
public static IEnumerable<object[]> SelectionFont_Set_TestData()
{
yield return new object[] { "Arial", 8.25f, false, FontStyle.Regular, 0, 0, 1 };
yield return new object[] { "Arial", 8.25f, true, FontStyle.Bold | FontStyle.Italic | FontStyle.Regular | FontStyle.Strikeout | FontStyle.Underline, GraphicsUnit.Point, 10, 1 };
}
[WinFormsTheory]
[MemberData(nameof(SelectionFont_Set_TestData))]
public void RichTextBox_SelectionFont_Set_GetReturnsExpected(string fontName, float fontSize, bool hasStyle, FontStyle fontStyle, GraphicsUnit units, byte gdiCharSet, byte expectedGdiCharset)
{
using Font value = hasStyle ? new Font(fontName, fontSize, fontStyle, units, gdiCharSet) : new Font(fontName, fontSize);
using RichTextBox control = new()
{
SelectionFont = value
};
Font result1 = control.SelectionFont;
Assert.NotSame(result1, value);
Assert.Equal(value?.Name, result1.Name);
Assert.Equal(value?.Size, result1.Size);
Assert.Equal(value?.Style, result1.Style);
Assert.Equal(expectedGdiCharset, result1.GdiCharSet);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionFont = value;
Font result2 = control.SelectionFont;
Assert.Equal(value?.Name, result2.Name);
Assert.Equal(value?.Size, result2.Size);
Assert.Equal(value?.Style, result2.Style);
Assert.Equal(expectedGdiCharset, result2.GdiCharSet);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(SelectionFont_Set_TestData))]
public void RichTextBox_SelectionFont_SetWithHandle_GetReturnsExpected(string fontName, float fontSize, bool hasStyle, FontStyle fontStyle, GraphicsUnit units, byte gdiCharSet, byte expectedGdiCharset)
{
using Font value = hasStyle ? new Font(fontName, fontSize, fontStyle, units, gdiCharSet) : new Font(fontName, fontSize);
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionFont = value;
Font result1 = control.SelectionFont;
Assert.NotSame(result1, value);
Assert.Equal(value?.Name, result1.Name);
Assert.Equal(value?.Size, result1.Size);
Assert.Equal(value?.Style, result1.Style);
Assert.Equal(expectedGdiCharset, result1.GdiCharSet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionFont = value;
Font result2 = control.SelectionFont;
Assert.Equal(value?.Name, result2.Name);
Assert.Equal(value?.Size, result2.Size);
Assert.Equal(value?.Style, result2.Style);
Assert.Equal(expectedGdiCharset, result2.GdiCharSet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionFont_SetCantCreate_TestData()
{
yield return new object[] { new Font("Arial", 8.25f) };
}
[WinFormsTheory]
[MemberData(nameof(SelectionFont_SetCantCreate_TestData))]
public void RichTextBox_SelectionFont_SetCantCreateHandle_GetReturnsExpected(Font value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionFont = value;
Assert.Null(control.SelectionFont);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionFont = value;
Assert.Null(control.SelectionFont);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(SelectionFont_SetCantCreate_TestData))]
public void RichTextBox_SelectionFont_SetDisposed_ThrowsObjectDisposedException(Font value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionFont = value);
}
public static IEnumerable<object[]> SelectionFont_GetCharFormat_TestData()
{
yield return new object[] { new Font("Arial", 8.25f), 165, 0 };
yield return new object[] { new Font("Arial", 8.25f, FontStyle.Bold), 165, CFE_EFFECTS.CFE_BOLD };
yield return new object[] { new Font("Arial", 8.25f, FontStyle.Italic), 165, CFE_EFFECTS.CFE_ITALIC };
yield return new object[] { new Font("Arial", 8.25f, FontStyle.Strikeout), 165, CFE_EFFECTS.CFE_STRIKEOUT };
yield return new object[] { new Font("Arial", 8.25f, FontStyle.Underline), 165, CFE_EFFECTS.CFE_UNDERLINE };
yield return new object[] { new Font("Arial", 8.25f, FontStyle.Bold | FontStyle.Italic | FontStyle.Regular | FontStyle.Strikeout | FontStyle.Underline, GraphicsUnit.Point, 10), 165, CFE_EFFECTS.CFE_BOLD | CFE_EFFECTS.CFE_ITALIC | CFE_EFFECTS.CFE_UNDERLINE | CFE_EFFECTS.CFE_STRIKEOUT };
}
[WinFormsTheory]
[MemberData(nameof(SelectionFont_GetCharFormat_TestData))]
public unsafe void RichTextBox_SelectionFont_GetCharFormat_Success(Font value, int expectedYHeight, int expectedEffects)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionFont = value;
var format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W),
dwMask = (CFM_MASK)int.MaxValue
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal("Arial", format.FaceName.ToString());
Assert.Equal(expectedYHeight, format.yHeight);
Assert.Equal(CFE_EFFECTS.CFE_AUTOBACKCOLOR | CFE_EFFECTS.CFE_AUTOCOLOR | (CFE_EFFECTS)expectedEffects, format.dwEffects);
Assert.Equal(0, format.bPitchAndFamily);
}
[WinFormsFact]
public void RichTextBox_SelectionFont_SetNull_ThrowsNullReferenceException()
{
using RichTextBox control = new();
Assert.Throws<NullReferenceException>(() => control.SelectionFont = null);
}
[WinFormsFact]
public void RichTextBox_SelectionHangingIndent_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionHangingIndent_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(0, control.SelectionHangingIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionHangingIndent_CustomGetParamFormat_TestData()
{
yield return new object[] { 0, 0, 0 };
yield return new object[] { 0, 20, 0 };
yield return new object[] { PFM.OFFSET, 900, 60 };
yield return new object[] { PFM.OFFSET, 30000, 2000 };
yield return new object[] { PFM.OFFSET, 60000, 4000 };
yield return new object[] { PFM.OFFSET, -900, -60 };
yield return new object[] { PFM.OFFSET | PFM.ALIGNMENT, -900, -60 };
}
[WinFormsTheory]
[MemberData(nameof(SelectionHangingIndent_CustomGetParamFormat_TestData))]
public void RichTextBox_SelectionHangingIndent_CustomGetParaFormat_ReturnsExpected(uint mask, int dxOffset, int expected)
{
using CustomGetParaFormatRichTextBox control = new()
{
GetParaFormatResult = new PARAFORMAT
{
dwMask = (PFM)mask,
dxOffset = dxOffset
}
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionHangingIndent);
}
[WinFormsFact]
public void RichTextBox_SelectionHangingIndent_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(0, control.SelectionHangingIndent);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionHangingIndent_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionHangingIndent);
}
[WinFormsTheory]
[InlineData(int.MinValue, 0)]
[InlineData(-1, 0)]
[InlineData(0, 0)]
[InlineData(1, 1)]
[InlineData(2000, 2000)]
[InlineData(2001, 2001)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_SelectionHangingIndent_Set_GetReturnsExpected(int value, int expected)
{
using RichTextBox control = new()
{
SelectionHangingIndent = value
};
Assert.Equal(expected, control.SelectionHangingIndent);
Assert.Equal(0, control.BulletIndent);
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionHangingIndent = value;
Assert.Equal(expected, control.SelectionHangingIndent);
Assert.Equal(0, control.BulletIndent);
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(int.MinValue, 0)]
[InlineData(-1, 0)]
[InlineData(0, 0)]
[InlineData(1, 1)]
[InlineData(2000, 2000)]
[InlineData(2001, 2001)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_SelectionHangingIndent_SetWithHandle_GetReturnsExpected(int value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionHangingIndent = value;
Assert.Equal(expected, control.SelectionHangingIndent);
Assert.Equal(0, control.BulletIndent);
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionHangingIndent = value;
Assert.Equal(expected, control.SelectionHangingIndent);
Assert.Equal(0, control.BulletIndent);
Assert.False(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(int.MinValue, 0)]
[InlineData(-1, 0)]
[InlineData(0, 0)]
[InlineData(1, 1)]
[InlineData(2000, 2000)]
[InlineData(2001, 2001)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_SelectionHangingIndent_SetSelectionBulletWithHandle_GetReturnsExpected(int value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionBullet = true;
control.SelectionHangingIndent = value;
Assert.Equal(expected, control.SelectionHangingIndent);
Assert.Equal(0, control.BulletIndent);
Assert.True(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionHangingIndent = value;
Assert.Equal(expected, control.SelectionHangingIndent);
Assert.Equal(0, control.BulletIndent);
Assert.True(control.SelectionBullet);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(int.MinValue, 0)]
[InlineData(-1, 0)]
[InlineData(0, 0)]
[InlineData(1, 15)]
[InlineData(2000, 30000)]
[InlineData(2001, 30015)]
[InlineData(int.MaxValue, 0)]
public unsafe void RichTextBox_SelectionHangingIndent_GetCharFormat_Success(int value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionHangingIndent = value;
PARAFORMAT format = new()
{
cbSize = (uint)sizeof(PARAFORMAT)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(expected, format.dxOffset);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionHangingIndent_SetCantCreateHandle_GetReturnsExpected(int value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionHangingIndent = value;
Assert.Equal(0, control.SelectionHangingIndent);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionHangingIndent = value;
Assert.Equal(0, control.SelectionHangingIndent);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionHangingIndent_SetDisposed_ThrowsObjectDisposedException(int value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionHangingIndent = value);
}
[WinFormsFact]
public void RichTextBox_SelectionIndent_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(0, control.SelectionIndent);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Equal(0, control.SelectionIndent);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionIndent_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.SelectionIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(0, control.SelectionIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionIndent_CustomGetParamFormat_TestData()
{
yield return new object[] { 0, 0, 0 };
yield return new object[] { 0, 20, 0 };
yield return new object[] { PFM.STARTINDENT, 900, 60 };
yield return new object[] { PFM.STARTINDENT, 30000, 2000 };
yield return new object[] { PFM.STARTINDENT, 60000, 4000 };
yield return new object[] { PFM.STARTINDENT, -900, -60 };
yield return new object[] { PFM.STARTINDENT | PFM.ALIGNMENT, -900, -60 };
yield return new object[] { PFM.ALIGNMENT, 20, 0 };
}
[WinFormsTheory]
[MemberData(nameof(SelectionIndent_CustomGetParamFormat_TestData))]
public void RichTextBox_SelectionIndent_CustomGetParaFormat_ReturnsExpected(uint mask, int dxStartIndent, int expected)
{
using CustomGetParaFormatRichTextBox control = new()
{
GetParaFormatResult = new PARAFORMAT
{
dwMask = (PFM)mask,
dxStartIndent = dxStartIndent
}
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionIndent);
}
[WinFormsFact]
public void RichTextBox_SelectionIndent_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(0, control.SelectionIndent);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionIndent_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionIndent);
}
[WinFormsTheory]
[InlineData(int.MinValue, 0)]
[InlineData(-1, 0)]
[InlineData(0, 0)]
[InlineData(1, 1)]
[InlineData(2000, 2000)]
[InlineData(2001, 2001)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_SelectionIndent_Set_GetReturnsExpected(int value, int expected)
{
using RichTextBox control = new()
{
SelectionIndent = value
};
Assert.Equal(expected, control.SelectionIndent);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionIndent = value;
Assert.Equal(expected, control.SelectionIndent);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(int.MinValue, 0)]
[InlineData(-1, 0)]
[InlineData(0, 0)]
[InlineData(1, 1)]
[InlineData(2000, 2000)]
[InlineData(2001, 2001)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_SelectionIndent_SetWithHandle_GetReturnsExpected(int value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionIndent = value;
Assert.Equal(expected, control.SelectionIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionIndent = value;
Assert.Equal(expected, control.SelectionIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(int.MinValue, 0)]
[InlineData(-1, 0)]
[InlineData(0, 0)]
[InlineData(1, 15)]
[InlineData(2000, 30000)]
[InlineData(2001, 30015)]
[InlineData(int.MaxValue, 0)]
public unsafe void RichTextBox_SelectionIndent_GetCharFormat_Success(int value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionIndent = value;
PARAFORMAT format = new()
{
cbSize = (uint)sizeof(PARAFORMAT)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(expected, format.dxStartIndent);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionIndent_SetCantCreateHandle_GetReturnsExpected(int value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionIndent = value;
Assert.Equal(0, control.SelectionIndent);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionIndent = value;
Assert.Equal(0, control.SelectionIndent);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionIndent_SetDisposed_ThrowsObjectDisposedException(int value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionIndent = value);
}
[WinFormsFact]
public void RichTextBox_SelectionLength_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(0, control.SelectionLength);
Assert.True(control.IsHandleCreated);
// Get again.
Assert.Equal(0, control.SelectionLength);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionLength_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.SelectionLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Get again.
Assert.Equal(0, control.SelectionLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SelectionLength_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(0, control.SelectionLength);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionLength_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionLength);
}
[WinFormsTheory]
[InlineData("", 0, 0, "")]
[InlineData("", 1, 0, "")]
[InlineData("text", 0, 0, "")]
[InlineData("text", 1, 1, "t")]
[InlineData("text", 2, 2, "te")]
[InlineData("text", 3, 3, "tex")]
[InlineData("text", 4, 4, "text")]
[InlineData("text", 5, 4, "text")]
public void RichTextBox_SelectionLength_Set_GetReturnsExpected(string text, int value, int expected, string expectedSelectedText)
{
using RichTextBox control = new()
{
Text = text,
SelectionLength = value
};
Assert.Equal(0, control.SelectionStart);
Assert.Equal(expected, control.SelectionLength);
Assert.Equal(expectedSelectedText, control.SelectedText);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionLength = value;
Assert.Equal(0, control.SelectionStart);
Assert.Equal(expected, control.SelectionLength);
Assert.Equal(expectedSelectedText, control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData("", 0, 0, "")]
[InlineData("", 1, 0, "")]
[InlineData("text", 0, 0, "")]
[InlineData("text", 1, 1, "e")]
[InlineData("text", 2, 2, "ex")]
[InlineData("text", 3, 3, "ext")]
[InlineData("text", 5, 3, "ext")]
public void RichTextBox_SelectionLength_SetWithSelectionStart_Success(string text, int value, int expected, string expectedSelectedText)
{
using RichTextBox control = new()
{
Text = text,
SelectionStart = 1,
SelectionLength = value
};
Assert.Equal(expected, control.SelectionLength);
Assert.Equal(expectedSelectedText, control.SelectedText);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionLength = value;
Assert.Equal(expected, control.SelectionLength);
Assert.Equal(expectedSelectedText, control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData("", 0, 0, "")]
[InlineData("", 1, 0, "")]
[InlineData("text", 0, 0, "")]
[InlineData("text", 1, 1, "t")]
[InlineData("text", 2, 2, "te")]
[InlineData("text", 4, 4, "text")]
[InlineData("text", 5, 4, "text")]
public void RichTextBox_SelectionLength_SetWithHandle_Success(string text, int value, int expected, string expectedSelectedText)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionLength = value;
Assert.Equal(0, control.SelectionStart);
Assert.Equal(expected, control.SelectionLength);
Assert.Equal(expectedSelectedText, control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionLength = value;
Assert.Equal(0, control.SelectionStart);
Assert.Equal(expected, control.SelectionLength);
Assert.Equal(expectedSelectedText, control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0, 1)]
[InlineData(1, 2)]
[InlineData(2, 3)]
[InlineData(4, 4)]
[InlineData(5, 4)]
public unsafe void RichTextBox_SelectionLength_GetSel_Success(int value, int expected)
{
using RichTextBox control = new()
{
Text = "Text",
SelectionStart = 1
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionLength = value;
int selectionStart = 0;
int selectionEnd = 0;
IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETSEL, (WPARAM)(&selectionStart), (LPARAM)(&selectionEnd));
Assert.Equal(1, PARAM.LOWORD(result));
Assert.Equal(expected, PARAM.HIWORD(result));
Assert.Equal(1, selectionStart);
Assert.Equal(expected, selectionEnd);
}
[WinFormsFact]
public void RichTextBox_SelectionLength_SetNegative_ThrowArgumentOutOfRangeException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionLength = -1);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionLength_SetCantCreateHandle_GetReturnsExpected(int value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionLength = value;
Assert.Equal(0, control.SelectionLength);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionLength = value;
Assert.Equal(0, control.SelectionLength);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionLength_SetDisposed_ThrowsObjectDisposedException(int value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionLength = value);
}
[WinFormsFact]
public void RichTextBox_SelectionProtected_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.False(control.SelectionProtected);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.False(control.SelectionProtected);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionProtected_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.False(control.SelectionProtected);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.False(control.SelectionProtected);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionProtected_CustomGetCharFormat_TestData()
{
yield return new object[] { 0, 0, false };
yield return new object[] { 0, CFE_EFFECTS.CFE_PROTECTED, false };
yield return new object[] { 0, CFE_EFFECTS.CFE_PROTECTED | CFE_EFFECTS.CFE_ALLCAPS, false };
yield return new object[] { CFM_MASK.CFM_PROTECTED, 0, false };
yield return new object[] { CFM_MASK.CFM_PROTECTED, CFE_EFFECTS.CFE_PROTECTED, true };
yield return new object[] { CFM_MASK.CFM_PROTECTED, CFE_EFFECTS.CFE_PROTECTED | CFE_EFFECTS.CFE_ALLCAPS, true };
yield return new object[] { CFM_MASK.CFM_PROTECTED, CFE_EFFECTS.CFE_ALLCAPS, false };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, CFE_EFFECTS.CFE_PROTECTED, false };
}
[WinFormsTheory]
[MemberData(nameof(SelectionProtected_CustomGetCharFormat_TestData))]
public void RichTextBox_SelectionProtected_CustomGetCharFormat_ReturnsExpected(uint mask, uint effects, bool expected)
{
using CustomGetCharFormatRichTextBox control = new()
{
ExpectedWParam = (IntPtr)PInvoke.SCF_SELECTION,
GetCharFormatResult = new CHARFORMAT2W
{
dwMask = (CFM_MASK)mask,
dwEffects = (CFE_EFFECTS)effects
}
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionProtected);
}
[WinFormsFact]
public void RichTextBox_SelectionProtected_GetCantCreateHandle_ReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.False(control.SelectionProtected);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionProtected_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionProtected);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionProtected_Set_GetReturnsExpected(bool value)
{
using RichTextBox control = new()
{
SelectionProtected = value
};
Assert.Equal(value, control.SelectionProtected);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionProtected = value;
Assert.Equal(value, control.SelectionProtected);
Assert.True(control.IsHandleCreated);
// Set different.
control.SelectionProtected = !value;
Assert.Equal(!value, control.SelectionProtected);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionProtected_SetWithHandle_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionProtected = value;
Assert.Equal(value, control.SelectionProtected);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionProtected = value;
Assert.Equal(value, control.SelectionProtected);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.SelectionProtected = !value;
Assert.Equal(!value, control.SelectionProtected);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[BoolData]
public unsafe void RichTextBox_SelectionProtected_GetCharFormat_Success(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionProtected = value;
var format = new CHARFORMAT2W
{
cbSize = (uint)sizeof(CHARFORMAT2W),
dwMask = CFM_MASK.CFM_PROTECTED
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(value, (format.dwEffects & CFE_EFFECTS.CFE_PROTECTED) != 0);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionProtected_SetCantCreateHandle_GetReturnExpected(bool value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionProtected = value;
Assert.False(control.SelectionProtected);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionProtected = value;
Assert.False(control.SelectionProtected);
Assert.False(control.IsHandleCreated);
// Set different.
control.SelectionProtected = !value;
Assert.False(control.SelectionProtected);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_SelectionProtected_SetDisposed_ThrowsObjectDisposedException(bool value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionProtected = value);
}
[WinFormsFact]
public void RichTextBox_SelectionRightIndent_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(0, control.SelectionRightIndent);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Equal(0, control.SelectionRightIndent);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionRightIndent_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.SelectionRightIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(0, control.SelectionRightIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionRightIndent_CustomGetParamFormat_TestData()
{
yield return new object[] { 0, 0, 0 };
yield return new object[] { 0, 20, 0 };
yield return new object[] { PFM.RIGHTINDENT, 900, 60 };
yield return new object[] { PFM.RIGHTINDENT, 30000, 2000 };
yield return new object[] { PFM.RIGHTINDENT, 60000, 4000 };
yield return new object[] { PFM.RIGHTINDENT, -900, -60 };
yield return new object[] { PFM.RIGHTINDENT | PFM.ALIGNMENT, -900, -60 };
yield return new object[] { PFM.ALIGNMENT, 20, 0 };
}
[WinFormsTheory]
[MemberData(nameof(SelectionRightIndent_CustomGetParamFormat_TestData))]
public void RichTextBox_SelectionRightIndent_CustomGetParaFormat_ReturnsExpected(uint mask, int dxRightIndent, int expected)
{
using CustomGetParaFormatRichTextBox control = new()
{
GetParaFormatResult = new PARAFORMAT
{
dwMask = (PFM)mask,
dxRightIndent = dxRightIndent
}
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionRightIndent);
}
[WinFormsFact]
public void RichTextBox_SelectionRightIndent_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(0, control.SelectionRightIndent);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionRightIndent_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionRightIndent);
}
[WinFormsTheory]
[InlineData(0, 0)]
[InlineData(1, 1)]
[InlineData(2000, 2000)]
[InlineData(2001, 2001)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_SelectionRightIndent_Set_GetReturnsExpected(int value, int expected)
{
using RichTextBox control = new()
{
SelectionRightIndent = value
};
Assert.Equal(expected, control.SelectionRightIndent);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionRightIndent = value;
Assert.Equal(expected, control.SelectionRightIndent);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0, 0)]
[InlineData(1, 1)]
[InlineData(2000, 2000)]
[InlineData(2001, 2001)]
[InlineData(int.MaxValue, 0)]
public void RichTextBox_SelectionRightIndent_SetWithHandle_GetReturnsExpected(int value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionRightIndent = value;
Assert.Equal(expected, control.SelectionRightIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionRightIndent = value;
Assert.Equal(expected, control.SelectionRightIndent);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0, 0)]
[InlineData(1, 15)]
[InlineData(2000, 30000)]
[InlineData(2001, 30015)]
[InlineData(int.MaxValue, 0)]
public unsafe void RichTextBox_SelectionRightIndent_GetCharFormat_Success(int value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionRightIndent = value;
PARAFORMAT format = new()
{
cbSize = (uint)sizeof(PARAFORMAT)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(expected, format.dxRightIndent);
}
[WinFormsFact]
public void RichTextBox_SelectionRightIndent_SetNegative_ThrowArgumentOutOfRangeException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionRightIndent = -1);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionRightIndent_SetCantCreateHandle_GetReturnsExpected(int value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionRightIndent = value;
Assert.Equal(0, control.SelectionRightIndent);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionRightIndent = value;
Assert.Equal(0, control.SelectionRightIndent);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionRightIndent_SetDisposed_ThrowsObjectDisposedException(int value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionRightIndent = value);
}
[WinFormsFact]
public void RichTextBox_SelectionStart_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(0, control.SelectionStart);
Assert.True(control.IsHandleCreated);
// Get again.
Assert.Equal(0, control.SelectionStart);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionStart_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.SelectionStart);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Get again.
Assert.Equal(0, control.SelectionStart);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SelectionStart_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(0, control.SelectionStart);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionStart_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionStart);
}
[WinFormsTheory]
[InlineData("", 0, 0)]
[InlineData("", 1, 0)]
[InlineData("text", 0, 0)]
[InlineData("text", 1, 1)]
[InlineData("text", 2, 2)]
[InlineData("text", 3, 3)]
[InlineData("text", 4, 4)]
[InlineData("text", 5, 4)]
public void RichTextBox_SelectionStart_Set_GetReturnsExpected(string text, int value, int expected)
{
using RichTextBox control = new()
{
Text = text,
SelectionStart = value
};
Assert.Equal(0, control.SelectionLength);
Assert.Equal(expected, control.SelectionStart);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionStart = value;
Assert.Equal(0, control.SelectionLength);
Assert.Equal(expected, control.SelectionStart);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData("", 0, 0, "")]
[InlineData("", 1, 0, "")]
[InlineData("text", 0, 0, "te")]
[InlineData("text", 1, 1, "ex")]
[InlineData("text", 2, 2, "xt")]
[InlineData("text", 3, 3, "t")]
[InlineData("text", 5, 4, "")]
public void RichTextBox_SelectionStart_SetWithSelectionLength_Success(string text, int value, int expected, string expectedSelectedText)
{
using RichTextBox control = new()
{
Text = text,
SelectionLength = 2,
SelectionStart = value
};
Assert.Equal(expected, control.SelectionStart);
Assert.Equal(expectedSelectedText, control.SelectedText);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionStart = value;
Assert.Equal(expected, control.SelectionStart);
Assert.Equal(expectedSelectedText, control.SelectedText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData("", 0, 0)]
[InlineData("", 1, 0)]
[InlineData("text", 0, 0)]
[InlineData("text", 1, 1)]
[InlineData("text", 2, 2)]
[InlineData("text", 3, 3)]
[InlineData("text", 4, 4)]
[InlineData("text", 5, 4)]
public void RichTextBox_SelectionStart_SetWithHandle_Success(string text, int value, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionStart = value;
Assert.Equal(0, control.SelectionLength);
Assert.Equal(expected, control.SelectionStart);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionStart = value;
Assert.Equal(0, control.SelectionLength);
Assert.Equal(expected, control.SelectionStart);
Assert.Empty(control.SelectedText);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0, 0, 1)]
[InlineData(1, 1, 2)]
[InlineData(2, 2, 3)]
[InlineData(3, 3, 4)]
[InlineData(5, 4, 4)]
public unsafe void RichTextBox_SelectionStart_GetSel_Success(int value, int expectedSelectionStart, int expectedEnd)
{
using RichTextBox control = new()
{
Text = "Text",
SelectionLength = 1
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionStart = value;
int selectionStart = 0;
int selectionEnd = 0;
IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETSEL, (WPARAM)(&selectionStart), (LPARAM)(&selectionEnd));
Assert.Equal(expectedSelectionStart, PARAM.LOWORD(result));
Assert.Equal(expectedEnd, PARAM.HIWORD(result));
Assert.Equal(expectedSelectionStart, selectionStart);
Assert.Equal(expectedEnd, selectionEnd);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionStart_SetCantCreateHandle_GetReturnsExpected(int value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionStart = value;
Assert.Equal(0, control.SelectionStart);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionStart = value;
Assert.Equal(0, control.SelectionStart);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_SelectionStart_SetDisposed_ThrowsObjectDisposedException(int value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionStart = value);
}
[WinFormsFact]
public void RichTextBox_SelectionTabs_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Empty(control.SelectionTabs);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Empty(control.SelectionTabs);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionTabs_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Empty(control.SelectionTabs);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Empty(control.SelectionTabs);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionTabs_CustomGetParaFormat_TestData()
{
yield return new object[] { 0, 3, new int[] { 900, 600, -900 }, Array.Empty<int>() };
yield return new object[] { PFM.TABSTOPS, 3, new int[] { 900, 600, -900 }, new int[] { 60, 40, -60 } };
yield return new object[] { PFM.TABSTOPS, 1, new int[] { 900, 600, -900 }, new int[] { 60 } };
yield return new object[] { PFM.TABSTOPS, 32, Enumerable.Repeat(900, 32).ToArray(), Enumerable.Repeat(60, 32).ToArray() };
yield return new object[] { PFM.TABSTOPS | PFM.ALIGNMENT, 3, new int[] { 900, 600, -900 }, new int[] { 60, 40, -60 } };
yield return new object[] { PFM.ALIGNMENT, 3, new int[] { 900, 600, -900 }, Array.Empty<int>() };
}
[WinFormsTheory]
[MemberData(nameof(SelectionTabs_CustomGetParaFormat_TestData))]
public unsafe void RichTextBox_SelectionTabs_CustomGetParaFormat_ReturnsExpected(int mask, short tabCount, int[] tabs, int[] expected)
{
PARAFORMAT result = new()
{
dwMask = (PFM)mask,
cTabCount = tabCount
};
for (int i = 0; i < tabs.Length; i++)
{
result.rgxTabs[i] = tabs[i];
}
using CustomGetParaFormatRichTextBox control = new()
{
GetParaFormatResult = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.MakeCustom = true;
Assert.Equal(expected, control.SelectionTabs);
}
[WinFormsFact]
public void RichTextBox_SelectionTabs_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Empty(control.SelectionTabs);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionTabs_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionTabs);
}
public static IEnumerable<object[]> SelectionTabs_Set_TestData()
{
yield return new object[] { null, Array.Empty<int>() };
yield return new object[] { Array.Empty<int>(), Array.Empty<int>() };
yield return new object[] { new int[] { 1, 2 }, new int[] { 1, 2 } };
yield return new object[] { new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 } };
yield return new object[] { new int[] { 1, 2, 3, 4 }, new int[] { 1, 2, 3, 4 } };
yield return new object[] { new int[] { 1, 0, 3 }, new int[] { 1, 0, 3 } };
yield return new object[] { new int[] { 1, -1, 3 }, Array.Empty<int>() };
}
[WinFormsTheory]
[MemberData(nameof(SelectionTabs_Set_TestData))]
public void RichTextBox_SelectionTabs_Set_GetReturnsExpected(int[] value, int[] expected)
{
using RichTextBox control = new()
{
SelectionTabs = value
};
Assert.Equal(expected, control.SelectionTabs);
Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
Assert.True(control.IsHandleCreated);
// Set same.
control.SelectionTabs = value;
Assert.Equal(expected, control.SelectionTabs);
Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(SelectionTabs_Set_TestData))]
public void RichTextBox_SelectionTabs_SetWithHandle_GetReturnsExpected(int[] value, int[] expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionTabs = value;
Assert.Equal(expected, control.SelectionTabs);
Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionTabs = value;
Assert.Equal(expected, control.SelectionTabs);
Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionTabs_SetWithCustomOldValue_TestData()
{
yield return new object[] { null, Array.Empty<int>() };
yield return new object[] { Array.Empty<int>(), Array.Empty<int>() };
yield return new object[] { new int[] { 1, 2 }, new int[] { 1, 2 } };
yield return new object[] { new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 } };
yield return new object[] { new int[] { 1, 2, 3, 4 }, new int[] { 1, 2, 3, 4 } };
yield return new object[] { new int[] { 1, 0, 3 }, new int[] { 1, 0, 3 } };
yield return new object[] { new int[] { 1, -1, 3 }, new int[] { 2, 3, 4 } };
}
[WinFormsTheory]
[MemberData(nameof(SelectionTabs_SetWithCustomOldValue_TestData))]
public void RichTextBox_SelectionTabs_SetWithCustomOldValueWithHandle_GetReturnsExpected(int[] value, int[] expected)
{
using RichTextBox control = new()
{
SelectionTabs = [2, 3, 4]
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SelectionTabs = value;
Assert.Equal(expected, control.SelectionTabs);
Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.SelectionTabs = value;
Assert.Equal(expected, control.SelectionTabs);
Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(new int[0])]
[InlineData(null)]
public unsafe void RichTextBox_SelectionTabs_GetParaFormat_Success(int[] nullOrEmptyValue)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.SelectionTabs = [1, 2, 3];
PARAFORMAT format = new()
{
cbSize = (uint)sizeof(PARAFORMAT)
};
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(3, format.cTabCount);
Assert.Equal(15, format.rgxTabs[0]);
Assert.Equal(30, format.rgxTabs[1]);
Assert.Equal(45, format.rgxTabs[2]);
// Set null or empty.
control.SelectionTabs = nullOrEmptyValue;
Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)PInvoke.SCF_SELECTION, ref format));
Assert.Equal(0, format.cTabCount);
}
[WinFormsFact]
public void RichTextBox_SelectionTabs_SetLongLength_ThrowsArgumentOutOfRangeException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionTabs = new int[33]);
}
public static IEnumerable<object[]> SelectionTabs_SetCantCreate_TestData()
{
yield return new object[] { null };
yield return new object[] { Array.Empty<int>() };
yield return new object[] { new int[] { 1 } };
}
[WinFormsTheory]
[MemberData(nameof(SelectionTabs_SetCantCreate_TestData))]
public void RichTextBox_SelectionTabs_SetCantCreateHandle_GetReturnsExpected(int[] value)
{
using CantCreateHandleRichTextBox control = new();
control.SelectionTabs = value;
Assert.Empty(control.SelectionTabs);
Assert.False(control.IsHandleCreated);
// Set same.
control.SelectionTabs = value;
Assert.Empty(control.SelectionTabs);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(SelectionTabs_SetCantCreate_TestData))]
public void RichTextBox_SelectionTabs_SetDisposed_ThrowsObjectDisposedException(int[] value)
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionTabs = value);
}
[WinFormsFact]
public void RichTextBox_SelectionType_GetWithoutHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionType_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(1, RichTextBoxSelectionTypes.Text)]
[InlineData(4, RichTextBoxSelectionTypes.Text | RichTextBoxSelectionTypes.MultiChar)]
public void RichTextBox_SelectionType_GetWithSelectionLengthWithHandle_ReturnsExpected(int selectionLength, RichTextBoxSelectionTypes expected)
{
using RichTextBox control = new()
{
Text = "text",
SelectionLength = selectionLength
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.SelectionType);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(expected, control.SelectionType);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> SelectionType_CustomSelectionType_TestData()
{
yield return new object[] { 0, (IntPtr)RichTextBoxSelectionTypes.Text, RichTextBoxSelectionTypes.Empty };
yield return new object[] { 0, (IntPtr)RichTextBoxSelectionTypes.MultiObject, RichTextBoxSelectionTypes.Empty };
yield return new object[] { 1, (IntPtr)RichTextBoxSelectionTypes.Text, RichTextBoxSelectionTypes.Text };
yield return new object[] { 1, (IntPtr)RichTextBoxSelectionTypes.MultiObject, RichTextBoxSelectionTypes.MultiObject };
yield return new object[] { 1, (IntPtr)(-1), -1 };
yield return new object[] { 4, (IntPtr)RichTextBoxSelectionTypes.Text, RichTextBoxSelectionTypes.Text };
yield return new object[] { 4, (IntPtr)RichTextBoxSelectionTypes.MultiObject, RichTextBoxSelectionTypes.MultiObject };
yield return new object[] { 4, (IntPtr)(-1), -1 };
}
[WinFormsTheory]
[MemberData(nameof(SelectionType_CustomSelectionType_TestData))]
public void RichTextBox_SelectionType_CustomSelectionType_ReturnsExpected(int selectionLength, IntPtr result, RichTextBoxSelectionTypes expected)
{
using CustomSelectionTypeRichTextBox control = new()
{
Text = "text",
SelectionLength = selectionLength,
SelectionTypeResult = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(expected, control.SelectionType);
}
private class CustomSelectionTypeRichTextBox : RichTextBox
{
public IntPtr SelectionTypeResult { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_SELECTIONTYPE)
{
Assert.Equal(IntPtr.Zero, m.WParam);
Assert.Equal(IntPtr.Zero, m.LParam);
m.Result = SelectionTypeResult;
return;
}
base.WndProc(ref m);
}
}
[WinFormsFact]
public void RichTextBox_SelectionType_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SelectionType_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Throws<ObjectDisposedException>(() => control.SelectionType);
}
[WinFormsFact]
public void RichTextBox_ShowSelectionMargin_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.False(control.ShowSelectionMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call EM_SETOPTIONS.
PInvoke.SendMessage(control, PInvoke.EM_SETOPTIONS, (WPARAM)(int)PInvoke.ECOOP_OR, (LPARAM)(nint)PInvoke.ECO_SELECTIONBAR);
Assert.False(control.ShowSelectionMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_ShowSelectionMargin_Set_GetReturnsExpected(bool value)
{
using RichTextBox control = new()
{
ShowSelectionMargin = value
};
Assert.Equal(value, control.ShowSelectionMargin);
Assert.False(control.IsHandleCreated);
// Set same.
control.ShowSelectionMargin = value;
Assert.Equal(value, control.ShowSelectionMargin);
Assert.False(control.IsHandleCreated);
// Set different.
control.ShowSelectionMargin = !value;
Assert.Equal(!value, control.ShowSelectionMargin);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[BoolData]
public void RichTextBox_ShowSelectionMargin_SetWithHandle_GetReturnsExpected(bool value)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.ShowSelectionMargin = value;
Assert.Equal(value, control.ShowSelectionMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.ShowSelectionMargin = value;
Assert.Equal(value, control.ShowSelectionMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.ShowSelectionMargin = !value;
Assert.Equal(!value, control.ShowSelectionMargin);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(true, 0x1000041)]
[InlineData(false, 0x41)]
public void RichTextBox_ShowSelectionMargin_GetOptions_Success(bool value, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
control.ShowSelectionMargin = value;
Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETOPTIONS));
}
[WinFormsFact]
public void RichTextBox_TextLength_GetDefaultWithoutHandle_Success()
{
using RichTextBox control = new();
Assert.Equal(0, control.TextLength);
Assert.True(control.IsHandleCreated);
// Call again.
Assert.Equal(0, control.TextLength);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_TextLength_GetDefaultWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.TextLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
Assert.Equal(0, control.TextLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData("", 0)]
[InlineData("a\0b", 1)]
[InlineData("a", 1)]
[InlineData("\ud83c\udf09", 2)] // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
public void RichTextBox_TextLength_GetSetWithHandle_Success(string text, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.Equal(expected, control.TextLength);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData("", 0)]
[InlineData("a\0b", 1)]
[InlineData("a", 1)]
[InlineData("\ud83c\udf09", 2)] // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
public void RichTextBox_TextLength_GetWithHandle_ReturnsExpected(string text, int expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.Text = text;
Assert.Equal(expected, control.TextLength);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> TextLength_GetCustomGetTextLengthEx_TestData()
{
yield return new object[] { IntPtr.Zero, 0 };
yield return new object[] { (IntPtr)(-1), -1 };
yield return new object[] { (IntPtr)1, 1 };
}
[WinFormsTheory]
[MemberData(nameof(TextLength_GetCustomGetTextLengthEx_TestData))]
public void RichTextBox_TextLength_GetCustomGetTextLengthEx_Success(IntPtr result, int expected)
{
using CustomGetTextLengthExRichTextBox control = new()
{
GetTextLengthExResult = result
};
Assert.Equal(expected, control.TextLength);
}
private class CustomGetTextLengthExRichTextBox : RichTextBox
{
public IntPtr GetTextLengthExResult { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_GETTEXTLENGTHEX)
{
GETTEXTLENGTHEX* gtl = (GETTEXTLENGTHEX*)m.WParam;
Assert.Equal(GETTEXTLENGTHEX_FLAGS.GTL_NUMCHARS, gtl->flags);
Assert.Equal(1200u, gtl->codepage);
Assert.Equal(IntPtr.Zero, m.LParam);
m.Result = GetTextLengthExResult;
return;
}
base.WndProc(ref m);
}
}
public static IEnumerable<object[]> RichTextBox_Text_GetWithHandle_TestData()
{
yield return new object[] { null, string.Empty };
yield return new object[] { string.Empty, string.Empty };
yield return new object[] { " ", " " };
yield return new object[] { "abc", "abc" };
yield return new object[] { "a\0b", "a" };
yield return new object[] { "\ud83c\udf09", "\ud83c\udf09" }; // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
yield return new object[] { "\n\n", "\n\n" };
yield return new object[] { "\r\r", "\n\n" };
yield return new object[] { "\n\r", "\n\n" };
yield return new object[] { "\r\n\r\n", "\n\n" };
yield return new object[] { "a6\r\nb\r\nc\r\nd\r\n", "a6\nb\nc\nd\n" };
yield return new object[] { "a7\nb\rc\r\n\n\rd\r\r\n", "a7\nb\nc\n\n\nd", SAME, "a7\nb\nc\n\n\nd " }; // RichEdit20W has a trailing space
// 0x0008 to 0x007F: https://www.unicode.org/charts/PDF/U0000.pdf
// 0x2000 to 0x2069: https://www.unicode.org/charts/PDF/U2000.pdf
var chars = Enumerable.Range(0x0008, /* 0x0008 to 0x007F */ 0x007F - 0x0008 + 1).Union(
Enumerable.Range(0x2000, /* 0x2000 to 0x2069 */ 0x2069 - 0x2000 + 1));
foreach (int i in chars)
{
if (i == 0x000B) // Vertical Tabulation
{
// NOTE: The old control works the same, but StreamOut() substituted 0x000B with \n
yield return new object[] { $"{(char)i}ab", " ab", "\nab" };
yield return new object[] { $"a{(char)i}b", "a b", "a\nb" };
yield return new object[] { $"ab\r\n{(char)i}\r\n", "ab\n \n", "ab\n\n\n" };
yield return new object[] { $"ab{(char)i}", $"ab ", "ab\n" };
yield return new object[] { $"ab\r\n{(char)i}", "ab\n ", "ab\n\n" };
continue;
}
if (i == 0x000D) // Carriage Return (\r) gets replaced with Line Feed (\n)
{
yield return new object[] { $"{(char)i}ab", "\nab" };
yield return new object[] { $"a{(char)i}b", "a\nb" };
yield return new object[] { $"ab\r\n{(char)i}\r\n", "ab\n", SAME, "ab\n " }; // RichEdit20W has a trailing space
yield return new object[] { $"ab{(char)i}", "ab\n" };
yield return new object[] { $"ab\r\n{(char)i}", "ab\n\n" };
continue;
}
if (i == 0x2028) // Line Separator (\v)
{
// NOTE: The old control works the same, but StreamOut() substituted 0x2028 with \n
yield return new object[] { $"{(char)i}ab", " ab", "\nab" };
yield return new object[] { $"a{(char)i}b", "a b", "a\nb" };
yield return new object[] { $"ab\r\n{(char)i}\r\n", "ab\n \n", "ab\n\n\n" };
yield return new object[] { $"ab{(char)i}", $"ab ", "ab\n" };
yield return new object[] { $"ab\r\n{(char)i}", "ab\n ", "ab\n\n" };
continue;
}
if (i == 0x2029) // Paragraph Separator
{
yield return new object[] { $"{(char)i}ab", "\nab" };
yield return new object[] { $"a{(char)i}b", "a\nb" };
yield return new object[] { $"ab\r\n{(char)i}\r\n", "ab\n", SAME, "ab\n\n\n" }; // RichEdit20W has extra line feeds
yield return new object[] { $"ab{(char)i}", $"ab\n" };
yield return new object[] { $"ab\r\n{(char)i}", "ab\n\n" };
continue;
}
yield return new object[] { $"{(char)i}ab", $"{(char)i}ab" };
yield return new object[] { $"a{(char)i}b", $"a{(char)i}b" };
yield return new object[] { $"ab\r\n{(char)i}\r\n", $"ab\n{(char)i}\n" };
yield return new object[] { $"ab{(char)i}", $"ab{(char)i}" };
yield return new object[] { $"ab\r\n{(char)i}", $"ab\n{(char)i}" };
}
}
private const string SAME = "SAME";
// NOTE: do not convert this into a theory as it will run hundreds of tests
// and with that will cycle through hundreds of UI controls.
[ActiveIssue("https://github.com/dotnet/winforms/issues/6609")]
[WinFormsFact]
[SkipOnArchitecture(TestArchitectures.X86,
"Flaky tests, see: https://github.com/dotnet/winforms/issues/6609")]
public void RichTextBox_Text_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
control.CreateControl();
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
// verify against RichEdit20W
using (var riched20 = new RichEdit20W())
{
riched20.CreateControl();
foreach (object[] testCaseData in RichTextBox_Text_GetWithHandle_TestData())
{
string text = (string)testCaseData[0];
string expectedText = (string)testCaseData[1];
string oldWayExpectedText = testCaseData.Length > 2 ? (string)testCaseData[2] : SAME;
string oldControlExpectedText = testCaseData.Length > 3 ? (string)testCaseData[3] : SAME;
// NOTE: in certain scenarios the old way (using StreamOut() method) returned a different
// text value to the new way (via GetTextEx() method).
// If oldWayExpectedText is SAME, assume StreamOut() returned the same expectedText.
if (oldWayExpectedText is SAME)
{
oldWayExpectedText = expectedText;
}
// NOTE: in certain scenarios the old control returns a different text value to the new control.
// If oldControlExpectedText is SAME, assume the old control returns the same expectedText.
if (oldControlExpectedText is SAME)
{
oldControlExpectedText = expectedText;
}
control.Text = text;
Assert.Equal(expectedText, control.Text);
// verify the old behavior via StreamOut(SF.TEXT | SF.UNICODE)
string textOldWay = control.TestAccessor().Dynamic.StreamOut(PInvoke.SF_TEXT | PInvoke.SF_UNICODE);
Assert.Equal(oldWayExpectedText, textOldWay);
// verify against RichEdit20W
riched20.Text = text;
Assert.Equal(oldControlExpectedText, riched20.Text);
}
}
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(null, "")]
[InlineData("", "")]
[InlineData("abc", "abc")]
[InlineData("a\0b", "a\0b")]
[InlineData("\ud83c\udf09", "\ud83c\udf09")] // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
[InlineData("\n\n", "\n\n")]
[InlineData("\r\r", "\r\r")]
[InlineData("\r\n\r\n", "\r\n\r\n")]
[InlineData("a\r\nb\r\nc\r\nd\r\n", "a\r\nb\r\nc\r\nd\r\n")]
[InlineData("a\nb\rc\r\n\n\rd\r\r\n", "a\nb\rc\r\n\n\rd\r\r\n")]
public void RichTextBox_Text_GetWithoutHandle_ReturnsExpected(string text, string expected)
{
using (RichTextBox control = new())
{
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Empty(control.Text);
Assert.False(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
control.Text = text;
Assert.Equal(expected, control.Text);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
Assert.False(control.IsHandleCreated);
}
// verify against RichEdit20W
using var riched20 = new RichEdit20W();
Assert.Empty(riched20.Text);
Assert.False(riched20.IsHandleCreated);
riched20.Text = text;
Assert.Equal(expected, riched20.Text);
Assert.False(riched20.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(null, "")]
[InlineData("", "")]
[InlineData("abc", "abc")]
[InlineData("a\0b", "a")]
[InlineData("\ud83c\udf09", "\ud83c\udf09")] // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
[InlineData("\n\n", "\r\n\r\n")]
[InlineData("\r\r", "\r\n\r\n")]
[InlineData("\r\n\r\n", "\r\n\r\n")]
[InlineData("a\r\nb\r\nc\r\nd\r\n", "a\r\nb\r\nc\r\nd\r\n")]
[InlineData("a1\nb\rc\n\r\n\rd\r\r\n", "a1\r\nb\r\nc\r\n\r\n\r\nd")]
public void RichTextBox_Text_GetTextEx_USECRLF_ReturnsExpected(string text, string expected)
{
using RichTextBox control = new();
control.CreateControl();
Assert.Empty(control.Text);
control.Text = text;
string textOldWay = control.TestAccessor().Dynamic.GetTextEx(GETTEXTEX_FLAGS.GT_USECRLF);
Assert.Equal(expected, textOldWay);
}
[WinFormsFact]
public void RichTextBox_Text_GetCantCreateHandle_ReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Empty(control.Text);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_Text_GetWithRtf_ReturnsExpected()
{
using RichTextBox control = new()
{
Rtf = "{\\rtf Hello World}"
};
Assert.Equal("Hello World", control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_Text_GetDisposed_ReturnsExpected()
{
using RichTextBox control = new();
control.Dispose();
Assert.Empty(control.Text);
}
public static IEnumerable<object[]> Text_Set_TestData()
{
foreach (bool autoSize in new bool[] { true, false })
{
yield return new object[] { autoSize, null, string.Empty };
yield return new object[] { autoSize, string.Empty, string.Empty };
yield return new object[] { autoSize, "text", "text" };
}
}
[WinFormsTheory]
[MemberData(nameof(Text_Set_TestData))]
public void RichTextBox_Text_Set_GetReturnsExpected(bool autoSize, string value, string expected)
{
using RichTextBox control = new()
{
AutoSize = autoSize
};
int layoutCallCount = 0;
control.Layout += (control, e) => layoutCallCount++;
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.Equal(0, layoutCallCount);
Assert.False(control.IsHandleCreated);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.Equal(0, layoutCallCount);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[NormalizedStringData]
public void RichTextBox_Text_SetWithRtfText_GetReturnsExpected(string value, string expected)
{
using RichTextBox control = new()
{
Rtf = "{\\rtf Hello World}",
Text = value
};
Assert.Equal(expected, control.Text);
Assert.Contains(expected, control.Rtf);
Assert.DoesNotContain("Hello World", control.Rtf);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Contains(expected, control.Rtf);
Assert.DoesNotContain("Hello World", control.Rtf);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
}
public static IEnumerable<object[]> Text_SetWithParent_TestData()
{
yield return new object[] { true, null, string.Empty, 1 };
yield return new object[] { true, string.Empty, string.Empty, 1 };
yield return new object[] { true, "text", "text", 1 };
yield return new object[] { false, null, string.Empty, 0 };
yield return new object[] { false, string.Empty, string.Empty, 0 };
yield return new object[] { false, "text", "text", 0 };
}
[WinFormsTheory]
[MemberData(nameof(Text_SetWithParent_TestData))]
public void RichTextBox_Text_SetWithParent_GetReturnsExpected(bool autoSize, string value, string expected, int expectedParentLayoutCallCount)
{
using Control parent = new();
using RichTextBox control = new()
{
Parent = parent,
AutoSize = autoSize
};
int layoutCallCount = 0;
control.Layout += (control, e) => layoutCallCount++;
int parentLayoutCallCount = 0;
void parentHandler(object sender, LayoutEventArgs e)
{
Assert.Same(parent, sender);
Assert.Same(control, e.AffectedControl);
Assert.Equal("Text", e.AffectedProperty);
parentLayoutCallCount++;
}
parent.Layout += parentHandler;
try
{
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.Equal(0, layoutCallCount);
Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.Equal(0, layoutCallCount);
Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
Assert.False(control.IsHandleCreated);
}
finally
{
parent.Layout -= parentHandler;
}
}
public static IEnumerable<object[]> Text_SetWithSelection_TestData()
{
yield return new object[] { string.Empty, 0, 2, null, string.Empty };
yield return new object[] { string.Empty, 0, 2, "t", "t" };
yield return new object[] { string.Empty, 0, 2, "text", "text" };
yield return new object[] { string.Empty, 1, 2, null, string.Empty };
yield return new object[] { string.Empty, 1, 2, "t", "t" };
yield return new object[] { string.Empty, 1, 2, "text", "text" };
yield return new object[] { "text", 0, 2, null, string.Empty };
yield return new object[] { "text", 0, 2, "t", "t" };
yield return new object[] { "text", 0, 2, "te", "te" };
yield return new object[] { "text", 0, 2, "tex", "tex" };
yield return new object[] { "text", 1, 2, null, string.Empty };
yield return new object[] { "text", 1, 2, "t", "t" };
yield return new object[] { "text", 1, 2, "te", "te" };
yield return new object[] { "text", 1, 2, "tex", "tex" };
}
[WinFormsTheory]
[MemberData(nameof(Text_SetWithSelection_TestData))]
public void RichTextBox_Text_SetWithSelection_GetReturnsExpected(string oldValue, int selectionStart, int selectionLength, string value, string expected)
{
using RichTextBox control = new()
{
Text = oldValue,
SelectionStart = selectionStart,
SelectionLength = selectionLength,
};
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(null, "", true)]
[InlineData("", "", false)]
[InlineData("text", "text", false)]
public void RichTextBox_Text_SetModified_GetReturnsExpected(string value, string expected, bool expectedModified)
{
using RichTextBox control = new()
{
Modified = true,
Text = value
};
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.Equal(expectedModified, control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(Text_Set_TestData))]
public void RichTextBox_Text_SetWithHandle_GetReturnsExpected(bool autoSize, string value, string expected)
{
using RichTextBox control = new()
{
AutoSize = autoSize
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int layoutCallCount = 0;
control.Layout += (control, e) => layoutCallCount++;
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.Equal(0, layoutCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.Equal(0, layoutCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[NormalizedStringData]
public void RichTextBox_Text_SetWithRtfTextWithHandle_GetReturnsExpected(string value, string expected)
{
using RichTextBox control = new()
{
Rtf = "{\\rtf Hello World}"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Contains(expected, control.Rtf);
Assert.DoesNotContain("Hello World", control.Rtf);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Contains(expected, control.Rtf);
Assert.DoesNotContain("Hello World", control.Rtf);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(Text_SetWithParent_TestData))]
public void RichTextBox_Text_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, string value, string expected, int expectedParentLayoutCallCount)
{
using Control parent = new();
using RichTextBox control = new()
{
Parent = parent,
AutoSize = autoSize
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int layoutCallCount = 0;
control.Layout += (control, e) => layoutCallCount++;
int parentLayoutCallCount = 0;
void parentHandler(object sender, LayoutEventArgs e)
{
Assert.Same(parent, sender);
Assert.Same(control, e.AffectedControl);
Assert.Equal("Text", e.AffectedProperty);
parentLayoutCallCount++;
}
parent.Layout += parentHandler;
try
{
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.Equal(0, layoutCallCount);
Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.Equal(0, layoutCallCount);
Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
finally
{
parent.Layout -= parentHandler;
}
}
[WinFormsTheory]
[InlineData(null, "")]
[InlineData("", "")]
[InlineData("text", "text")]
public void RichTextBox_Text_SetModifiedWithHandle_GetReturnsExpected(string value, string expected)
{
using RichTextBox control = new()
{
Modified = true
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> Text_SetWithSelectionWithHandle_TestData()
{
yield return new object[] { string.Empty, 0, 2, null, string.Empty };
yield return new object[] { string.Empty, 0, 2, "t", "t" };
yield return new object[] { string.Empty, 0, 2, "text", "text" };
yield return new object[] { string.Empty, 1, 2, null, string.Empty };
yield return new object[] { string.Empty, 1, 2, "t", "t" };
yield return new object[] { string.Empty, 1, 2, "text", "text" };
yield return new object[] { "text", 0, 2, null, string.Empty };
yield return new object[] { "text", 0, 2, "t", "t" };
yield return new object[] { "text", 0, 2, "te", "te" };
yield return new object[] { "text", 0, 2, "tex", "tex" };
yield return new object[] { "text", 1, 2, null, string.Empty };
yield return new object[] { "text", 1, 2, "t", "t" };
yield return new object[] { "text", 1, 2, "te", "te" };
yield return new object[] { "text", 1, 2, "tex", "tex" };
}
[WinFormsTheory]
[MemberData(nameof(Text_SetWithSelectionWithHandle_TestData))]
public void RichTextBox_Text_SetWithSelectionWith_GetReturnsExpected(string oldValue, int selectionStart, int selectionLength, string value, string expected)
{
using RichTextBox control = new()
{
Text = oldValue,
SelectionStart = selectionStart,
SelectionLength = selectionLength,
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.Equal(expected.Length, control.TextLength);
Assert.Equal(0, control.SelectionStart);
Assert.Equal(0, control.SelectionLength);
Assert.Empty(control.SelectedText);
Assert.False(control.Modified);
Assert.False(control.CanUndo);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_Text_SetWithHandler_CallsTextChanged()
{
using RichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Equal(EventArgs.Empty, e);
callCount++;
};
control.TextChanged += handler;
// Set different.
control.Text = "text";
Assert.Equal("text", control.Text);
Assert.Equal(0, callCount);
// Set same.
control.Text = "text";
Assert.Equal("text", control.Text);
Assert.Equal(0, callCount);
// Set different.
control.Text = null;
Assert.Empty(control.Text);
Assert.Equal(0, callCount);
// Remove handler.
control.TextChanged -= handler;
control.Text = "text";
Assert.Equal("text", control.Text);
Assert.Equal(0, callCount);
}
[WinFormsFact]
public void RichTextBox_Text_SetWithHandlerWithHandle_CallsTextChanged()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Equal(EventArgs.Empty, e);
callCount++;
};
control.TextChanged += handler;
// Set different.
control.Text = "text";
Assert.Equal("text", control.Text);
Assert.Equal(1, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.Text = "text";
Assert.Equal("text", control.Text);
Assert.Equal(2, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set different.
control.Text = null;
Assert.Empty(control.Text);
Assert.Equal(3, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Remove handler.
control.TextChanged -= handler;
control.Text = "text";
Assert.Equal("text", control.Text);
Assert.Equal(3, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[NormalizedStringData]
public void RichTextBox_Text_SetCantCreateHandle_GetReturnsExpected(string value, string expected)
{
using CantCreateHandleRichTextBox control = new();
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.False(control.IsHandleCreated);
// Set same.
control.Text = value;
Assert.Equal(expected, control.Text);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[StringWithNullData]
public void RichTextBox_Text_SetDisposed_ThrowsObjectDisposedException(string value)
{
using RichTextBox control = new();
control.Dispose();
control.Text = value;
Assert.Empty(control.Text);
Assert.False(control.IsHandleCreated);
// Set same.
control.Text = value;
Assert.Empty(control.Text);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_UndoActionName_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Empty(control.UndoActionName);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> UndoActionName_CustomGetUndoName_TestData()
{
yield return new object[] { IntPtr.Zero, IntPtr.Zero, string.Empty };
yield return new object[] { (IntPtr)1, IntPtr.Zero, "Unknown" };
yield return new object[] { (IntPtr)1, (IntPtr)1, "Typing" };
yield return new object[] { (IntPtr)1, (IntPtr)2, "Delete" };
yield return new object[] { (IntPtr)1, (IntPtr)3, "Drag and Drop" };
yield return new object[] { (IntPtr)1, (IntPtr)4, "Cut" };
yield return new object[] { (IntPtr)1, (IntPtr)5, "Paste" };
yield return new object[] { (IntPtr)1, (IntPtr)6, "Unknown" };
yield return new object[] { (IntPtr)1, (IntPtr)7, "Unknown" };
}
[WinFormsTheory]
[MemberData(nameof(UndoActionName_CustomGetUndoName_TestData))]
public void RichTextBox_UndoActionName_CustomGetUndoName_ReturnsExpected(IntPtr canUndoResult, IntPtr getUndoNameResult, string expected)
{
using CustomGetUndoNameRichTextBox control = new()
{
CanUndoResult = canUndoResult,
GetUndoNameResult = getUndoNameResult
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(expected, control.UndoActionName);
}
private class CustomGetUndoNameRichTextBox : RichTextBox
{
public IntPtr CanUndoResult { get; set; }
public IntPtr GetUndoNameResult { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_CANUNDO)
{
m.Result = CanUndoResult;
return;
}
else if (m.Msg == (int)PInvoke.EM_GETUNDONAME)
{
m.Result = GetUndoNameResult;
return;
}
base.WndProc(ref m);
}
}
[WinFormsFact]
public void RichTextBox_UndoActionName_GetCantCreateHandle_GetReturnsExpected()
{
using CantCreateHandleRichTextBox control = new();
Assert.Empty(control.UndoActionName);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_UndoActionName_GetDisposed_ThrowsObjectDisposedException()
{
using RichTextBox control = new();
control.Dispose();
Assert.Empty(control.UndoActionName);
}
[WinFormsFact]
public void RichTextBox_ZoomFactor_GetWithHandle_ReturnsExpected()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(1, control.ZoomFactor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call EM_SETZOOM.
PInvoke.SendMessage(control, PInvoke.EM_SETZOOM, 2, 10);
Assert.Equal(0.2f, control.ZoomFactor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(1, 1, 1.0f)]
[InlineData(10, 1, 10.0f)]
[InlineData(10, 2, 5.0f)]
[InlineData(1, 10, 0.1f)]
[InlineData(1, 0, 1f)]
[InlineData(0, 1, 1f)]
[InlineData(0, 0, 1f)]
public void RichTextBox_ZoomFactor_CustomGetZoom_ReturnsExpected(int numerator, int denominator, float expected)
{
using CustomGetZoomRichTextBox control = new()
{
NumeratorResult = numerator,
DenominatorResult = denominator
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(expected, control.ZoomFactor);
}
private class CustomGetZoomRichTextBox : RichTextBox
{
public int NumeratorResult { get; set; }
public int DenominatorResult { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_GETZOOM)
{
int* pNumerator = (int*)m.WParam;
int* pDenominator = (int*)m.LParam;
*pNumerator = NumeratorResult;
*pDenominator = DenominatorResult;
return;
}
base.WndProc(ref m);
}
}
[WinFormsTheory]
[InlineData(0.015626f, 0.016f)]
[InlineData(63.9f, 63.9f)]
[InlineData(1.0f, 1.0f)]
[InlineData(2.0f, 2.0f)]
[InlineData(float.NaN, 1.0f)]
public void RichTextBox_ZoomFactor_Set_GetReturnsExpected(float value, float expected)
{
using RichTextBox control = new()
{
ZoomFactor = value
};
Assert.Equal(expected, control.ZoomFactor, 2f);
Assert.False(control.IsHandleCreated);
// Set same.
control.ZoomFactor = value;
Assert.Equal(expected, control.ZoomFactor, 2f);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(0.015626f, 0.016f)]
[InlineData(63.9f, 63.9f)]
[InlineData(1.0f, 1.0f)]
[InlineData(2.0f, 2.0f)]
[InlineData(float.NaN, 1.0f)]
public void RichTextBox_ZoomFactor_SetWithHandle_GetReturnsExpected(float value, float expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.ZoomFactor = value;
Assert.Equal(expected, control.ZoomFactor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Set same.
control.ZoomFactor = value;
Assert.Equal(expected, control.ZoomFactor);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(0.015624f)]
[InlineData(0.015625f)]
[InlineData(64.0f)]
[InlineData(64.1f)]
[InlineData(float.PositiveInfinity)]
[InlineData(float.NegativeInfinity)]
public void RichTextBox_ZoomFactor_SetInvalidValue_ThrowsArgumentOutOfRangeException(float value)
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ZoomFactor = value);
}
public static IEnumerable<object[]> CanPaste_TestData()
{
yield return new object[] { DataFormats.GetFormat(DataFormats.Palette), false };
yield return new object[] { new DataFormats.Format("UnknownName", int.MaxValue), false };
}
[WinFormsTheory]
[MemberData(nameof(CanPaste_TestData))]
public void RichTextBox_CanPaste_Invoke_ReturnsExpected(DataFormats.Format format, bool expected)
{
using RichTextBox control = new();
Assert.Equal(expected, control.CanPaste(format));
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(CanPaste_TestData))]
public void RichTextBox_CanPaste_InvokeWithHandle_ReturnsExpected(DataFormats.Format format, bool expected)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.CanPaste(format));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> CanPaste_CustomCanPaste_TestData()
{
yield return new object[] { IntPtr.Zero, false };
yield return new object[] { (IntPtr)1, true };
}
[WinFormsTheory]
[MemberData(nameof(CanPaste_CustomCanPaste_TestData))]
public void RichTextBox_CanPaste_CustomCanPaste_ReturnsExpected(IntPtr result, bool expected)
{
using CustomCanPasteRichTextBox control = new()
{
Result = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(expected, control.CanPaste(DataFormats.GetFormat(DataFormats.Text)));
}
private class CustomCanPasteRichTextBox : RichTextBox
{
public IntPtr Result { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_CANPASTE)
{
m.Result = Result;
return;
}
base.WndProc(ref m);
}
}
[WinFormsFact]
public void RichTextBox_CanPaste_NullFormat_ThrowsNullReferenceException()
{
using RichTextBox control = new();
Assert.Throws<NullReferenceException>(() => control.CanPaste(null));
}
[WinFormsFact]
public void RichTextBox_Find_String_Table_ReturnsExpected()
{
using RichTextBox control = new()
{
Rtf = "{\\rtf1\\ansi\\deff0\\trowd\\pard\\intbl Test\\cell Example\\cell Meow\\cell Woof\\cell \\row}"
};
Assert.Equal(2, control.Find("Test"));
Assert.Equal(7, control.Find("Example"));
Assert.Equal(15, control.Find("Meow"));
Assert.Equal(20, control.Find("Woof"));
}
public static IEnumerable<object[]> Find_String_TestData()
{
yield return new object[] { string.Empty, string.Empty, -1 };
yield return new object[] { string.Empty, "abc", -1 };
yield return new object[] { "abc", string.Empty, -1 };
yield return new object[] { "abc", "a", 0 };
yield return new object[] { "abc", "ab", 0 };
yield return new object[] { "abc", "abc", 0 };
yield return new object[] { "abc", "abcd", -1 };
yield return new object[] { "abc", "b", 1 };
yield return new object[] { "abc", "d", -1 };
yield return new object[] { "abc", "ABC", 0 };
yield return new object[] { "aa", "a", 0 };
yield return new object[] { "abc def", "ef", 5 };
yield return new object[] { "abc def", "def", 4 };
yield return new object[] { "abc def", " ", 3 };
yield return new object[] { "ab\u0640cd", "abcd", 0 };
yield return new object[] { "ab\u0640cd", "\u0640", 2 };
yield return new object[] { "ab\u0640cd", "bc", 1 };
}
[WinFormsTheory]
[MemberData(nameof(Find_String_TestData))]
public void RichTextBox_Find_String_ReturnsExpected(string text, string str, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.Equal(expected, control.Find(str));
Assert.True(control.IsHandleCreated);
}
public static IEnumerable<object[]> Find_String_RichTextBoxFinds_TestData()
{
yield return new object[] { string.Empty, string.Empty, RichTextBoxFinds.None, -1 };
yield return new object[] { string.Empty, "abc", RichTextBoxFinds.None, -1 };
yield return new object[] { string.Empty, string.Empty, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { string.Empty, "abc", RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc", string.Empty, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "a", RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "a", RichTextBoxFinds.Reverse, 0 };
yield return new object[] { "abc", "ab", RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abc", RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abcd", RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "b", RichTextBoxFinds.None, 1 };
yield return new object[] { "abc", "d", RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "ABC", RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abc", RichTextBoxFinds.MatchCase, 0 };
yield return new object[] { "abc", "ABC", RichTextBoxFinds.MatchCase, -1 };
yield return new object[] { "aa", "a", RichTextBoxFinds.None, 0 };
yield return new object[] { "aa", "a", RichTextBoxFinds.Reverse, 1 };
yield return new object[] { "aa", string.Empty, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc def", "ef", RichTextBoxFinds.None, 5 };
yield return new object[] { "abc def", "def", RichTextBoxFinds.None, 4 };
yield return new object[] { "abc def", " ", RichTextBoxFinds.None, 3 };
yield return new object[] { "abc def", "ef", RichTextBoxFinds.WholeWord, -1 };
yield return new object[] { "abc def", "def", RichTextBoxFinds.WholeWord, 4 };
yield return new object[] { "abc def", " ", RichTextBoxFinds.WholeWord, -1 };
yield return new object[] { "ab\u0640cd", "abcd", RichTextBoxFinds.None, 0 };
yield return new object[] { "ab\u0640cd", "\u0640", RichTextBoxFinds.None, 2 };
yield return new object[] { "ab\u0640cd", "bc", RichTextBoxFinds.None, 1 };
yield return new object[] { "ab\u0640cd", "abcd", RichTextBoxFinds.NoHighlight, 0 };
yield return new object[] { "ab\u0640cd", "\u0640", RichTextBoxFinds.NoHighlight, 2 };
yield return new object[] { "ab\u0640cd", "bc", RichTextBoxFinds.NoHighlight, 1 };
yield return new object[] { "abcd", "abcd", RichTextBoxFinds.NoHighlight, 0 };
}
[WinFormsTheory]
[MemberData(nameof(Find_String_RichTextBoxFinds_TestData))]
public void RichTextBox_Find_StringRichTextBoxFinds_ReturnsExpected(string text, string str, RichTextBoxFinds options, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.Equal(expected, control.Find(str, options));
Assert.True(control.IsHandleCreated);
}
public static IEnumerable<object[]> Find_String_Int_RichTextBoxFinds_TestData()
{
yield return new object[] { string.Empty, string.Empty, 0, RichTextBoxFinds.None, -1 };
yield return new object[] { string.Empty, "abc", 0, RichTextBoxFinds.None, -1 };
yield return new object[] { string.Empty, string.Empty, 0, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { string.Empty, "abc", 0, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc", string.Empty, 0, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "a", 0, RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "a", 0, RichTextBoxFinds.Reverse, 0 };
yield return new object[] { "abc", "ab", 0, RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abc", 0, RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abcd", 0, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "b", 0, RichTextBoxFinds.None, 1 };
yield return new object[] { "abc", "d", 0, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "ABC", 0, RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abc", 0, RichTextBoxFinds.MatchCase, 0 };
yield return new object[] { "abc", "ABC", 0, RichTextBoxFinds.MatchCase, -1 };
yield return new object[] { "aa", "a", 0, RichTextBoxFinds.None, 0 };
yield return new object[] { "aa", "a", 0, RichTextBoxFinds.Reverse, 1 };
yield return new object[] { "aa", string.Empty, 0, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc def", "ef", 0, RichTextBoxFinds.None, 5 };
yield return new object[] { "abc def", "def", 0, RichTextBoxFinds.None, 4 };
yield return new object[] { "abc def", " ", 0, RichTextBoxFinds.None, 3 };
yield return new object[] { "abc def", "ef", 0, RichTextBoxFinds.WholeWord, -1 };
yield return new object[] { "abc def", "def", 0, RichTextBoxFinds.WholeWord, 4 };
yield return new object[] { "abc def", " ", 0, RichTextBoxFinds.WholeWord, -1 };
yield return new object[] { "abc", "a", 1, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "a", 2, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "c", 2, RichTextBoxFinds.None, 2 };
yield return new object[] { "abc", "a", 1, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc", "a", 2, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc", "c", 2, RichTextBoxFinds.Reverse, 2 };
yield return new object[] { "ab\u0640cd", "abcd", 0, RichTextBoxFinds.None, 0 };
yield return new object[] { "ab\u0640cd", "\u0640", 0, RichTextBoxFinds.None, 2 };
yield return new object[] { "ab\u0640cd", "bc", 0, RichTextBoxFinds.None, 1 };
yield return new object[] { "ab\u0640cd", "abcd", 0, RichTextBoxFinds.NoHighlight, 0 };
yield return new object[] { "ab\u0640cd", "\u0640", 0, RichTextBoxFinds.NoHighlight, 2 };
yield return new object[] { "ab\u0640cd", "bc", 0, RichTextBoxFinds.NoHighlight, 1 };
yield return new object[] { "abcd", "abcd", 0, RichTextBoxFinds.NoHighlight, 0 };
}
[WinFormsTheory]
[MemberData(nameof(Find_String_Int_RichTextBoxFinds_TestData))]
public void RichTextBox_Find_StringIntRichTextBoxFinds_ReturnsExpected(string text, string str, int start, RichTextBoxFinds options, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.Equal(expected, control.Find(str, start, options));
Assert.True(control.IsHandleCreated);
}
public static IEnumerable<object[]> Find_String_Int_Int_RichTextBoxFinds_TestData()
{
foreach (int end in new int[] { -1, 0 })
{
yield return new object[] { string.Empty, string.Empty, 0, end, RichTextBoxFinds.None, -1 };
yield return new object[] { string.Empty, "abc", 0, end, RichTextBoxFinds.None, -1 };
yield return new object[] { string.Empty, string.Empty, 0, end, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { string.Empty, "abc", 0, end, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc", string.Empty, 0, end, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "a", 0, end, RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "a", 0, end, RichTextBoxFinds.Reverse, 0 };
yield return new object[] { "abc", "ab", 0, end, RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abc", 0, end, RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abcd", 0, end, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "b", 0, end, RichTextBoxFinds.None, 1 };
yield return new object[] { "abc", "d", 0, end, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "ABC", 0, end, RichTextBoxFinds.None, 0 };
yield return new object[] { "abc", "abc", 0, end, RichTextBoxFinds.MatchCase, 0 };
yield return new object[] { "abc", "ABC", 0, end, RichTextBoxFinds.MatchCase, -1 };
yield return new object[] { "aa", "a", 0, end, RichTextBoxFinds.None, 0 };
yield return new object[] { "aa", "a", 0, end, RichTextBoxFinds.Reverse, 1 };
yield return new object[] { "abc", string.Empty, 0, end, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc def", "ef", 0, end, RichTextBoxFinds.None, 5 };
yield return new object[] { "abc def", "def", 0, end, RichTextBoxFinds.None, 4 };
yield return new object[] { "abc def", " ", 0, end, RichTextBoxFinds.None, 3 };
yield return new object[] { "abc def", "ef", 0, end, RichTextBoxFinds.WholeWord, -1 };
yield return new object[] { "abc def", "def", 0, end, RichTextBoxFinds.WholeWord, 4 };
yield return new object[] { "abc def", " ", 0, end, RichTextBoxFinds.WholeWord, -1 };
yield return new object[] { "ab\u0640cd", "abcd", 0, end, RichTextBoxFinds.None, 0 };
yield return new object[] { "ab\u0640cd", "\u0640", 0, end, RichTextBoxFinds.None, 2 };
yield return new object[] { "ab\u0640cd", "bc", 0, end, RichTextBoxFinds.None, 1 };
yield return new object[] { "ab\u0640cd", "abcd", 0, end, RichTextBoxFinds.NoHighlight, 0 };
yield return new object[] { "ab\u0640cd", "\u0640", 0, end, RichTextBoxFinds.NoHighlight, 2 };
yield return new object[] { "ab\u0640cd", "bc", 0, end, RichTextBoxFinds.NoHighlight, 1 };
yield return new object[] { "abcd", "abcd", 0, end, RichTextBoxFinds.NoHighlight, 0 };
}
yield return new object[] { "abc", "a", 1, 3, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "a", 2, 3, RichTextBoxFinds.None, -1 };
yield return new object[] { "abc", "c", 2, 3, RichTextBoxFinds.None, 2 };
yield return new object[] { "abc", "a", 1, 3, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc", "a", 2, 3, RichTextBoxFinds.Reverse, -1 };
yield return new object[] { "abc", "c", 2, 3, RichTextBoxFinds.Reverse, 2 };
yield return new object[] { "abc", "c", 0, 5, RichTextBoxFinds.None, 2 };
yield return new object[] { "abc", "c", 0, 2, RichTextBoxFinds.None, -1 };
}
[WinFormsTheory]
[MemberData(nameof(Find_String_Int_Int_RichTextBoxFinds_TestData))]
public void RichTextBox_Find_StringIntIntRichTextBoxFinds_ReturnsExpected(string text, string str, int start, int end, RichTextBoxFinds options, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.Equal(expected, control.Find(str, start, end, options));
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(Find_String_TestData))]
public void RichTextBox_Find_StringWithHandle_ReturnsExpected(string text, string str, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.Find(str));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(Find_String_RichTextBoxFinds_TestData))]
public void RichTextBox_Find_StringRichTextBoxFindsWithHandle_ReturnsExpected(string text, string str, RichTextBoxFinds options, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.Find(str, options));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(Find_String_Int_RichTextBoxFinds_TestData))]
public void RichTextBox_Find_StringIntRichTextBoxFindsWithHandle_ReturnsExpected(string text, string str, int start, RichTextBoxFinds options, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.Find(str, start, options));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(Find_String_Int_Int_RichTextBoxFinds_TestData))]
public void RichTextBox_Find_StringIntIntRichTextBoxFindsWithHandle_ReturnsExpected(string text, string str, int start, int end, RichTextBoxFinds options, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.Find(str, start, end, options));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> Find_CharArray_TestData()
{
yield return new object[] { string.Empty, Array.Empty<char>(), -1 };
yield return new object[] { string.Empty, new char[] { 'a', 'b', 'c' }, -1 };
yield return new object[] { "abc", Array.Empty<char>(), -1 };
yield return new object[] { "abc", new char[] { 'a' }, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b' }, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b', 'c' }, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b', 'c', 'd' }, 0 };
yield return new object[] { "abc", new char[] { 'c', 'b', 'a' }, 0 };
yield return new object[] { "abc", new char[] { 'c', 'b' }, 1 };
yield return new object[] { "abc", new char[] { 'b' }, 1 };
yield return new object[] { "abc", new char[] { 'd' }, -1 };
yield return new object[] { "abc", new char[] { 'A', 'B', 'C' }, -1 };
yield return new object[] { "aa", new char[] { 'a' }, 0 };
yield return new object[] { "abc def", new char[] { 'e', 'f' }, 5 };
yield return new object[] { "abc def", new char[] { 'd', 'e', 'f' }, 4 };
yield return new object[] { "abc def", new char[] { ' ' }, 3 };
yield return new object[] { "ab\u0640cd", new char[] { 'a', 'b', 'c', 'd' }, 0 };
yield return new object[] { "ab\u0640cd", new char[] { '\u0640' }, 2 };
yield return new object[] { "ab\u0640cd", new char[] { 'b', 'c' }, 1 };
}
[WinFormsTheory]
[MemberData(nameof(Find_CharArray_TestData))]
public void RichTextBox_Find_CharArray_ReturnsExpected(string text, char[] characterSet, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.Equal(expected, control.Find(characterSet));
Assert.True(control.IsHandleCreated);
}
public static IEnumerable<object[]> Find_CharArray_Int_TestData()
{
yield return new object[] { string.Empty, Array.Empty<char>(), 0, -1 };
yield return new object[] { string.Empty, new char[] { 'a', 'b', 'c' }, 0, -1 };
yield return new object[] { "abc", Array.Empty<char>(), 0, -1 };
yield return new object[] { "abc", new char[] { 'a' }, 0, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b' }, 0, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b', 'c' }, 0, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b', 'c', 'd' }, 0, 0 };
yield return new object[] { "abc", new char[] { 'c', 'b', 'a' }, 0, 0 };
yield return new object[] { "abc", new char[] { 'c', 'b' }, 0, 1 };
yield return new object[] { "abc", new char[] { 'b' }, 0, 1 };
yield return new object[] { "abc", new char[] { 'd' }, 0, -1 };
yield return new object[] { "abc", new char[] { 'A', 'B', 'C' }, 0, -1 };
yield return new object[] { "aa", new char[] { 'a' }, 0, 0 };
yield return new object[] { "abc def", new char[] { 'e', 'f' }, 0, 5 };
yield return new object[] { "abc def", new char[] { 'd', 'e', 'f' }, 0, 4 };
yield return new object[] { "abc def", new char[] { ' ' }, 0, 3 };
yield return new object[] { "ab\u0640cd", new char[] { 'a', 'b', 'c', 'd' }, 0, 0 };
yield return new object[] { "ab\u0640cd", new char[] { '\u0640' }, 0, 2 };
yield return new object[] { "ab\u0640cd", new char[] { 'b', 'c' }, 0, 1 };
yield return new object[] { "abc", new char[] { 'a' }, 1, -1 };
yield return new object[] { "abc", new char[] { 'a' }, 2, -1 };
yield return new object[] { "abc", new char[] { 'c' }, 2, 2 };
}
[WinFormsTheory]
[MemberData(nameof(Find_CharArray_Int_TestData))]
public void RichTextBox_Find_CharArrayInt_ReturnsExpected(string text, char[] characterSet, int start, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.Equal(expected, control.Find(characterSet, start));
Assert.True(control.IsHandleCreated);
}
public static IEnumerable<object[]> Find_CharArray_Int_Int_TestData()
{
foreach (int end in new int[] { -1, 0 })
{
yield return new object[] { string.Empty, Array.Empty<char>(), 0, end, -1 };
yield return new object[] { string.Empty, new char[] { 'a', 'b', 'c' }, 0, end, -1 };
yield return new object[] { "abc", Array.Empty<char>(), 0, end, -1 };
yield return new object[] { "abc", new char[] { 'a' }, 0, end, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b' }, 0, end, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b', 'c' }, 0, end, 0 };
yield return new object[] { "abc", new char[] { 'a', 'b', 'c', 'd' }, 0, end, 0 };
yield return new object[] { "abc", new char[] { 'c', 'b', 'a' }, 0, end, 0 };
yield return new object[] { "abc", new char[] { 'c', 'b' }, 0, end, 1 };
yield return new object[] { "abc", new char[] { 'b' }, 0, end, 1 };
yield return new object[] { "abc", new char[] { 'd' }, 0, end, -1 };
yield return new object[] { "abc", new char[] { 'A', 'B', 'C' }, 0, end, -1 };
yield return new object[] { "aa", new char[] { 'a' }, 0, end, 0 };
yield return new object[] { "abc def", new char[] { 'e', 'f' }, 0, end, 5 };
yield return new object[] { "abc def", new char[] { 'd', 'e', 'f' }, 0, end, 4 };
yield return new object[] { "abc def", new char[] { ' ' }, 0, end, 3 };
yield return new object[] { "ab\u0640cd", new char[] { 'a', 'b', 'c', 'd' }, 0, end, 0 };
yield return new object[] { "ab\u0640cd", new char[] { '\u0640' }, 0, end, 2 };
yield return new object[] { "ab\u0640cd", new char[] { 'b', 'c' }, 0, end, 1 };
}
yield return new object[] { "abc", new char[] { 'a' }, 1, 3, -1 };
yield return new object[] { "abc", new char[] { 'a' }, 2, 3, -1 };
yield return new object[] { "abc", new char[] { 'c' }, 2, 3, 2 };
yield return new object[] { "abc", new char[] { 'c' }, 0, 5, 2 };
yield return new object[] { "abc", new char[] { 'c' }, 0, 2, -1 };
}
[WinFormsTheory]
[MemberData(nameof(Find_CharArray_Int_Int_TestData))]
public void RichTextBox_Find_CharArrayIntInt_ReturnsExpected(string text, char[] characterSet, int start, int end, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.Equal(expected, control.Find(characterSet, start, end));
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(Find_CharArray_TestData))]
public void RichTextBox_Find_CharArrayWithHandle_ReturnsExpected(string text, char[] characterSet, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.Find(characterSet));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(Find_CharArray_Int_TestData))]
public void RichTextBox_Find_CharArrayIntWithHandle_ReturnsExpected(string text, char[] characterSet, int start, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.Find(characterSet, start));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(Find_CharArray_Int_Int_TestData))]
public void RichTextBox_Find_CharArrayIntIntWithHandle_ReturnsExpected(string text, char[] characterSet, int start, int end, int expected)
{
using RichTextBox control = new()
{
Text = text
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(expected, control.Find(characterSet, start, end));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_Find_NullStrEmpty_ThrowsArgumentNullException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentNullException>("str", () => control.Find((string)null));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, -1, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 1, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, -1, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 1, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, -2, RichTextBoxFinds.None));
}
[WinFormsFact]
public void RichTextBox_Find_NullStrNotEmpty_ThrowsArgumentNullException()
{
using RichTextBox control = new()
{
Text = "t"
};
Assert.Throws<ArgumentNullException>("str", () => control.Find((string)null));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, -1, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 2, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, -1, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 2, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, -2, RichTextBoxFinds.None));
}
[WinFormsFact]
public void RichTextBox_Find_NullCharacterSetEmpty_ThrowsArgumentNullException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find((char[])null));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, -1));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 1));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0, 0));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, -1, 0));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 1, 0));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0, -2));
}
[WinFormsFact]
public void RichTextBox_Find_NullCharacterSetNotEmpty_ThrowsArgumentNullException()
{
using RichTextBox control = new()
{
Text = "t"
};
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find((char[])null));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, -1));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 2));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0, 0));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, -1, 0));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 2, 0));
Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0, -2));
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(1)]
public void RichTextBox_Find_InvalidStartEmpty_ThrowsArgumentOutOfRangeException(int start)
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find("s", start, RichTextBoxFinds.NoHighlight));
Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find("s", start, 0, RichTextBoxFinds.NoHighlight));
Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find(['s'], start));
Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find(['s'], start, 0));
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(2)]
public void RichTextBox_Find_InvalidStartNotEmpty_ThrowsArgumentOutOfRangeException(int start)
{
using RichTextBox control = new()
{
Text = "t"
};
Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find("s", start, RichTextBoxFinds.NoHighlight));
Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find("s", start, 0, RichTextBoxFinds.NoHighlight));
Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find(['s'], start));
Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find(['s'], start, 0));
}
[WinFormsFact]
public void RichTextBox_Find_InvalidEndEmpty_ThrowsArgumentOutOfRangeException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find("s", 0, -2, RichTextBoxFinds.NoHighlight));
Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find(['s'], 0, -2));
}
[WinFormsFact]
public void RichTextBox_Find_InvalidEndNotEmpty_ThrowsArgumentOutOfRangeException()
{
using RichTextBox control = new()
{
Text = "t"
};
Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find("s", 0, -2, RichTextBoxFinds.NoHighlight));
Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find(['s'], 0, -2));
}
[WinFormsFact]
public void RichTextBox_Find_StartGreaterThanEnd_ThrowsArgumentOutOfRangeException()
{
using RichTextBox control = new()
{
Text = "t"
};
Assert.Throws<ArgumentException>(() => control.Find("s", 1, 0, RichTextBoxFinds.None));
Assert.Throws<ArgumentException>(() => control.Find("s", 1, 0, RichTextBoxFinds.Reverse));
Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find(['s'], 1, 0));
Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find(['s'], 1, 0));
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokePlainTextEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
control.LoadFile(stream, RichTextBoxStreamType.PlainText);
Assert.Empty(control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokePlainTextNotEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
byte[] buffer = Encoding.ASCII.GetBytes("Hello World");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
control.LoadFile(stream, RichTextBoxStreamType.PlainText);
Assert.Equal("Hello World", control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokePlainTextEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.LoadFile(stream, RichTextBoxStreamType.PlainText);
Assert.Empty(control.Text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokePlainTextNotEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
byte[] buffer = Encoding.ASCII.GetBytes("Hello World");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
control.LoadFile(stream, RichTextBoxStreamType.PlainText);
Assert.Equal("Hello World", control.Text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokePlainTextWithRtf_Success()
{
using RichTextBox control = new()
{
Rtf = "{\\rtf1OldText}"
};
using MemoryStream stream = new();
byte[] buffer = Encoding.ASCII.GetBytes("Hello World");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
control.LoadFile(stream, RichTextBoxStreamType.PlainText);
Assert.Equal("Hello World", control.Text);
Assert.DoesNotContain("OldText", control.Rtf);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokeUnicodeTextEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
Assert.Empty(control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokeUnicodeTextNotEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
byte[] buffer = Encoding.Unicode.GetBytes("Hello World");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
Assert.Equal("Hello World", control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokeUnicodeTextEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
Assert.Empty(control.Text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokeUnicodeTextNotEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
byte[] buffer = Encoding.Unicode.GetBytes("Hello World");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
Assert.Equal("Hello World", control.Text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokeUnicodeTextWithRtf_Success()
{
using RichTextBox control = new()
{
Rtf = "{\\rtf1OldText}"
};
using MemoryStream stream = new();
byte[] buffer = Encoding.Unicode.GetBytes("Hello World");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
Assert.Equal("Hello World", control.Text);
Assert.DoesNotContain("OldText", control.Rtf);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokeRichTextNotEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
byte[] buffer = Encoding.ASCII.GetBytes("{\\rtf1Hello World}");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
control.LoadFile(stream, RichTextBoxStreamType.RichText);
Assert.Equal("Hello World", control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvokeRichTextWithRtf_Success()
{
using RichTextBox control = new()
{
Rtf = "{\\rtf1OldText}"
};
using MemoryStream stream = new();
byte[] buffer = Encoding.ASCII.GetBytes("{\\rtf1Hello World}");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
control.LoadFile(stream, RichTextBoxStreamType.RichText);
Assert.Equal("Hello World", control.Text);
Assert.DoesNotContain("OldText", control.Rtf);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_NullData_ThrowsArgumentNullException()
{
using RichTextBox control = new();
Assert.Throws<ArgumentNullException>("data", () => control.LoadFile((Stream)null, RichTextBoxStreamType.RichText));
}
[WinFormsTheory]
[InvalidEnumData<RichTextBoxStreamType>]
public void RichTextBox_LoadFile_InvalidFileType_ThrowsInvalidEnumArgumentException(RichTextBoxStreamType fileType)
{
using RichTextBox control = new();
using MemoryStream stream = new();
Assert.Throws<InvalidEnumArgumentException>("fileType", () => control.LoadFile(stream, fileType));
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(RichTextBoxStreamType.RichNoOleObjs)]
[InlineData(RichTextBoxStreamType.TextTextOleObjs)]
public void RichTextBox_LoadFile_UnprocessableFileType_ThrowsArgumentException(RichTextBoxStreamType fileType)
{
using RichTextBox control = new();
using MemoryStream stream = new();
Assert.Throws<ArgumentException>(() => control.LoadFile(stream, fileType));
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_RichTextEmpty_ThrowsArgumentException()
{
using RichTextBox control = new();
using MemoryStream stream = new();
Assert.Throws<ArgumentException>(() => control.LoadFile(stream, RichTextBoxStreamType.RichText));
Assert.Empty(control.Text);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_LoadFile_InvalidRtf_ThrowsArgumentException()
{
using RichTextBox control = new();
using MemoryStream stream = new();
byte[] buffer = Encoding.ASCII.GetBytes("Hello World");
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
Assert.Throws<ArgumentException>(() => control.LoadFile(stream, RichTextBoxStreamType.RichText));
}
[WinFormsFact]
public void RichTextBox_GetAutoSizeMode_Invoke_ReturnsExpected()
{
using SubRichTextBox control = new();
Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_GetLineFromCharIndex_InvokeEmpty_Success(int index)
{
using RichTextBox control = new();
Assert.Equal(0, control.GetLineFromCharIndex(index));
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
[InlineData(4)]
[InlineData(5)]
public void RichTextBox_GetLineFromCharIndex_InvokeNotEmpty_Success(int index)
{
using RichTextBox control = new()
{
Text = "text"
};
Assert.Equal(0, control.GetLineFromCharIndex(index));
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
public void RichTextBox_GetLineFromCharIndex_InvokeEmptyWithHandle_Success(int index)
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.GetLineFromCharIndex(index));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[InlineData(-1)]
[InlineData(0)]
[InlineData(1)]
[InlineData(4)]
[InlineData(5)]
public void RichTextBox_GetLineFromCharIndex_InvokeNotEmptyWithHandle_Success(int index)
{
using RichTextBox control = new()
{
Text = "text"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Assert.Equal(0, control.GetLineFromCharIndex(index));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> GetLineFromCharIndex_CustomLineFromChar_TestData()
{
yield return new object[] { (IntPtr)(-1) };
yield return new object[] { IntPtr.Zero };
yield return new object[] { (IntPtr)1 };
yield return new object[] { (IntPtr)int.MaxValue };
yield return new object[] { PARAM.FromLowHigh(1, 2) };
yield return new object[] { PARAM.FromLowHigh(int.MaxValue, int.MaxValue) };
}
[WinFormsTheory]
[MemberData(nameof(GetLineFromCharIndex_CustomLineFromChar_TestData))]
public void RichTextBox_GetLineFromCharIndex_CustomLineFromChar_Success(IntPtr result)
{
using CustomLineFromCharRichTextBox control = new()
{
LineFromCharResult = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(0, control.GetLineFromCharIndex(1));
}
private class CustomLineFromCharRichTextBox : RichTextBox
{
public IntPtr LineFromCharResult { get; set; }
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_LINEFROMCHAR)
{
Assert.Equal(1, m.WParam);
Assert.Equal(IntPtr.Zero, m.LParam);
m.Result = LineFromCharResult;
return;
}
base.WndProc(ref m);
}
}
public static IEnumerable<object[]> GetLineFromCharIndex_CustomExLineFromChar_TestData()
{
yield return new object[] { (IntPtr)(-1), -1 };
yield return new object[] { IntPtr.Zero, 0 };
yield return new object[] { (IntPtr)1, 1 };
yield return new object[] { (IntPtr)int.MaxValue, 0x7FFFFFFF };
yield return new object[] { PARAM.FromLowHigh(1, 2), 0x20001 };
yield return new object[] { PARAM.FromLowHigh(int.MaxValue, int.MaxValue), -1 };
}
[WinFormsTheory]
[MemberData(nameof(GetLineFromCharIndex_CustomExLineFromChar_TestData))]
public void RichTextBox_GetLineFromCharIndex_CustomExLineFromChar_Success(IntPtr result, int expected)
{
using CustomExLineFromCharRichTextBox control = new()
{
ExLineFromCharResult = result
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
Assert.Equal(expected, control.GetLineFromCharIndex(1));
}
private class CustomExLineFromCharRichTextBox : RichTextBox
{
public IntPtr ExLineFromCharResult { get; set; }
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)PInvoke.EM_EXLINEFROMCHAR)
{
Assert.Equal(IntPtr.Zero, m.WParam);
Assert.Equal(1, m.LParam);
m.Result = ExLineFromCharResult;
return;
}
base.WndProc(ref m);
}
}
[WinFormsTheory]
[InlineData(ControlStyles.ContainerControl, false)]
[InlineData(ControlStyles.UserPaint, false)]
[InlineData(ControlStyles.Opaque, false)]
[InlineData(ControlStyles.ResizeRedraw, false)]
[InlineData(ControlStyles.FixedWidth, false)]
[InlineData(ControlStyles.FixedHeight, false)]
[InlineData(ControlStyles.StandardClick, false)]
[InlineData(ControlStyles.Selectable, true)]
[InlineData(ControlStyles.UserMouse, false)]
[InlineData(ControlStyles.SupportsTransparentBackColor, false)]
[InlineData(ControlStyles.StandardDoubleClick, false)]
[InlineData(ControlStyles.AllPaintingInWmPaint, true)]
[InlineData(ControlStyles.CacheText, false)]
[InlineData(ControlStyles.EnableNotifyMessage, false)]
[InlineData(ControlStyles.DoubleBuffer, false)]
[InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
[InlineData(ControlStyles.UseTextForAccessibility, false)]
[InlineData((ControlStyles)0, true)]
[InlineData((ControlStyles)int.MaxValue, false)]
[InlineData((ControlStyles)(-1), false)]
public void RichTextBox_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
{
using SubRichTextBox control = new();
Assert.Equal(expected, control.GetStyle(flag));
// Call again to test caching.
Assert.Equal(expected, control.GetStyle(flag));
}
[WinFormsFact]
public void RichTextBox_GetTopLevel_Invoke_ReturnsExpected()
{
using SubRichTextBox control = new();
Assert.False(control.GetTopLevel());
}
[WinFormsTheory]
[NewAndDefaultData<EventArgs>]
public void RichTextBox_OnBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
{
using SubRichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.BackColorChanged += handler;
control.OnBackColorChanged(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
// Remove handler.
control.BackColorChanged -= handler;
control.OnBackColorChanged(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[NewAndDefaultData<EventArgs>]
public void RichTextBox_OnBackColorChanged_InvokeWithHandle_CallsBackColorChanged(EventArgs eventArgs)
{
using SubRichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.BackColorChanged += handler;
control.OnBackColorChanged(eventArgs);
Assert.Equal(1, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(1, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Remove handler.
control.BackColorChanged -= handler;
control.OnBackColorChanged(eventArgs);
Assert.Equal(1, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(2, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> OnContentsResized_TestData()
{
yield return new object[] { null };
yield return new object[] { new ContentsResizedEventArgs(new Rectangle()) };
}
[WinFormsTheory]
[MemberData(nameof(OnContentsResized_TestData))]
public void RichTextBox_OnContentsResized_Invoke_CallsContentsResized(ContentsResizedEventArgs eventArgs)
{
using SubRichTextBox control = new();
int layoutCallCount = 0;
control.Layout += (sender, e) => layoutCallCount++;
int resizeCallCount = 0;
control.Resize += (sender, e) => resizeCallCount++;
int callCount = 0;
ContentsResizedEventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.ContentsResized += handler;
control.OnContentsResized(eventArgs);
Assert.Equal(1, callCount);
Assert.Equal(0, layoutCallCount);
Assert.Equal(0, resizeCallCount);
Assert.False(control.IsHandleCreated);
// Remove handler.
control.ContentsResized -= handler;
control.OnContentsResized(eventArgs);
Assert.Equal(1, callCount);
Assert.Equal(0, layoutCallCount);
Assert.Equal(0, resizeCallCount);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[NewAndDefaultData<EventArgs>]
public void RichTextBox_OnHScroll_Invoke_CallsHScroll(EventArgs eventArgs)
{
using SubRichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.HScroll += handler;
control.OnHScroll(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
// Remove handler.
control.HScroll -= handler;
control.OnHScroll(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[NewAndDefaultData<EventArgs>]
public void RichTextBox_OnImeChange_Invoke_CallsImeChange(EventArgs eventArgs)
{
using SubRichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.ImeChange += handler;
control.OnImeChange(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
// Remove handler.
control.ImeChange -= handler;
control.OnImeChange(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> OnLinkClicked_TestData()
{
yield return new object[] { null };
yield return new object[] { new LinkClickedEventArgs(null) };
yield return new object[] { new LinkClickedEventArgs("") };
yield return new object[] { new LinkClickedEventArgs("text") };
yield return new object[] { new LinkClickedEventArgs("", 10, 0) };
yield return new object[] { new LinkClickedEventArgs("text", 10, 4) };
}
[WinFormsTheory]
[MemberData(nameof(OnLinkClicked_TestData))]
public void RichTextBox_OnLinkClicked_Invoke_CallsLinkClicked(LinkClickedEventArgs eventArgs)
{
using SubRichTextBox control = new();
int callCount = 0;
LinkClickedEventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.LinkClicked += handler;
control.OnLinkClicked(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
// Remove handler.
control.LinkClicked -= handler;
control.OnLinkClicked(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
}
public static IEnumerable<object[]> RichTextBox_InvalidLinkClickedEventArgs_TestData()
{
yield return new object[] { -1, 0 };
yield return new object[] { 0, -1 };
yield return new object[] { int.MaxValue, 1 };
yield return new object[] { 1, int.MaxValue };
}
[WinFormsTheory]
[MemberData(nameof(RichTextBox_InvalidLinkClickedEventArgs_TestData))]
public void RichTextBox_InvalidLinkClickedEventArgs_ThrowsArgumentOutOfRangeException(int linkStart, int linkLength)
{
Assert.Throws<ArgumentOutOfRangeException>(() => new LinkClickedEventArgs("text", linkStart, linkLength));
}
[WinFormsTheory]
[NewAndDefaultData<EventArgs>]
public void RichTextBox_OnProtected_Invoke_CallsProtected(EventArgs eventArgs)
{
using SubRichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.Protected += handler;
control.OnProtected(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
// Remove handler.
control.Protected -= handler;
control.OnProtected(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[NewAndDefaultData<EventArgs>]
public void RichTextBox_OnSelectionChanged_Invoke_CallsSelectionChanged(EventArgs eventArgs)
{
using SubRichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.SelectionChanged += handler;
control.OnSelectionChanged(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
// Remove handler.
control.SelectionChanged -= handler;
control.OnSelectionChanged(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
}
[WinFormsTheory]
[NewAndDefaultData<EventArgs>]
public void RichTextBox_OnVScroll_Invoke_CallsVScroll(EventArgs eventArgs)
{
using SubRichTextBox control = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
control.VScroll += handler;
control.OnVScroll(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
// Remove handler.
control.VScroll -= handler;
control.OnVScroll(eventArgs);
Assert.Equal(1, callCount);
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_Redo_Invoke_Success()
{
using RichTextBox control = new();
control.Redo();
Assert.True(control.IsHandleCreated);
// Call again.
control.Redo();
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_Redo_InvokeWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.Redo();
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
// Call again.
control.Redo();
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokePlainTextEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.PlainText);
Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokePlainTextNotEmpty_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.PlainText);
Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokePlainTextEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.PlainText);
Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokePlainTextNotEmptyWithHandle_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.PlainText);
Assert.Equal("Hello World", Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeUnicodeTextEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.PlainText);
Assert.Empty(Encoding.Unicode.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeUnicodeTextNotEmpty_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.PlainText);
Assert.Empty(Encoding.Unicode.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeUnicodePlainTextEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.UnicodePlainText);
Assert.Empty(Encoding.Unicode.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeUnicodePlainTextNotEmptyWithHandle_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.UnicodePlainText);
Assert.Equal("Hello World", Encoding.Unicode.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeRichTextEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.RichText);
string text = Encoding.ASCII.GetString(stream.ToArray());
Assert.StartsWith("{\\rtf", text);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeRichTextNotEmpty_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.RichText);
Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeRichTextEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.RichText);
string text = Encoding.ASCII.GetString(stream.ToArray());
Assert.StartsWith("{\\rtf", text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeRichTextNotEmptyWithHandle_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.RichText);
string text = Encoding.ASCII.GetString(stream.ToArray());
Assert.StartsWith("{\\rtf", text);
Assert.Contains("Hello World", text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeTextTextOleObjsEmpty_Success()
{
using RichTextBox control = new();
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.TextTextOleObjs);
Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeTextTextOleObjsNotEmpty_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.TextTextOleObjs);
Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeTextTextOleObjsEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.TextTextOleObjs);
Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeTextTextOleObjsNotEmptyWithHandle_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.TextTextOleObjs);
Assert.Equal("Hello World", Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeRichNoOleObjsNotEmpty_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.RichNoOleObjs);
Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeRichNoOleObjsEmptyWithHandle_Success()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.RichNoOleObjs);
string text = Encoding.ASCII.GetString(stream.ToArray());
Assert.StartsWith("{\\rtf", text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_InvokeRichNoOleObjsNotEmptyWithHandle_Success()
{
using RichTextBox control = new()
{
Text = "Hello World"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
using MemoryStream stream = new();
control.SaveFile(stream, RichTextBoxStreamType.RichNoOleObjs);
string text = Encoding.ASCII.GetString(stream.ToArray());
Assert.StartsWith("{\\rtf", text);
Assert.Contains("Hello World", text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_SaveFile_NullData_Nop()
{
using RichTextBox control = new();
control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_NullDataWithText_Nop()
{
using RichTextBox control = new()
{
Text = "Text"
};
control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_NullDataWithHandle_Nop()
{
using RichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SaveFile_NullDataWithTextWithHandle_Nop()
{
using RichTextBox control = new()
{
Text = "Text"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[InvalidEnumData<RichTextBoxStreamType>]
public void RichTextBox_SaveFile_InvalidFileType_ThrowsInvalidEnumArgumentException(RichTextBoxStreamType fileType)
{
using RichTextBox control = new();
using MemoryStream stream = new();
Assert.Throws<InvalidEnumArgumentException>("fileType", () => control.SaveFile(stream, fileType));
Assert.False(control.IsHandleCreated);
}
[WinFormsFact]
public void RichTextBox_SetAnsiRtf_DoesNotCorrupt()
{
// RichTextBox.Rtf treats input as code page specific (i.e. not Unicode). To see
// that we're actually using the code page we'll set the text to 0xA0 (160 / nbsp) to see
// that we can get it back out. If the encoding is not done in the codepage we'll likely
// get multiple ASCII bytes back out. UTF-8, for example, encodes the .NET UTF-16 0x00A0 (160)
// to 0xC2 0xA0.
// Ultimately we should really update RichTextBox to always stream data in Unicode as
// we're hard-coded to load 4.1 (see RichTextBox.CreateParams).
using RichTextBox control = new();
char input = (char)0xA0;
control.Rtf = $"{{\\rtf1\\ansi {input}}}";
Span<byte> output = stackalloc byte[16];
int currentCodePage = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).CodePage;
// The non-lossy conversion of nbsp only works single byte Windows code pages (e.g. not Japanese).
if (currentCodePage is >= 1250 and <= 1258)
{
Assert.Equal(input, control.Text[0]);
}
}
public static IEnumerable<object[]> WndProc_GetDlgCode_TestData()
{
yield return new object[] { true, (IntPtr)2 };
yield return new object[] { false, IntPtr.Zero };
}
[WinFormsTheory]
[MemberData(nameof(WndProc_GetDlgCode_TestData))]
public void RichTextBox_WndProc_InvokeGetDlgCodeWithoutHandle_ReturnsExpected(bool acceptsTabs, IntPtr expectedResult)
{
using (new NoAssertContext())
{
using SubRichTextBox control = new()
{
AcceptsTab = acceptsTabs
};
Message m = new()
{
Msg = (int)PInvoke.WM_GETDLGCODE,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(expectedResult, m.Result);
Assert.False(control.IsHandleCreated);
}
}
[WinFormsTheory]
[MemberData(nameof(WndProc_GetDlgCode_TestData))]
public void RichTextBox_WndProc_InvokeGetDlgCodeWithHandle_ReturnsExpected(bool acceptsTabs, IntPtr expectedResult)
{
using SubRichTextBox control = new()
{
AcceptsTab = acceptsTabs
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
Message m = new()
{
Msg = (int)PInvoke.WM_GETDLGCODE,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(expectedResult, m.Result);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_WndProc_InvokeImeNotifyCallCountWithoutHandle_Success()
{
using (new NoAssertContext())
{
using SubRichTextBox control = new();
int imeModeChangedCallCount = 0;
control.ImeModeChanged += (sender, e) => imeModeChangedCallCount++;
int imeChangeCallCount = 0;
control.ImeChange += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
imeChangeCallCount++;
};
Message m = new()
{
Msg = (int)PInvoke.WM_IME_NOTIFY,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(IntPtr.Zero, m.Result);
Assert.Equal(0, imeModeChangedCallCount);
Assert.Equal(1, imeChangeCallCount);
Assert.False(control.IsHandleCreated);
}
}
[WinFormsFact]
public void RichTextBox_WndProc_InvokeImeNotifyCallCountWithHandle_Success()
{
using SubRichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int imeModeChangedCallCount = 0;
control.ImeModeChanged += (sender, e) => imeModeChangedCallCount++;
int imeChangeCallCount = 0;
control.ImeChange += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
imeChangeCallCount++;
};
Message m = new()
{
Msg = (int)PInvoke.WM_IME_NOTIFY,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(IntPtr.Zero, m.Result);
Assert.Equal(0, imeModeChangedCallCount);
Assert.Equal(1, imeChangeCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_WndProc_InvokeMouseHoverWithHandle_Success()
{
using SubRichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int callCount = 0;
control.MouseHover += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
callCount++;
};
Message m = new()
{
Msg = (int)PInvoke.WM_MOUSEHOVER,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(IntPtr.Zero, m.Result);
Assert.Equal(1, callCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> WndProc_ReflectCommand_TestData()
{
foreach (IntPtr lParam in new IntPtr[] { IntPtr.Zero, 1 })
{
yield return new object[] { IntPtr.Zero, lParam, 0 };
yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_CHANGE), lParam, 1 };
yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_UPDATE), lParam, 0 };
yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_CHANGE), lParam, 1 };
yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_HSCROLL), lParam, 0 };
yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_VSCROLL), lParam, 0 };
yield return new object[] { PARAM.FromLowHigh(123, 456), lParam, 0 };
}
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectCommand_TestData))]
public void RichTextBox_WndProc_InvokeReflectCommandWithoutHandle_Success(IntPtr wParam, IntPtr lParam, int expectedTextChangedCallCount)
{
using SubRichTextBox control = new();
int textChangedCallCount = 0;
control.TextChanged += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
textChangedCallCount++;
};
int modifiedCallCount = 0;
control.ModifiedChanged += (sender, e) => modifiedCallCount++;
int hScrollCallCount = 0;
control.HScroll += (sender, e) => hScrollCallCount++;
int vScrollCallCount = 0;
control.VScroll += (sender, e) => vScrollCallCount++;
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_COMMAND),
WParam = wParam,
LParam = lParam,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(250, m.Result);
Assert.Equal(expectedTextChangedCallCount, textChangedCallCount);
Assert.Equal(0, hScrollCallCount);
Assert.Equal(0, vScrollCallCount);
Assert.Equal(0, modifiedCallCount);
Assert.True(control.IsHandleCreated);
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectCommand_TestData))]
public void RichTextBox_WndProc_InvokeReflectCommandWithHandle_Success(IntPtr wParam, IntPtr lParam, int expectedTextChangedCallCount)
{
using SubRichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int textChangedCallCount = 0;
control.TextChanged += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
textChangedCallCount++;
};
int hScrollCallCount = 0;
control.HScroll += (sender, e) => hScrollCallCount++;
int vScrollCallCount = 0;
control.VScroll += (sender, e) => vScrollCallCount++;
int modifiedCallCount = 0;
control.ModifiedChanged += (sender, e) => modifiedCallCount++;
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_COMMAND),
WParam = wParam,
LParam = lParam,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(250, m.Result);
Assert.Equal(expectedTextChangedCallCount, textChangedCallCount);
Assert.Equal(0, hScrollCallCount);
Assert.Equal(0, vScrollCallCount);
Assert.Equal(0, modifiedCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> WndProc_ReflectCommandWithLParam_TestData()
{
yield return new object[] { IntPtr.Zero, 0, 0, 0 };
yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_CHANGE), 1, 0, 0 };
yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_UPDATE), 0, 0, 0 };
yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_CHANGE), 1, 0, 0 };
yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_HSCROLL), 0, 1, 0 };
yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_VSCROLL), 0, 0, 1 };
yield return new object[] { PARAM.FromLowHigh(123, 456), 0, 0, 0 };
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectCommandWithLParam_TestData))]
public void RichTextBox_WndProc_InvokeReflectCommandWithHandleWithLParam_Success(IntPtr wParam, int expectedTextChangedCallCount, int expectedHScrollCallCount, int expectedVScrollCallCount)
{
using SubRichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int textChangedCallCount = 0;
control.TextChanged += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
textChangedCallCount++;
};
int hScrollCallCount = 0;
control.HScroll += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
hScrollCallCount++;
};
int vScrollCallCount = 0;
control.VScroll += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
vScrollCallCount++;
};
int modifiedCallCount = 0;
control.ModifiedChanged += (sender, e) => modifiedCallCount++;
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_COMMAND),
WParam = wParam,
LParam = control.Handle,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(250, m.Result);
Assert.Equal(expectedTextChangedCallCount, textChangedCallCount);
Assert.Equal(expectedHScrollCallCount, hScrollCallCount);
Assert.Equal(expectedVScrollCallCount, vScrollCallCount);
Assert.Equal(0, modifiedCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> WndProc_ReflectNotify_TestData()
{
foreach (IntPtr hWnd in new IntPtr[] { IntPtr.Zero, 1 })
{
yield return new object[] { hWnd, (int)PInvoke.EN_LINK };
yield return new object[] { hWnd, (int)PInvoke.EN_DROPFILES };
yield return new object[] { hWnd, (int)PInvoke.EN_REQUESTRESIZE };
yield return new object[] { hWnd, (int)PInvoke.EN_SELCHANGE };
yield return new object[] { hWnd, (int)PInvoke.EN_PROTECTED };
yield return new object[] { hWnd, 0 };
}
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectNotify_TestData))]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithoutHandle_Success(IntPtr hWnd, int code)
{
using SubRichTextBox control = new();
NMHDR nmhdr = new()
{
code = (uint)code
};
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = hWnd,
LParam = (IntPtr)(&nmhdr),
Result = 250
};
control.WndProc(ref m);
Assert.Equal(0, m.Result);
Assert.True(control.IsHandleCreated);
}
[WinFormsFact]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHWndDropFiles_Success()
{
using SubRichTextBox control = new()
{
Text = "text"
};
ENDROPFILES dropFiles = new()
{
nmhdr = new NMHDR
{
code = (int)PInvoke.EN_DROPFILES
}
};
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = control.Handle,
LParam = (IntPtr)(&dropFiles),
Result = 250
};
control.WndProc(ref m);
Assert.Equal(1, m.Result);
Assert.Equal("text", control.Text);
Assert.True(control.IsHandleCreated);
}
public static IEnumerable<object[]> WndProc_ReflectNotifyWithHWndSelChange_TestData()
{
yield return new object[] { -1, -1, -1, 0 };
yield return new object[] { -2, -1, -1, 1 };
yield return new object[] { 0, -1, -1, 1 };
yield return new object[] { 1, -1, -1, 1 };
yield return new object[] { -1, -2, -1, 1 };
yield return new object[] { -1, 0, -1, 1 };
yield return new object[] { -1, 1, -1, 1 };
yield return new object[] { -1, -1, (int)RICH_EDIT_GET_CONTEXT_MENU_SEL_TYPE.SEL_EMPTY, 1 };
yield return new object[] { -1, -1, (int)RICH_EDIT_GET_CONTEXT_MENU_SEL_TYPE.SEL_TEXT, 1 };
yield return new object[] { 0, 1, (int)RICH_EDIT_GET_CONTEXT_MENU_SEL_TYPE.SEL_TEXT, 1 };
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectNotifyWithHWndSelChange_TestData))]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHWndSelChange_Success(int min, int max, int selectionType, int expectedSelectionChangedCallCount)
{
using SubRichTextBox control = new();
int selectionChangedCallCount = 0;
control.SelectionChanged += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
selectionChangedCallCount++;
};
SELCHANGE selChange = new()
{
nmhdr = new NMHDR
{
code = (int)PInvoke.EN_SELCHANGE
},
chrg = new CHARRANGE
{
cpMin = min,
cpMax = max
},
seltyp = (RICH_EDIT_GET_CONTEXT_MENU_SEL_TYPE)selectionType
};
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = control.Handle,
LParam = (IntPtr)(&selChange),
Result = 250
};
control.WndProc(ref m);
Assert.Equal(250, m.Result);
Assert.Equal(expectedSelectionChangedCallCount, selectionChangedCallCount);
Assert.Equal(0, control.SelectionLength);
Assert.Equal(0, control.SelectionStart);
Assert.True(control.IsHandleCreated);
}
public static IEnumerable<object[]> WndProc_ReflectNotifyWithHWndProtected_TestData()
{
yield return new object[] { 0, (IntPtr)1, 1 };
yield return new object[] { CFM_MASK.CFM_ALLCAPS, (IntPtr)1, 1 };
yield return new object[] { CFM_MASK.CFM_PROTECTED, IntPtr.Zero, 0 };
yield return new object[] { CFM_MASK.CFM_PROTECTED | CFM_MASK.CFM_ALLCAPS, IntPtr.Zero, 0 };
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectNotifyWithHWndProtected_TestData))]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHWndProtected_Success(int mask, IntPtr expectedResult, int expectedProtectedCallCount)
{
using SubRichTextBox control = new();
int protectedCallCount = 0;
control.Protected += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
protectedCallCount++;
};
var format = new CHARFORMAT2W
{
dwMask = (CFM_MASK)mask
};
IntPtr ptr = Marshal.AllocCoTaskMem(100);
try
{
Marshal.WriteInt32(ptr, IntPtr.Size * 2, (int)PInvoke.EN_PROTECTED);
Marshal.WriteInt32(ptr, IntPtr.Size * 2 + IntPtr.Size, (int)PInvoke.EM_SETCHARFORMAT);
Marshal.WriteIntPtr(ptr, IntPtr.Size * 2 + IntPtr.Size + 4 + IntPtr.Size, (IntPtr)(&format));
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = control.Handle,
LParam = ptr,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(expectedResult, m.Result);
Assert.Equal(expectedProtectedCallCount, protectedCallCount);
Assert.True(control.IsHandleCreated);
}
finally
{
Marshal.FreeCoTaskMem(ptr);
}
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectNotify_TestData))]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandle_Success(IntPtr hWnd, int code)
{
using SubRichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
NMHDR nmhdr = new()
{
code = (uint)code
};
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = hWnd,
LParam = (IntPtr)(&nmhdr),
Result = 250
};
control.WndProc(ref m);
Assert.Equal(0, m.Result);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandleWithHWndDropFiles_Success()
{
using SubRichTextBox control = new()
{
Text = "text"
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
ENDROPFILES dropFiles = new()
{
nmhdr = new NMHDR
{
code = (int)PInvoke.EN_DROPFILES
}
};
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = control.Handle,
LParam = (IntPtr)(&dropFiles),
Result = 250
};
control.WndProc(ref m);
Assert.Equal(1, m.Result);
Assert.Equal("text", control.Text);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
public static IEnumerable<object[]> WndProc_ReflectNotifyWithHwndRequestResize_TestData()
{
yield return new object[] { BorderStyle.Fixed3D, Rectangle.Empty, new Rectangle(0, 0, 0, 1) };
yield return new object[] { BorderStyle.FixedSingle, Rectangle.Empty, Rectangle.Empty };
yield return new object[] { BorderStyle.None, Rectangle.Empty, Rectangle.Empty };
yield return new object[] { BorderStyle.Fixed3D, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 5) };
yield return new object[] { BorderStyle.FixedSingle, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4) };
yield return new object[] { BorderStyle.None, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4) };
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectNotifyWithHwndRequestResize_TestData))]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandleWithHWndRequestResize_Success(BorderStyle borderStyle, Rectangle result, Rectangle expected)
{
using SubRichTextBox control = new()
{
BorderStyle = borderStyle
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int contentsResizedCallCount = 0;
control.ContentsResized += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Equal(expected, e.NewRectangle);
contentsResizedCallCount++;
};
int layoutCallCount = 0;
control.Layout += (sender, e) => layoutCallCount++;
int resizeCallCount = 0;
control.Resize += (sender, e) => resizeCallCount++;
REQRESIZE reqResize = new()
{
nmhdr = new NMHDR
{
code = (int)PInvoke.EN_REQUESTRESIZE
},
rc = result
};
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = control.Handle,
LParam = (IntPtr)(&reqResize),
Result = 250
};
control.WndProc(ref m);
Assert.Equal(250, m.Result);
Assert.Equal(1, contentsResizedCallCount);
Assert.Equal(0, layoutCallCount);
Assert.Equal(0, resizeCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectNotifyWithHWndSelChange_TestData))]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandleWithHWndSelChange_Success(int min, int max, int selectionType, int expectedSelectionChangedCallCount)
{
using SubRichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int selectionChangedCallCount = 0;
control.SelectionChanged += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
selectionChangedCallCount++;
};
SELCHANGE selChange = new()
{
nmhdr = new NMHDR
{
code = (int)PInvoke.EN_SELCHANGE
},
chrg = new CHARRANGE
{
cpMin = min,
cpMax = max
},
seltyp = (RICH_EDIT_GET_CONTEXT_MENU_SEL_TYPE)selectionType
};
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = control.Handle,
LParam = (IntPtr)(&selChange),
Result = 250
};
control.WndProc(ref m);
Assert.Equal(250, m.Result);
Assert.Equal(expectedSelectionChangedCallCount, selectionChangedCallCount);
Assert.Equal(0, control.SelectionLength);
Assert.Equal(0, control.SelectionStart);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsTheory]
[MemberData(nameof(WndProc_ReflectNotifyWithHWndProtected_TestData))]
public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandleWithHWndProtected_Success(int mask, IntPtr expectedResult, int expectedProtectedCallCount)
{
using SubRichTextBox control = new();
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
int protectedCallCount = 0;
control.Protected += (sender, e) =>
{
Assert.Same(control, sender);
Assert.Same(EventArgs.Empty, e);
protectedCallCount++;
};
var format = new CHARFORMAT2W
{
dwMask = (CFM_MASK)mask
};
IntPtr ptr = Marshal.AllocCoTaskMem(100);
try
{
Marshal.WriteInt32(ptr, IntPtr.Size * 2, (int)PInvoke.EN_PROTECTED);
Marshal.WriteInt32(ptr, IntPtr.Size * 2 + IntPtr.Size, (int)PInvoke.EM_SETCHARFORMAT);
Marshal.WriteIntPtr(ptr, IntPtr.Size * 2 + IntPtr.Size + 4 + IntPtr.Size, (IntPtr)(&format));
Message m = new()
{
Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
HWnd = control.Handle,
LParam = ptr,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(expectedResult, m.Result);
Assert.Equal(expectedProtectedCallCount, protectedCallCount);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
finally
{
Marshal.FreeCoTaskMem(ptr);
}
}
[WinFormsTheory]
[InlineData(true, 1)]
[InlineData(false, 0)]
public void RichTextBox_WndProc_InvokeSetFontWithoutHandle_ReturnsExpected(bool multiline, int expectedMargin)
{
using (new NoAssertContext())
{
using SubRichTextBox control = new()
{
Multiline = multiline
};
Message m = new()
{
Msg = (int)PInvoke.WM_SETFONT,
Result = 250
};
int textChangedCallCount = 0;
control.TextChanged += (sender, e) => textChangedCallCount++;
control.WndProc(ref m);
Assert.Equal(IntPtr.Zero, m.Result);
Assert.True(control.IsHandleCreated);
Assert.Equal(0, textChangedCallCount);
IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETMARGINS);
Assert.Equal(expectedMargin, PARAM.HIWORD(result));
Assert.Equal(expectedMargin, PARAM.LOWORD(result));
}
}
[WinFormsTheory]
[InlineData(true, 1, 2)]
[InlineData(false, 0, 0)]
public void RichTextBox_WndProc_InvokeSetFontWithHandle_ReturnsExpected(bool multiline, int expectedLeft, int expectedRight)
{
using SubRichTextBox control = new()
{
Multiline = multiline
};
Assert.NotEqual(IntPtr.Zero, control.Handle);
int invalidatedCallCount = 0;
control.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
control.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
control.HandleCreated += (sender, e) => createdCallCount++;
PInvoke.SendMessage(control, PInvoke.EM_SETMARGINS, (WPARAM)(PInvoke.EC_LEFTMARGIN | PInvoke.EC_RIGHTMARGIN), LPARAM.MAKELPARAM(1, 2));
int textChangedCallCount = 0;
control.TextChanged += (sender, e) => textChangedCallCount++;
Message m = new()
{
Msg = (int)PInvoke.WM_SETFONT,
Result = 250
};
control.WndProc(ref m);
Assert.Equal(IntPtr.Zero, m.Result);
Assert.Equal(0, textChangedCallCount);
IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETMARGINS);
Assert.Equal(expectedLeft, PARAM.LOWORD(result));
Assert.Equal(expectedRight, PARAM.HIWORD(result));
Assert.True(control.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
[WinFormsFact]
public void RichTextBox_CheckDefaultNativeControlVersions()
{
using RichTextBox control = new();
control.CreateControl();
Assert.Contains("RICHEDIT50W", GetClassName(control.HWND), StringComparison.Ordinal);
}
[WinFormsFact]
public void RichTextBox_CheckRichEditWithVersionCanCreateOldVersions()
{
using (RichEdit riched32 = new())
{
riched32.CreateControl();
Assert.Contains(".RichEdit.", GetClassName(riched32.HWND), StringComparison.Ordinal);
}
using var riched20 = new RichEdit20W();
riched20.CreateControl();
Assert.Contains(".RichEdit20W.", GetClassName(riched20.HWND), StringComparison.Ordinal);
string rtfString = @"{\rtf1\ansi{" +
@"The next line\par " +
@"is {\v ###NOT### }hidden\par in plain text!}}";
riched20.Rtf = rtfString;
using RichTextBox richTextBox = new();
richTextBox.CreateControl();
richTextBox.Rtf = rtfString;
Assert.Equal(riched20.TextLength, richTextBox.TextLength);
Assert.Equal(riched20.Text, richTextBox.Text);
Assert.Equal(richTextBox.Text.Length, richTextBox.TextLength);
int startOfIs = riched20.Text.IndexOf("is", StringComparison.Ordinal);
int endOfHidden = riched20.Text.IndexOf("hidden", StringComparison.Ordinal) + "hidden".Length;
richTextBox.Select(startOfIs, endOfHidden - startOfIs);
Assert.Equal("is ###NOT### hidden", richTextBox.SelectedText);
}
[WinFormsTheory]
[NewAndDefaultData<EventArgs>]
public void RichTextBox_OnGotFocus_RaisesAutomationNotification_WithText(EventArgs eventArgs)
{
Mock<Control> mockParent = new() { CallBase = true };
Mock<Control.ControlAccessibleObject> mockAccessibleObject = new(MockBehavior.Strict, mockParent.Object);
mockAccessibleObject
.Setup(a => a.InternalRaiseAutomationNotification(
It.IsAny<AutomationNotificationKind>(),
It.IsAny<AutomationNotificationProcessing>(),
It.IsAny<string>()))
.Returns(true)
.Verifiable();
mockParent.Protected().Setup<AccessibleObject>("CreateAccessibilityInstance")
.Returns(mockAccessibleObject.Object);
using Control parent = mockParent.Object;
string richTextBoxContent = "RichTextBox";
using SubRichTextBox control = new()
{
Parent = parent,
Text = richTextBoxContent,
};
// Enforce accessible object creation
Assert.Equal(mockAccessibleObject.Object, parent.AccessibilityObject);
control.OnGotFocus(eventArgs);
mockAccessibleObject.Verify(a => a.InternalRaiseAutomationNotification(
AutomationNotificationKind.Other,
AutomationNotificationProcessing.MostRecent,
richTextBoxContent),
Times.Once);
}
[WinFormsTheory]
[InlineData(-1, -1, 0)]
[InlineData(0, 0, 0)]
[InlineData(10, 10, 1)]
public void RichTextBox_GetCharIndexFromPosition_Invoke_ReturnsExpected(int x, int y, int expectedIndex)
{
using RichTextBox richTextBox1 = new();
richTextBox1.Text = "Hello, World!";
Assert.NotEqual(0, richTextBox1.Handle);
int invalidatedCallCount = 0;
richTextBox1.Invalidated += (sender, e) => invalidatedCallCount++;
int styleChangedCallCount = 0;
richTextBox1.StyleChanged += (sender, e) => styleChangedCallCount++;
int createdCallCount = 0;
richTextBox1.HandleCreated += (sender, e) => createdCallCount++;
Point pt = new(x, y);
int index = richTextBox1.GetCharIndexFromPosition(pt);
Assert.Equal(expectedIndex, index);
Assert.True(richTextBox1.IsHandleCreated);
Assert.Equal(0, invalidatedCallCount);
Assert.Equal(0, styleChangedCallCount);
Assert.Equal(0, createdCallCount);
}
// DrawToBitmap doesn't work for this control, so we should hide it.
// We'll still call base so that this has a chance to work if it can.
[WinFormsFact]
public void RichTextBox_DrawToBitmap_Invoke_Success()
{
using Bitmap bitmap1 = new(10, 10);
using RichTextBox richTextBox1 = new();
richTextBox1.DrawToBitmap(bitmap1, new Rectangle(0, 0, 10, 10));
bitmap1.Width.Should().Be(10);
bitmap1.Height.Should().Be(10);
}
[WinFormsFact]
public void RichTextBox_SaveFilePath_Invoke_Success()
{
using RichTextBox richTextBox1 = new()
{
Rtf = @"{\rtf1\ansi{Sample for {\v HIDDEN }text}}"
};
using RichTextBox richTextBox2 = new();
string fileName = "SaveRichTextBox.rtf";
string projectDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..", "..", "..", "..", "..");
string filePath = $"{projectDirectory}/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/{fileName}";
try
{
richTextBox1.SaveFile(filePath);
richTextBox2.LoadFile(filePath);
int startOfSample = richTextBox2.Text.IndexOf("Sample", StringComparison.Ordinal);
int endOfText = richTextBox2.Text.IndexOf("text", StringComparison.Ordinal) + "text".Length;
richTextBox2.Select(startOfSample, endOfText - startOfSample);
richTextBox2.Rtf.Should().NotBeNullOrEmpty();
richTextBox2.SelectedText.Should().Be("Sample for HIDDEN text");
}
finally
{
File.Delete(filePath);
}
}
[WinFormsTheory]
[InlineData(RichTextBoxStreamType.RichText)]
[InlineData(RichTextBoxStreamType.PlainText)]
[InlineData(RichTextBoxStreamType.UnicodePlainText)]
[InlineData(RichTextBoxStreamType.RichNoOleObjs)]
[InlineData(RichTextBoxStreamType.TextTextOleObjs)]
public void RichTextBox_SaveFile_Invoke_Success(RichTextBoxStreamType fileType)
{
using RichTextBox richTextBox1 = new();
string projectDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..", "..", "..", "..", "..");
string filePath = Path.Combine(projectDirectory, "src", "System.Windows.Forms", "tests", "UnitTests", "TestResources", "Files", "Test");
try
{
richTextBox1.SaveFile(filePath, fileType);
File.Exists(filePath).Should().BeTrue();
}
finally
{
File.Delete(filePath);
}
}
[WinFormsFact]
public void RichTextBox_DragDropEvent_AddRemove_Success()
{
using SubRichTextBox richTextBox1 = new();
int callCount = 0;
DragEventHandler handler = (sender, e) =>
{
sender.Should().Be(richTextBox1);
callCount++;
};
DragEventArgs dragEventArgs = new DragEventArgs(
data: null,
keyState: 0,
x: 0,
y: 0,
allowedEffect: DragDropEffects.None,
effect: DragDropEffects.None);
richTextBox1.DragDrop += handler;
richTextBox1.OnDragDrop(dragEventArgs);
callCount.Should().Be(1);
richTextBox1.DragDrop -= handler;
richTextBox1.OnDragDrop(dragEventArgs);
callCount.Should().Be(1);
}
[WinFormsFact]
public void RichTextBox_DragEnterEvent_AddRemove_Success()
{
using SubRichTextBox richTextBox1 = new();
int callCount = 0;
DragEventHandler handler = (sender, e) =>
{
sender.Should().Be(richTextBox1);
callCount++;
};
DragEventArgs dragEventArgs = new DragEventArgs(
data: null,
keyState: 0,
x: 0,
y: 0,
allowedEffect: DragDropEffects.None,
effect: DragDropEffects.None);
richTextBox1.DragEnter += handler;
richTextBox1.OnDragDrop(dragEventArgs);
callCount.Should().Be(0);
richTextBox1.DragEnter -= handler;
richTextBox1.OnDragDrop(dragEventArgs);
callCount.Should().Be(0);
}
[WinFormsFact]
public void RichTextBox_DragLeaveEvent_AddRemove_Success()
{
using SubRichTextBox richTextBox1 = new();
int callCount = 0;
EventHandler handler = (sender, e) =>
{
sender.Should().Be(richTextBox1);
e.Should().Be(EventArgs.Empty);
callCount++;
};
richTextBox1.DragLeave += handler;
richTextBox1.OnDragLeave(EventArgs.Empty);
callCount.Should().Be(1);
richTextBox1.DragLeave -= handler;
richTextBox1.OnDragLeave(EventArgs.Empty);
callCount.Should().Be(1);
}
[WinFormsFact]
public void RichTextBox_DragOverEvent_AddRemove_Success()
{
using SubRichTextBox richTextBox1 = new();
int callCount = 0;
DragEventHandler handler = (sender, e) =>
{
sender.Should().Be(richTextBox1);
callCount++;
};
DragEventArgs dragEventArgs = new DragEventArgs(
data: null,
keyState: 0,
x: 0,
y: 0,
allowedEffect: DragDropEffects.None,
effect: DragDropEffects.None);
richTextBox1.DragOver += handler;
richTextBox1.OnDragOver(dragEventArgs);
callCount.Should().Be(1);
richTextBox1.DragOver -= handler;
richTextBox1.OnDragOver(dragEventArgs);
callCount.Should().Be(1);
}
[WinFormsFact]
public void RichTextBox_GiveFeedbackEvent_AddRemove_Success()
{
using SubRichTextBox richTextBox1 = new();
int callCount = 0;
GiveFeedbackEventHandler handler = (sender, e) =>
{
sender.Should().Be(richTextBox1);
callCount++;
};
GiveFeedbackEventArgs giveFeedbackEventArgs = new(DragDropEffects.None, useDefaultCursors: true);
richTextBox1.GiveFeedback += handler;
richTextBox1.OnGiveFeedback(giveFeedbackEventArgs);
callCount.Should().Be(1);
richTextBox1.GiveFeedback -= handler;
richTextBox1.OnGiveFeedback(giveFeedbackEventArgs);
callCount.Should().Be(1);
}
[WinFormsFact]
public void RichTextBox_QueryContinueDragEvent_AddRemove_Success()
{
using SubRichTextBox richTextBox1 = new();
int callCount = 0;
QueryContinueDragEventHandler handler = (sender, e) =>
{
sender.Should().Be(richTextBox1);
callCount++;
};
QueryContinueDragEventArgs queryContinueDragEventArgs = new(keyState: 0, escapePressed: true, action: DragAction.Continue);
richTextBox1.QueryContinueDrag += handler;
richTextBox1.OnQueryContinueDrag(queryContinueDragEventArgs);
callCount.Should().Be(1);
richTextBox1.QueryContinueDrag -= handler;
richTextBox1.OnQueryContinueDrag(queryContinueDragEventArgs);
callCount.Should().Be(1);
}
private class CustomGetParaFormatRichTextBox : RichTextBox
{
public bool MakeCustom { get; set; }
public IntPtr ExpectedWParam { get; set; }
public PARAFORMAT GetParaFormatResult { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (MakeCustom && m.Msg == (int)PInvoke.EM_GETPARAFORMAT)
{
PARAFORMAT* format = (PARAFORMAT*)m.LParam;
Assert.Equal(IntPtr.Zero, m.WParam);
Assert.NotEqual(IntPtr.Zero, m.LParam);
*format = GetParaFormatResult;
return;
}
base.WndProc(ref m);
}
}
private class CustomGetCharFormatRichTextBox : RichTextBox
{
public bool MakeCustom { get; set; }
public IntPtr ExpectedWParam { get; set; }
public CHARFORMAT2W GetCharFormatResult { get; set; }
protected override unsafe void WndProc(ref Message m)
{
if (MakeCustom && m.Msg == (int)PInvoke.EM_GETCHARFORMAT)
{
CHARFORMAT2W* format = (CHARFORMAT2W*)m.LParam;
Assert.Equal(ExpectedWParam, m.WParam);
Assert.NotEqual(IntPtr.Zero, m.LParam);
*format = GetCharFormatResult;
return;
}
base.WndProc(ref m);
}
}
private class CantCreateHandleRichTextBox : RichTextBox
{
protected override void CreateHandle()
{
// Nop.
}
}
private class SubRichTextBox : RichTextBox
{
public new bool CanEnableIme => base.CanEnableIme;
public new bool CanRaiseEvents => base.CanRaiseEvents;
public new CreateParams CreateParams => base.CreateParams;
public new Cursor DefaultCursor => base.DefaultCursor;
public new ImeMode DefaultImeMode => base.DefaultImeMode;
public new Padding DefaultMargin => base.DefaultMargin;
public new Size DefaultMaximumSize => base.DefaultMaximumSize;
public new Size DefaultMinimumSize => base.DefaultMinimumSize;
public new Padding DefaultPadding => base.DefaultPadding;
public new Size DefaultSize => base.DefaultSize;
public new bool DesignMode => base.DesignMode;
public new bool DoubleBuffered
{
get => base.DoubleBuffered;
set => base.DoubleBuffered = value;
}
public new EventHandlerList Events => base.Events;
public new int FontHeight
{
get => base.FontHeight;
set => base.FontHeight = value;
}
public new ImeMode ImeModeBase
{
get => base.ImeModeBase;
set => base.ImeModeBase = value;
}
public new bool ResizeRedraw
{
get => base.ResizeRedraw;
set => base.ResizeRedraw = value;
}
public new bool ShowFocusCues => base.ShowFocusCues;
public new bool ShowKeyboardCues => base.ShowKeyboardCues;
public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
public new bool GetTopLevel() => base.GetTopLevel();
public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
public new void OnContentsResized(ContentsResizedEventArgs e) => base.OnContentsResized(e);
public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
public new void OnHScroll(EventArgs e) => base.OnHScroll(e);
public new void OnImeChange(EventArgs e) => base.OnImeChange(e);
public new void OnLinkClicked(LinkClickedEventArgs e) => base.OnLinkClicked(e);
public new void OnProtected(EventArgs e) => base.OnProtected(e);
public new void OnSelectionChanged(EventArgs e) => base.OnSelectionChanged(e);
public new void OnVScroll(EventArgs e) => base.OnVScroll(e);
public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
public new void WndProc(ref Message m) => base.WndProc(ref m);
public new void OnDragDrop(DragEventArgs e) => base.OnDragDrop(e);
public new void OnDragLeave(EventArgs e) => base.OnDragLeave(e);
public new void OnDragOver(DragEventArgs e) => base.OnDragOver(e);
public new void OnGiveFeedback(GiveFeedbackEventArgs e) => base.OnGiveFeedback(e);
public new void OnQueryContinueDrag(QueryContinueDragEventArgs e) => base.OnQueryContinueDrag(e);
}
private static unsafe string GetClassName(HWND hWnd)
{
int length = 0;
Span<char> buffer = stackalloc char[PInvoke.MaxClassName];
fixed (char* lpClassName = buffer)
{
length = PInvoke.GetClassName(hWnd, lpClassName, buffer.Length);
}
return new string(buffer[..length]);
}
/// <summary>
/// Represents RichEdit 1.0 control.
/// </summary>
private class RichEdit : RichEditWithVersion
{
protected override string NativeDll => "riched32.dll";
protected override string WindowClassName => "RichEdit";
}
/// <summary>
/// Represents RichEdit 2.0 control.
/// </summary>
private class RichEdit20W : RichEditWithVersion
{
protected override string NativeDll => "riched20.dll";
protected override string WindowClassName => "RichEdit20W";
}
private abstract class RichEditWithVersion : RichTextBox
{
// NOTE: Do not unload the library once it is loaded!
// To prevent race conditions where one thread unloads the library
// while another thread instantiates the control.
private IntPtr _nativeDllHandle = IntPtr.Zero;
protected abstract string NativeDll { get; }
protected abstract string WindowClassName { get; }
protected override CreateParams CreateParams
{
get
{
// This code is copied and adapted from the original RichTextBox implemenation
// https://referencesource.microsoft.com/#System.Windows.Forms/winforms/Managed/System/WinForms/RichTextBox.cs,357
if (_nativeDllHandle == IntPtr.Zero)
{
_nativeDllHandle = PInvoke.LoadLibraryFromSystemPathIfAvailable(NativeDll);
int lastWin32Error = Marshal.GetLastWin32Error();
if ((ulong)_nativeDllHandle < 32)
{
throw new Win32Exception(lastWin32Error, $"Failed to load '{NativeDll}'");
}
}
CreateParams cp = base.CreateParams;
cp.ClassName = WindowClassName;
return cp;
}
}
}
}
|