mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-26 15:57:56 +01:00
4168 lines
156 KiB
C#
4168 lines
156 KiB
C#
using System.Text;
|
||
using Xunit.Abstractions;
|
||
using static Terminal.Gui.SpinnerStyle;
|
||
|
||
// Alias Console to MockConsole so we don't accidentally use Console
|
||
|
||
namespace Terminal.Gui.TextTests;
|
||
|
||
public class TextFormatterTests
|
||
{
|
||
private readonly ITestOutputHelper _output;
|
||
public TextFormatterTests (ITestOutputHelper output) { _output = output; }
|
||
|
||
public static IEnumerable<object []> CMGlyphs =>
|
||
new List<object []> { new object [] { $"{CM.Glyphs.LeftBracket} Say Hello 你 {CM.Glyphs.RightBracket}", 16, 15 } };
|
||
|
||
public static IEnumerable<object []> FormatEnvironmentNewLine =>
|
||
new List<object []>
|
||
{
|
||
new object []
|
||
{
|
||
$"Line1{Environment.NewLine}Line2{Environment.NewLine}Line3{Environment.NewLine}",
|
||
60,
|
||
new [] { "Line1", "Line2", "Line3" }
|
||
}
|
||
};
|
||
|
||
public static IEnumerable<object []> SplitEnvironmentNewLine =>
|
||
new List<object []>
|
||
{
|
||
new object []
|
||
{
|
||
$"First Line 界{Environment.NewLine}Second Line 界{Environment.NewLine}Third Line 界",
|
||
new [] { "First Line 界", "Second Line 界", "Third Line 界" }
|
||
},
|
||
new object []
|
||
{
|
||
$"First Line 界{Environment.NewLine}Second Line 界{Environment.NewLine}Third Line 界{Environment.NewLine}",
|
||
new [] { "First Line 界", "Second Line 界", "Third Line 界", "" }
|
||
}
|
||
};
|
||
|
||
[Fact]
|
||
public void Basic_Usage_With_AutoSize_True ()
|
||
{
|
||
var testText = "test";
|
||
var testBounds = new Rectangle (0, 0, 100, 1);
|
||
var tf = new TextFormatter ();
|
||
|
||
// Manually set AutoSize to true
|
||
tf.AutoSize = true;
|
||
|
||
tf.Text = testText;
|
||
Size expectedSize = new (testText.Length, 1);
|
||
Assert.Equal (testText, tf.Text);
|
||
Assert.Equal (TextAlignment.Left, tf.Alignment);
|
||
Assert.Equal (expectedSize, tf.Size);
|
||
tf.Draw (testBounds, new Attribute (), new Attribute ());
|
||
Assert.Equal (expectedSize, tf.Size);
|
||
Assert.NotEmpty (tf.GetLines ());
|
||
|
||
tf.Alignment = TextAlignment.Right;
|
||
expectedSize = new (testText.Length, 1);
|
||
Assert.Equal (testText, tf.Text);
|
||
Assert.Equal (TextAlignment.Right, tf.Alignment);
|
||
Assert.Equal (expectedSize, tf.Size);
|
||
tf.Draw (testBounds, new Attribute (), new Attribute ());
|
||
Assert.Equal (expectedSize, tf.Size);
|
||
Assert.NotEmpty (tf.GetLines ());
|
||
|
||
tf.Alignment = TextAlignment.Right;
|
||
expectedSize = new (testText.Length, 1);
|
||
tf.Size = expectedSize;
|
||
Assert.Equal (testText, tf.Text);
|
||
Assert.Equal (TextAlignment.Right, tf.Alignment);
|
||
Assert.Equal (expectedSize, tf.Size);
|
||
tf.Draw (testBounds, new Attribute (), new Attribute ());
|
||
Assert.Equal (expectedSize, tf.Size);
|
||
Assert.NotEmpty (tf.GetLines ());
|
||
|
||
tf.Alignment = TextAlignment.Centered;
|
||
expectedSize = new (testText.Length, 1);
|
||
tf.Size = expectedSize;
|
||
Assert.Equal (testText, tf.Text);
|
||
Assert.Equal (TextAlignment.Centered, tf.Alignment);
|
||
Assert.Equal (expectedSize, tf.Size);
|
||
tf.Draw (testBounds, new Attribute (), new Attribute ());
|
||
Assert.Equal (expectedSize, tf.Size);
|
||
Assert.NotEmpty (tf.GetLines ());
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (null)]
|
||
[InlineData ("")]
|
||
public void CalcRect_Invalid_Returns_Empty (string text)
|
||
{
|
||
Assert.Equal (Rectangle.Empty, TextFormatter.CalcRect (0, 0, text));
|
||
Assert.Equal (new (new (1, 2), Size.Empty), TextFormatter.CalcRect (1, 2, text));
|
||
Assert.Equal (new (new (-1, -2), Size.Empty), TextFormatter.CalcRect (-1, -2, text));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("line1\nline2", 5, 2)]
|
||
[InlineData ("\nline2", 5, 2)]
|
||
[InlineData ("\n\n", 0, 3)]
|
||
[InlineData ("\n\n\n", 0, 4)]
|
||
[InlineData ("line1\nline2\nline3long!", 10, 3)]
|
||
[InlineData ("line1\nline2\n\n", 5, 4)]
|
||
[InlineData ("line1\r\nline2", 5, 2)]
|
||
[InlineData (" ~ s gui.cs master ↑10\n", 31, 2)]
|
||
[InlineData ("\n ~ s gui.cs master ↑10", 31, 2)]
|
||
[InlineData (" ~ s gui.cs master\n↑10", 27, 2)]
|
||
public void CalcRect_MultiLine_Returns_nHigh (string text, int expectedWidth, int expectedLines)
|
||
{
|
||
Assert.Equal (new (0, 0, expectedWidth, expectedLines), TextFormatter.CalcRect (0, 0, text));
|
||
string [] lines = text.Split (text.Contains (Environment.NewLine) ? Environment.NewLine : "\n");
|
||
int maxWidth = lines.Max (s => s.GetColumns ());
|
||
var lineWider = 0;
|
||
|
||
for (var i = 0; i < lines.Length; i++)
|
||
{
|
||
int w = lines [i].GetColumns ();
|
||
|
||
if (w == maxWidth)
|
||
{
|
||
lineWider = i;
|
||
}
|
||
}
|
||
|
||
Assert.Equal (new (0, 0, maxWidth, expectedLines), TextFormatter.CalcRect (0, 0, text));
|
||
|
||
Assert.Equal (
|
||
new (
|
||
0,
|
||
0,
|
||
lines [lineWider].ToRuneList ().Sum (r => Math.Max (r.GetColumns (), 0)),
|
||
expectedLines
|
||
),
|
||
TextFormatter.CalcRect (0, 0, text)
|
||
);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test")]
|
||
[InlineData (" ~ s gui.cs master ↑10")]
|
||
public void CalcRect_SingleLine_Returns_1High (string text)
|
||
{
|
||
Assert.Equal (new (0, 0, text.GetRuneCount (), 1), TextFormatter.CalcRect (0, 0, text));
|
||
Assert.Equal (new (0, 0, text.GetColumns (), 1), TextFormatter.CalcRect (0, 0, text));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (14, 1, TextDirection.LeftRight_TopBottom)]
|
||
[InlineData (1, 14, TextDirection.TopBottom_LeftRight)]
|
||
public void CalcRect_With_Combining_Runes (int width, int height, TextDirection textDirection)
|
||
{
|
||
var text = "Les Mise\u0328\u0301rables";
|
||
Assert.Equal (new (0, 0, width, height), TextFormatter.CalcRect (0, 0, text, textDirection));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", TextDirection.LeftRight_TopBottom)]
|
||
[InlineData (" ~ s gui.cs master ↑10", TextDirection.LeftRight_TopBottom)]
|
||
[InlineData ("Say Hello view4 你", TextDirection.LeftRight_TopBottom)]
|
||
[InlineData ("Say Hello view4 你", TextDirection.RightLeft_TopBottom)]
|
||
[InlineData ("Say Hello view4 你", TextDirection.LeftRight_BottomTop)]
|
||
[InlineData ("Say Hello view4 你", TextDirection.RightLeft_BottomTop)]
|
||
public void CalcRect_Horizontal_Width_Correct (string text, TextDirection textDirection)
|
||
{
|
||
// The width is the number of columns in the text
|
||
Assert.Equal (new Size (text.GetColumns (), 1), TextFormatter.CalcRect (0, 0, text, textDirection).Size);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", TextDirection.TopBottom_LeftRight)]
|
||
[InlineData (" ~ s gui.cs master ↑10", TextDirection.TopBottom_LeftRight)]
|
||
[InlineData ("Say Hello view4 你", TextDirection.TopBottom_LeftRight)]
|
||
[InlineData ("Say Hello view4 你", TextDirection.TopBottom_RightLeft)]
|
||
[InlineData ("Say Hello view4 你", TextDirection.BottomTop_LeftRight)]
|
||
[InlineData ("Say Hello view4 你", TextDirection.BottomTop_RightLeft)]
|
||
public void CalcRect_Vertical_Height_Correct (string text, TextDirection textDirection)
|
||
{
|
||
// The height is based both the number of lines and the number of wide chars
|
||
Assert.Equal (new Size (1 + text.GetColumns () - text.Length, text.Length), TextFormatter.CalcRect (0, 0, text, textDirection).Size);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("")]
|
||
[InlineData (null)]
|
||
[InlineData ("test")]
|
||
public void ClipAndJustify_Invalid_Returns_Original (string text)
|
||
{
|
||
string expected = string.IsNullOrEmpty (text) ? text : "";
|
||
Assert.Equal (expected, TextFormatter.ClipAndJustify (text, 0, TextAlignment.Left));
|
||
Assert.Equal (expected, TextFormatter.ClipAndJustify (text, 0, TextAlignment.Left));
|
||
|
||
Assert.Throws<ArgumentOutOfRangeException> (
|
||
() =>
|
||
TextFormatter.ClipAndJustify (text, -1, TextAlignment.Left)
|
||
);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", "", 0)]
|
||
[InlineData ("test", "te", 2)]
|
||
[InlineData ("test", "test", int.MaxValue)]
|
||
[InlineData ("A sentence has words.", "A sentence has words.", 22)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words.", 21)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words.", int.MaxValue)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words", 20)] // Should not fit
|
||
[InlineData ("A sentence has words.", "A sentence", 10)] // Should not fit
|
||
[InlineData ("A\tsentence\thas\twords.", "A sentence has words.", int.MaxValue)]
|
||
[InlineData ("A\tsentence\thas\twords.", "A sentence", 10)]
|
||
[InlineData ("line1\nline2\nline3long!", "line1\nline2\nline3long!", int.MaxValue)]
|
||
[InlineData ("line1\nline2\nline3long!", "line1\nline", 10)]
|
||
[InlineData (" ~ s gui.cs master ↑10", " ~ s ", 10)] // Unicode
|
||
[InlineData ("Ð ÑÐ", "Ð ÑÐ", 5)] // should fit
|
||
[InlineData ("Ð ÑÐ", "Ð ÑÐ", 4)] // should fit
|
||
[InlineData ("Ð ÑÐ", "Ð Ñ", 3)] // Should not fit
|
||
public void ClipAndJustify_Valid_Centered (string text, string justifiedText, int maxWidth)
|
||
{
|
||
var align = TextAlignment.Centered;
|
||
var textDirection = TextDirection.LeftRight_TopBottom;
|
||
var tabWidth = 1;
|
||
|
||
Assert.Equal (
|
||
justifiedText,
|
||
TextFormatter.ClipAndJustify (text, maxWidth, align, textDirection, tabWidth)
|
||
);
|
||
int expectedClippedWidth = Math.Min (justifiedText.GetRuneCount (), maxWidth);
|
||
|
||
Assert.Equal (
|
||
justifiedText,
|
||
TextFormatter.ClipAndJustify (text, maxWidth, align, textDirection, tabWidth)
|
||
);
|
||
Assert.True (justifiedText.GetRuneCount () <= maxWidth);
|
||
Assert.True (justifiedText.GetColumns () <= maxWidth);
|
||
Assert.Equal (expectedClippedWidth, justifiedText.GetRuneCount ());
|
||
|
||
Assert.Equal (
|
||
expectedClippedWidth,
|
||
justifiedText.ToRuneList ().Sum (r => Math.Max (r.GetColumns (), 1))
|
||
);
|
||
Assert.True (expectedClippedWidth <= maxWidth);
|
||
|
||
Assert.Equal (
|
||
StringExtensions.ToString (justifiedText.ToRunes () [..expectedClippedWidth]),
|
||
justifiedText
|
||
);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", "", 0)]
|
||
[InlineData ("test", "te", 2)]
|
||
[InlineData ("test", "test", int.MaxValue)] // This doesn't throw because it only create a word with length 1
|
||
[InlineData ("A sentence has words.", "A sentence has words.", 22)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words.", 21)] // should fit
|
||
[InlineData (
|
||
"A sentence has words.",
|
||
"A sentence has words.",
|
||
500
|
||
)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words", 20)] // Should not fit
|
||
[InlineData ("A sentence has words.", "A sentence", 10)] // Should not fit
|
||
// Now throw System.OutOfMemoryException. See https://stackoverflow.com/questions/20672920/maxcapacity-of-stringbuilder
|
||
//[InlineData ("A\tsentence\thas\twords.", "A sentence has words.", int.MaxValue)]
|
||
[InlineData ("A\tsentence\thas\twords.", "A sentence", 10)]
|
||
[InlineData (
|
||
"line1\nline2\nline3long!",
|
||
"line1\nline2\nline3long!",
|
||
int.MaxValue
|
||
)] // This doesn't throw because it only create a line with length 1
|
||
[InlineData ("line1\nline2\nline3long!", "line1\nline", 10)]
|
||
[InlineData (" ~ s gui.cs master ↑10", " ~ s ", 10)] // Unicode
|
||
[InlineData ("Ð ÑÐ", "Ð ÑÐ", 5)] // should fit
|
||
[InlineData ("Ð ÑÐ", "Ð ÑÐ", 4)] // should fit
|
||
[InlineData ("Ð ÑÐ", "Ð Ñ", 3)] // Should not fit
|
||
public void ClipAndJustify_Valid_Justified (string text, string justifiedText, int maxWidth)
|
||
{
|
||
var align = TextAlignment.Justified;
|
||
var textDirection = TextDirection.LeftRight_TopBottom;
|
||
var tabWidth = 1;
|
||
|
||
Assert.Equal (
|
||
justifiedText,
|
||
TextFormatter.ClipAndJustify (text, maxWidth, align, textDirection, tabWidth)
|
||
);
|
||
int expectedClippedWidth = Math.Min (justifiedText.GetRuneCount (), maxWidth);
|
||
|
||
Assert.Equal (
|
||
justifiedText,
|
||
TextFormatter.ClipAndJustify (text, maxWidth, align, textDirection, tabWidth)
|
||
);
|
||
Assert.True (justifiedText.GetRuneCount () <= maxWidth);
|
||
Assert.True (justifiedText.GetColumns () <= maxWidth);
|
||
Assert.Equal (expectedClippedWidth, justifiedText.GetRuneCount ());
|
||
|
||
Assert.Equal (
|
||
expectedClippedWidth,
|
||
justifiedText.ToRuneList ().Sum (r => Math.Max (r.GetColumns (), 1))
|
||
);
|
||
Assert.True (expectedClippedWidth <= maxWidth);
|
||
|
||
Assert.Equal (
|
||
StringExtensions.ToString (justifiedText.ToRunes () [..expectedClippedWidth]),
|
||
justifiedText
|
||
);
|
||
|
||
// see Justify_ tests below
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", "", 0)]
|
||
[InlineData ("test", "te", 2)]
|
||
[InlineData ("test", "test", int.MaxValue)]
|
||
[InlineData ("A sentence has words.", "A sentence has words.", 22)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words.", 21)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words.", int.MaxValue)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words", 20)] // Should not fit
|
||
[InlineData ("A sentence has words.", "A sentence", 10)] // Should not fit
|
||
[InlineData ("A\tsentence\thas\twords.", "A sentence has words.", int.MaxValue)]
|
||
[InlineData ("A\tsentence\thas\twords.", "A sentence", 10)]
|
||
[InlineData ("line1\nline2\nline3long!", "line1\nline2\nline3long!", int.MaxValue)]
|
||
[InlineData ("line1\nline2\nline3long!", "line1\nline", 10)]
|
||
[InlineData (" ~ s gui.cs master ↑10", " ~ s ", 10)] // Unicode
|
||
[InlineData ("Ð ÑÐ", "Ð ÑÐ", 5)] // should fit
|
||
[InlineData ("Ð ÑÐ", "Ð ÑÐ", 4)] // should fit
|
||
[InlineData ("Ð ÑÐ", "Ð Ñ", 3)] // Should not fit
|
||
public void ClipAndJustify_Valid_Left (string text, string justifiedText, int maxWidth)
|
||
{
|
||
var align = TextAlignment.Left;
|
||
var textDirection = TextDirection.LeftRight_BottomTop;
|
||
var tabWidth = 1;
|
||
|
||
Assert.Equal (
|
||
justifiedText,
|
||
TextFormatter.ClipAndJustify (text, maxWidth, align, textDirection, tabWidth)
|
||
);
|
||
int expectedClippedWidth = Math.Min (justifiedText.GetRuneCount (), maxWidth);
|
||
|
||
Assert.Equal (
|
||
justifiedText,
|
||
TextFormatter.ClipAndJustify (text, maxWidth, align, textDirection, tabWidth)
|
||
);
|
||
Assert.True (justifiedText.GetRuneCount () <= maxWidth);
|
||
Assert.True (justifiedText.GetColumns () <= maxWidth);
|
||
Assert.Equal (expectedClippedWidth, justifiedText.GetRuneCount ());
|
||
|
||
Assert.Equal (
|
||
expectedClippedWidth,
|
||
justifiedText.ToRuneList ().Sum (r => Math.Max (r.GetColumns (), 1))
|
||
);
|
||
Assert.True (expectedClippedWidth <= maxWidth);
|
||
|
||
Assert.Equal (
|
||
StringExtensions.ToString (justifiedText.ToRunes () [..expectedClippedWidth]),
|
||
justifiedText
|
||
);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", "", 0)]
|
||
[InlineData ("test", "te", 2)]
|
||
[InlineData ("test", "test", int.MaxValue)]
|
||
[InlineData ("A sentence has words.", "A sentence has words.", 22)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words.", 21)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words.", int.MaxValue)] // should fit
|
||
[InlineData ("A sentence has words.", "A sentence has words", 20)] // Should not fit
|
||
[InlineData ("A sentence has words.", "A sentence", 10)] // Should not fit
|
||
[InlineData ("A\tsentence\thas\twords.", "A sentence has words.", int.MaxValue)]
|
||
[InlineData ("A\tsentence\thas\twords.", "A sentence", 10)]
|
||
[InlineData ("line1\nline2\nline3long!", "line1\nline2\nline3long!", int.MaxValue)]
|
||
[InlineData ("line1\nline2\nline3long!", "line1\nline", 10)]
|
||
[InlineData (" ~ s gui.cs master ↑10", " ~ s ", 10)] // Unicode
|
||
[InlineData ("Ð ÑÐ", "Ð ÑÐ", 5)] // should fit
|
||
[InlineData ("Ð ÑÐ", "Ð ÑÐ", 4)] // should fit
|
||
[InlineData ("Ð ÑÐ", "Ð Ñ", 3)] // Should not fit
|
||
public void ClipAndJustify_Valid_Right (string text, string justifiedText, int maxWidth)
|
||
{
|
||
var align = TextAlignment.Right;
|
||
var textDirection = TextDirection.LeftRight_BottomTop;
|
||
var tabWidth = 1;
|
||
|
||
Assert.Equal (
|
||
justifiedText,
|
||
TextFormatter.ClipAndJustify (text, maxWidth, align, textDirection, tabWidth)
|
||
);
|
||
int expectedClippedWidth = Math.Min (justifiedText.GetRuneCount (), maxWidth);
|
||
|
||
Assert.Equal (
|
||
justifiedText,
|
||
TextFormatter.ClipAndJustify (text, maxWidth, align, textDirection, tabWidth)
|
||
);
|
||
Assert.True (justifiedText.GetRuneCount () <= maxWidth);
|
||
Assert.True (justifiedText.GetColumns () <= maxWidth);
|
||
Assert.Equal (expectedClippedWidth, justifiedText.GetRuneCount ());
|
||
|
||
Assert.Equal (
|
||
expectedClippedWidth,
|
||
justifiedText.ToRuneList ().Sum (r => Math.Max (r.GetColumns (), 1))
|
||
);
|
||
Assert.True (expectedClippedWidth <= maxWidth);
|
||
|
||
Assert.Equal (
|
||
StringExtensions.ToString (justifiedText.ToRunes () [..expectedClippedWidth]),
|
||
justifiedText
|
||
);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (14, 1, TextDirection.LeftRight_TopBottom, "Les Misęrables")]
|
||
[InlineData (1, 14, TextDirection.TopBottom_LeftRight, "L\ne\ns\n \nM\ni\ns\nę\nr\na\nb\nl\ne\ns")]
|
||
[InlineData (
|
||
4,
|
||
4,
|
||
TextDirection.TopBottom_LeftRight,
|
||
@"
|
||
LMre
|
||
eias
|
||
ssb
|
||
ęl "
|
||
)]
|
||
public void Draw_With_Combining_Runes (int width, int height, TextDirection textDirection, string expected)
|
||
{
|
||
var driver = new FakeDriver ();
|
||
driver.Init ();
|
||
|
||
var text = "Les Mise\u0328\u0301rables";
|
||
|
||
var tf = new TextFormatter ();
|
||
tf.Direction = textDirection;
|
||
tf.Text = text;
|
||
|
||
Assert.True (tf.WordWrap);
|
||
|
||
tf.Size = new (width, height);
|
||
|
||
tf.Draw (
|
||
new (0, 0, width, height),
|
||
new Attribute (ColorName.White, ColorName.Black),
|
||
new Attribute (ColorName.Blue, ColorName.Black),
|
||
default (Rectangle),
|
||
driver
|
||
);
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expected, _output, driver);
|
||
|
||
driver.End ();
|
||
}
|
||
|
||
[Fact]
|
||
[SetupFakeDriver]
|
||
public void FillRemaining_True_False ()
|
||
{
|
||
((FakeDriver)Application.Driver).SetBufferSize (22, 5);
|
||
|
||
Attribute [] attrs =
|
||
{
|
||
Attribute.Default, new Attribute (ColorName.Green, ColorName.BrightMagenta),
|
||
new Attribute (ColorName.Blue, ColorName.Cyan)
|
||
};
|
||
var tf = new TextFormatter { Size = new (14, 3), Text = "Test\nTest long\nTest long long\n", MultiLine = true };
|
||
|
||
tf.Draw (
|
||
new (1, 1, 19, 3),
|
||
attrs [1],
|
||
attrs [2]);
|
||
|
||
Assert.False (tf.FillRemaining);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (
|
||
@"
|
||
Test
|
||
Test long
|
||
Test long long",
|
||
_output);
|
||
|
||
TestHelpers.AssertDriverAttributesAre (
|
||
@"
|
||
000000000000000000000
|
||
011110000000000000000
|
||
011111111100000000000
|
||
011111111111111000000
|
||
000000000000000000000",
|
||
null,
|
||
attrs);
|
||
|
||
tf.FillRemaining = true;
|
||
|
||
tf.Draw (
|
||
new (1, 1, 19, 3),
|
||
attrs [1],
|
||
attrs [2]);
|
||
|
||
TestHelpers.AssertDriverAttributesAre (
|
||
@"
|
||
000000000000000000000
|
||
011111111111111111110
|
||
011111111111111111110
|
||
011111111111111111110
|
||
000000000000000000000",
|
||
null,
|
||
attrs);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("_k Before", true, 0, (KeyCode)'K')] // lower case should return uppercase Hotkey
|
||
[InlineData ("a_k Second", true, 1, (KeyCode)'K')]
|
||
[InlineData ("Last _k", true, 5, (KeyCode)'K')]
|
||
[InlineData ("After k_", false, -1, KeyCode.Null)]
|
||
[InlineData ("Multiple _k and _R", true, 9, (KeyCode)'K')]
|
||
[InlineData ("Non-english: _кдать", true, 13, (KeyCode)'к')] // Lower case Cryllic K (к)
|
||
[InlineData ("_k Before", true, 0, (KeyCode)'K', true)] // Turn on FirstUpperCase and verify same results
|
||
[InlineData ("a_k Second", true, 1, (KeyCode)'K', true)]
|
||
[InlineData ("Last _k", true, 5, (KeyCode)'K', true)]
|
||
[InlineData ("After k_", false, -1, KeyCode.Null, true)]
|
||
[InlineData ("Multiple _k and _r", true, 9, (KeyCode)'K', true)]
|
||
[InlineData ("Non-english: _кдать", true, 13, (KeyCode)'к', true)] // Cryllic K (К)
|
||
public void FindHotKey_AlphaLowerCase_Succeeds (
|
||
string text,
|
||
bool expectedResult,
|
||
int expectedHotPos,
|
||
KeyCode expectedKey,
|
||
bool supportFirstUpperCase = false
|
||
)
|
||
{
|
||
var hotKeySpecifier = (Rune)'_';
|
||
|
||
bool result = TextFormatter.FindHotKey (
|
||
text,
|
||
hotKeySpecifier,
|
||
out int hotPos,
|
||
out Key hotKey,
|
||
supportFirstUpperCase
|
||
);
|
||
|
||
if (expectedResult)
|
||
{
|
||
Assert.True (result);
|
||
}
|
||
else
|
||
{
|
||
Assert.False (result);
|
||
}
|
||
|
||
Assert.Equal (expectedResult, result);
|
||
Assert.Equal (expectedHotPos, hotPos);
|
||
Assert.Equal (expectedKey, hotKey);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("_K Before", true, 0, (KeyCode)'K')]
|
||
[InlineData ("a_K Second", true, 1, (KeyCode)'K')]
|
||
[InlineData ("Last _K", true, 5, (KeyCode)'K')]
|
||
[InlineData ("After K_", false, -1, KeyCode.Null)]
|
||
[InlineData ("Multiple _K and _R", true, 9, (KeyCode)'K')]
|
||
[InlineData ("Non-english: _Кдать", true, 13, (KeyCode)'К')] // Cryllic K (К)
|
||
[InlineData ("_K Before", true, 0, (KeyCode)'K', true)] // Turn on FirstUpperCase and verify same results
|
||
[InlineData ("a_K Second", true, 1, (KeyCode)'K', true)]
|
||
[InlineData ("Last _K", true, 5, (KeyCode)'K', true)]
|
||
[InlineData ("After K_", false, -1, KeyCode.Null, true)]
|
||
[InlineData ("Multiple _K and _R", true, 9, (KeyCode)'K', true)]
|
||
[InlineData ("Non-english: _Кдать", true, 13, (KeyCode)'К', true)] // Cryllic K (К)
|
||
public void FindHotKey_AlphaUpperCase_Succeeds (
|
||
string text,
|
||
bool expectedResult,
|
||
int expectedHotPos,
|
||
KeyCode expectedKey,
|
||
bool supportFirstUpperCase = false
|
||
)
|
||
{
|
||
var hotKeySpecifier = (Rune)'_';
|
||
|
||
bool result = TextFormatter.FindHotKey (
|
||
text,
|
||
hotKeySpecifier,
|
||
out int hotPos,
|
||
out Key hotKey,
|
||
supportFirstUpperCase
|
||
);
|
||
|
||
if (expectedResult)
|
||
{
|
||
Assert.True (result);
|
||
}
|
||
else
|
||
{
|
||
Assert.False (result);
|
||
}
|
||
|
||
Assert.Equal (expectedResult, result);
|
||
Assert.Equal (expectedHotPos, hotPos);
|
||
Assert.Equal (expectedKey, hotKey);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (null)]
|
||
[InlineData ("")]
|
||
[InlineData ("no hotkey")]
|
||
[InlineData ("No hotkey, Upper Case")]
|
||
[InlineData ("Non-english: Сохранить")]
|
||
public void FindHotKey_Invalid_ReturnsFalse (string text)
|
||
{
|
||
var hotKeySpecifier = (Rune)'_';
|
||
var supportFirstUpperCase = false;
|
||
var hotPos = 0;
|
||
Key hotKey = KeyCode.Null;
|
||
var result = false;
|
||
|
||
result = TextFormatter.FindHotKey (
|
||
text,
|
||
hotKeySpecifier,
|
||
out hotPos,
|
||
out hotKey,
|
||
supportFirstUpperCase
|
||
);
|
||
Assert.False (result);
|
||
Assert.Equal (-1, hotPos);
|
||
Assert.Equal (KeyCode.Null, hotKey);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("\"k before")]
|
||
[InlineData ("ak second")]
|
||
[InlineData ("last k")]
|
||
[InlineData ("multiple k and r")]
|
||
[InlineData ("12345")]
|
||
[InlineData ("`~!@#$%^&*()-_=+[{]}\\|;:'\",<.>/?")] // punctuation
|
||
[InlineData (" ~ s gui.cs master ↑10")] // ~IsLetterOrDigit + Unicode
|
||
[InlineData ("non-english: кдать")] // Lower case Cryllic K (к)
|
||
public void FindHotKey_Legacy_FirstUpperCase_NotFound_Returns_False (string text)
|
||
{
|
||
var supportFirstUpperCase = true;
|
||
|
||
var hotKeySpecifier = (Rune)0;
|
||
|
||
bool result = TextFormatter.FindHotKey (
|
||
text,
|
||
hotKeySpecifier,
|
||
out int hotPos,
|
||
out Key hotKey,
|
||
supportFirstUpperCase
|
||
);
|
||
Assert.False (result);
|
||
Assert.Equal (-1, hotPos);
|
||
Assert.Equal (KeyCode.Null, hotKey);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("K Before", true, 0, (KeyCode)'K')]
|
||
[InlineData ("aK Second", true, 1, (KeyCode)'K')]
|
||
[InlineData ("last K", true, 5, (KeyCode)'K')]
|
||
[InlineData ("multiple K and R", true, 9, (KeyCode)'K')]
|
||
[InlineData ("non-english: Кдать", true, 13, (KeyCode)'К')] // Cryllic K (К)
|
||
public void FindHotKey_Legacy_FirstUpperCase_Succeeds (
|
||
string text,
|
||
bool expectedResult,
|
||
int expectedHotPos,
|
||
KeyCode expectedKey
|
||
)
|
||
{
|
||
var supportFirstUpperCase = true;
|
||
|
||
var hotKeySpecifier = (Rune)0;
|
||
|
||
bool result = TextFormatter.FindHotKey (
|
||
text,
|
||
hotKeySpecifier,
|
||
out int hotPos,
|
||
out Key hotKey,
|
||
supportFirstUpperCase
|
||
);
|
||
|
||
if (expectedResult)
|
||
{
|
||
Assert.True (result);
|
||
}
|
||
else
|
||
{
|
||
Assert.False (result);
|
||
}
|
||
|
||
Assert.Equal (expectedResult, result);
|
||
Assert.Equal (expectedHotPos, hotPos);
|
||
Assert.Equal (expectedKey, hotKey);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("_1 Before", true, 0, (KeyCode)'1')] // Digits
|
||
[InlineData ("a_1 Second", true, 1, (KeyCode)'1')]
|
||
[InlineData ("Last _1", true, 5, (KeyCode)'1')]
|
||
[InlineData ("After 1_", false, -1, KeyCode.Null)]
|
||
[InlineData ("Multiple _1 and _2", true, 9, (KeyCode)'1')]
|
||
[InlineData ("_1 Before", true, 0, (KeyCode)'1', true)] // Turn on FirstUpperCase and verify same results
|
||
[InlineData ("a_1 Second", true, 1, (KeyCode)'1', true)]
|
||
[InlineData ("Last _1", true, 5, (KeyCode)'1', true)]
|
||
[InlineData ("After 1_", false, -1, KeyCode.Null, true)]
|
||
[InlineData ("Multiple _1 and _2", true, 9, (KeyCode)'1', true)]
|
||
public void FindHotKey_Numeric_Succeeds (
|
||
string text,
|
||
bool expectedResult,
|
||
int expectedHotPos,
|
||
KeyCode expectedKey,
|
||
bool supportFirstUpperCase = false
|
||
)
|
||
{
|
||
var hotKeySpecifier = (Rune)'_';
|
||
|
||
bool result = TextFormatter.FindHotKey (
|
||
text,
|
||
hotKeySpecifier,
|
||
out int hotPos,
|
||
out Key hotKey,
|
||
supportFirstUpperCase
|
||
);
|
||
|
||
if (expectedResult)
|
||
{
|
||
Assert.True (result);
|
||
}
|
||
else
|
||
{
|
||
Assert.False (result);
|
||
}
|
||
|
||
Assert.Equal (expectedResult, result);
|
||
Assert.Equal (expectedHotPos, hotPos);
|
||
Assert.Equal (expectedKey, hotKey);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("_\"k before", true, (KeyCode)'"')] // BUGBUG: Not sure why this fails. " is a normal char
|
||
[InlineData ("\"_k before", true, KeyCode.K)]
|
||
[InlineData ("_`~!@#$%^&*()-_=+[{]}\\|;:'\",<.>/?", true, (KeyCode)'`')]
|
||
[InlineData ("`_~!@#$%^&*()-_=+[{]}\\|;:'\",<.>/?", true, (KeyCode)'~')]
|
||
[InlineData (
|
||
"`~!@#$%^&*()-__=+[{]}\\|;:'\",<.>/?",
|
||
true,
|
||
(KeyCode)'='
|
||
)] // BUGBUG: Not sure why this fails. Ignore the first and consider the second
|
||
[InlineData ("_ ~ s gui.cs master ↑10", true, (KeyCode)'')] // ~IsLetterOrDigit + Unicode
|
||
[InlineData (" ~ s gui.cs _ master ↑10", true, (KeyCode)'')] // ~IsLetterOrDigit + Unicode
|
||
[InlineData ("non-english: _кдать", true, (KeyCode)'к')] // Lower case Cryllic K (к)
|
||
public void FindHotKey_Symbols_Returns_Symbol (string text, bool found, KeyCode expected)
|
||
{
|
||
var hotKeySpecifier = (Rune)'_';
|
||
|
||
bool result = TextFormatter.FindHotKey (text, hotKeySpecifier, out int _, out Key hotKey);
|
||
Assert.Equal (found, result);
|
||
Assert.Equal (expected, hotKey);
|
||
}
|
||
|
||
[Fact]
|
||
public void Format_Dont_Throw_ArgumentException_With_WordWrap_As_False_And_Keep_End_Spaces_As_True ()
|
||
{
|
||
Exception exception = Record.Exception (
|
||
() =>
|
||
TextFormatter.Format (
|
||
"Some text",
|
||
4,
|
||
TextAlignment.Left,
|
||
false,
|
||
true
|
||
)
|
||
);
|
||
Assert.Null (exception);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (
|
||
"Hello world, how are you today? Pretty neat!",
|
||
44,
|
||
80,
|
||
"Hello world, how are you today? Pretty neat!"
|
||
)]
|
||
public void Format_Justified_Always_Returns_Text_Width_Equal_To_Passed_Width_Horizontal (
|
||
string text,
|
||
int runeCount,
|
||
int maxWidth,
|
||
string justifiedText
|
||
)
|
||
{
|
||
Assert.Equal (runeCount, text.GetRuneCount ());
|
||
|
||
var fmtText = string.Empty;
|
||
|
||
for (int i = text.GetRuneCount (); i < maxWidth; i++)
|
||
{
|
||
fmtText = TextFormatter.Format (text, i, TextAlignment.Justified, false, true) [0];
|
||
Assert.Equal (i, fmtText.GetRuneCount ());
|
||
char c = fmtText [^1];
|
||
Assert.True (text.EndsWith (c));
|
||
}
|
||
|
||
Assert.Equal (justifiedText, fmtText);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (
|
||
"Hello world, how are you today? Pretty neat!",
|
||
44,
|
||
80,
|
||
"Hello world, how are you today? Pretty neat!"
|
||
)]
|
||
public void Format_Justified_Always_Returns_Text_Width_Equal_To_Passed_Width_Vertical (
|
||
string text,
|
||
int runeCount,
|
||
int maxWidth,
|
||
string justifiedText
|
||
)
|
||
{
|
||
Assert.Equal (runeCount, text.GetRuneCount ());
|
||
|
||
var fmtText = string.Empty;
|
||
|
||
for (int i = text.GetRuneCount (); i < maxWidth; i++)
|
||
{
|
||
fmtText = TextFormatter.Format (
|
||
text,
|
||
i,
|
||
TextAlignment.Justified,
|
||
false,
|
||
true,
|
||
0,
|
||
TextDirection.TopBottom_LeftRight
|
||
) [0];
|
||
Assert.Equal (i, fmtText.GetRuneCount ());
|
||
char c = fmtText [^1];
|
||
Assert.True (text.EndsWith (c));
|
||
}
|
||
|
||
Assert.Equal (justifiedText, fmtText);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("Truncate", 3, "Tru")]
|
||
[InlineData ("デモエムポンズ", 3, "デ")]
|
||
public void Format_Truncate_Simple_And_Wide_Runes (string text, int width, string expected)
|
||
{
|
||
List<string> list = TextFormatter.Format (text, width, false, false);
|
||
Assert.Equal (expected, list [^1]);
|
||
}
|
||
|
||
[Theory]
|
||
[MemberData (nameof (FormatEnvironmentNewLine))]
|
||
public void Format_With_PreserveTrailingSpaces_And_Without_PreserveTrailingSpaces (
|
||
string text,
|
||
int width,
|
||
IEnumerable<string> expected
|
||
)
|
||
{
|
||
var preserveTrailingSpaces = false;
|
||
List<string> formated = TextFormatter.Format (text, width, false, true, preserveTrailingSpaces);
|
||
Assert.Equal (expected, formated);
|
||
|
||
preserveTrailingSpaces = true;
|
||
formated = TextFormatter.Format (text, width, false, true, preserveTrailingSpaces);
|
||
Assert.Equal (expected, formated);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (
|
||
" A sentence has words. \n This is the second Line - 2. ",
|
||
4,
|
||
-50,
|
||
TextAlignment.Left,
|
||
true,
|
||
false,
|
||
new [] { " A", "sent", "ence", "has", "word", "s. ", " Thi", "s is", "the", "seco", "nd", "Line", "- 2." },
|
||
" Asentencehaswords. This isthesecondLine- 2."
|
||
)]
|
||
[InlineData (
|
||
" A sentence has words. \n This is the second Line - 2. ",
|
||
4,
|
||
-50,
|
||
TextAlignment.Left,
|
||
true,
|
||
true,
|
||
new []
|
||
{
|
||
" A ",
|
||
"sent",
|
||
"ence",
|
||
" ",
|
||
"has ",
|
||
"word",
|
||
"s. ",
|
||
" ",
|
||
"This",
|
||
" is ",
|
||
"the ",
|
||
"seco",
|
||
"nd ",
|
||
"Line",
|
||
" - ",
|
||
"2. "
|
||
},
|
||
" A sentence has words. This is the second Line - 2. "
|
||
)]
|
||
public void Format_WordWrap_PreserveTrailingSpaces (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
TextAlignment textAlignment,
|
||
bool wrap,
|
||
bool preserveTrailingSpaces,
|
||
IEnumerable<string> resultLines,
|
||
string expectedWrappedText
|
||
)
|
||
{
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
List<string> list = TextFormatter.Format (text, maxWidth, textAlignment, wrap, preserveTrailingSpaces);
|
||
Assert.Equal (list.Count, resultLines.Count ());
|
||
Assert.Equal (resultLines, list);
|
||
var wrappedText = string.Empty;
|
||
|
||
foreach (string txt in list)
|
||
{
|
||
wrappedText += txt;
|
||
}
|
||
|
||
Assert.Equal (expectedWrappedText, wrappedText);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("Hello World", 11)]
|
||
[InlineData ("こんにちは世界", 14)]
|
||
public void GetColumns_Simple_And_Wide_Runes (string text, int width) { Assert.Equal (width, text.GetColumns ()); }
|
||
|
||
[Theory]
|
||
[InlineData ("Hello World", 6, 6)]
|
||
[InlineData ("こんにちは 世界", 6, 3)]
|
||
[MemberData (nameof (CMGlyphs))]
|
||
public void GetLengthThatFits_List_Simple_And_Wide_Runes (string text, int columns, int expectedLength)
|
||
{
|
||
List<Rune> runes = text.ToRuneList ();
|
||
Assert.Equal (expectedLength, TextFormatter.GetLengthThatFits (runes, columns));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", 3, 3)]
|
||
[InlineData ("test", 4, 4)]
|
||
[InlineData ("test", 10, 4)]
|
||
public void GetLengthThatFits_Runelist (string text, int columns, int expectedLength)
|
||
{
|
||
List<Rune> runes = text.ToRuneList ();
|
||
|
||
Assert.Equal (expectedLength, TextFormatter.GetLengthThatFits (runes, columns));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("Hello World", 6, 6)]
|
||
[InlineData ("こんにちは 世界", 6, 3)]
|
||
public void GetLengthThatFits_Simple_And_Wide_Runes (string text, int columns, int expectedLength)
|
||
{
|
||
Assert.Equal (expectedLength, TextFormatter.GetLengthThatFits (text, columns));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", 3, 3)]
|
||
[InlineData ("test", 4, 4)]
|
||
[InlineData ("test", 10, 4)]
|
||
[InlineData ("test", 1, 1)]
|
||
[InlineData ("test", 0, 0)]
|
||
[InlineData ("test", -1, 0)]
|
||
[InlineData (null, -1, 0)]
|
||
[InlineData ("", -1, 0)]
|
||
public void GetLengthThatFits_String (string text, int columns, int expectedLength)
|
||
{
|
||
Assert.Equal (expectedLength, TextFormatter.GetLengthThatFits (text, columns));
|
||
}
|
||
|
||
[Fact]
|
||
public void GetLengthThatFits_With_Combining_Runes ()
|
||
{
|
||
var text = "Les Mise\u0328\u0301rables";
|
||
Assert.Equal (16, TextFormatter.GetLengthThatFits (text, 14));
|
||
}
|
||
|
||
[Fact]
|
||
public void GetMaxColsForWidth_With_Combining_Runes ()
|
||
{
|
||
List<string> text = new () { "Les Mis", "e\u0328\u0301", "rables" };
|
||
Assert.Equal (1, TextFormatter.GetMaxColsForWidth (text, 1));
|
||
}
|
||
|
||
|
||
[Theory]
|
||
[InlineData (new [] { "0123456789" }, 1)]
|
||
[InlineData (new [] { "Hello World" }, 1)]
|
||
[InlineData (new [] { "Hello", "World" }, 2)]
|
||
[InlineData (new [] { "こんにちは", "世界" }, 4)]
|
||
public void GetColumnsRequiredForVerticalText_List_GetsWidth (IEnumerable<string> text, int expectedWidth)
|
||
{
|
||
Assert.Equal (expectedWidth, TextFormatter.GetColumnsRequiredForVerticalText (text.ToList ()));
|
||
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (new [] { "Hello World" }, 1, 0, 1, 1)]
|
||
[InlineData (new [] { "Hello", "World" }, 2, 1, 1, 1)]
|
||
[InlineData (new [] { "こんにちは", "世界" }, 4, 1, 1, 2)]
|
||
public void GetColumnsRequiredForVerticalText_List_Simple_And_Wide_Runes (
|
||
IEnumerable<string> text,
|
||
int expectedWidth,
|
||
int index,
|
||
int length,
|
||
int expectedIndexWidth
|
||
)
|
||
{
|
||
Assert.Equal (expectedWidth, TextFormatter.GetColumnsRequiredForVerticalText (text.ToList ()));
|
||
Assert.Equal (expectedIndexWidth, TextFormatter.GetColumnsRequiredForVerticalText (text.ToList (), index, length));
|
||
}
|
||
|
||
[Fact]
|
||
public void GetColumnsRequiredForVerticalText_List_With_Combining_Runes ()
|
||
{
|
||
List<string> text = new () { "Les Mis", "e\u0328\u0301", "rables" };
|
||
Assert.Equal (1, TextFormatter.GetColumnsRequiredForVerticalText (text, 1, 1));
|
||
}
|
||
|
||
//[Fact]
|
||
//public void GetWidestLineLength_With_Combining_Runes ()
|
||
//{
|
||
// var text = "Les Mise\u0328\u0301rables";
|
||
// Assert.Equal (1, TextFormatter.GetWidestLineLength (text, 1, 1));
|
||
//}
|
||
|
||
[Fact]
|
||
public void Internal_Tests ()
|
||
{
|
||
var tf = new TextFormatter ();
|
||
Assert.Equal (KeyCode.Null, tf.HotKey);
|
||
tf.HotKey = KeyCode.CtrlMask | KeyCode.Q;
|
||
Assert.Equal (KeyCode.CtrlMask | KeyCode.Q, tf.HotKey);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("")]
|
||
[InlineData (null)]
|
||
[InlineData ("test")]
|
||
public void Justify_Invalid (string text)
|
||
{
|
||
Assert.Equal (text, TextFormatter.Justify (text, 0));
|
||
Assert.Equal (text, TextFormatter.Justify (text, 0));
|
||
Assert.Throws<ArgumentOutOfRangeException> (() => TextFormatter.Justify (text, -1));
|
||
}
|
||
|
||
[Theory]
|
||
|
||
// Even # of spaces
|
||
// 0123456789
|
||
[InlineData ("012 456 89", "012 456 89", 10, 0, "+", true)]
|
||
[InlineData ("012 456 89", "012++456+89", 11, 1)]
|
||
[InlineData ("012 456 89", "012 456 89", 12, 2, "++", true)]
|
||
[InlineData ("012 456 89", "012+++456++89", 13, 3)]
|
||
[InlineData ("012 456 89", "012 456 89", 14, 4, "+++", true)]
|
||
[InlineData ("012 456 89", "012++++456+++89", 15, 5)]
|
||
[InlineData ("012 456 89", "012 456 89", 16, 6, "++++", true)]
|
||
[InlineData ("012 456 89", "012 456 89", 30, 20, "+++++++++++", true)]
|
||
[InlineData ("012 456 89", "012+++++++++++++456++++++++++++89", 33, 23)]
|
||
|
||
// Odd # of spaces
|
||
// 01234567890123
|
||
[InlineData ("012 456 89 end", "012 456 89 end", 14, 0, "+", true)]
|
||
[InlineData ("012 456 89 end", "012++456+89+end", 15, 1)]
|
||
[InlineData ("012 456 89 end", "012++456++89+end", 16, 2)]
|
||
[InlineData ("012 456 89 end", "012 456 89 end", 17, 3, "++", true)]
|
||
[InlineData ("012 456 89 end", "012+++456++89++end", 18, 4)]
|
||
[InlineData ("012 456 89 end", "012+++456+++89++end", 19, 5)]
|
||
[InlineData ("012 456 89 end", "012 456 89 end", 20, 6, "+++", true)]
|
||
[InlineData ("012 456 89 end", "012++++++++456++++++++89+++++++end", 34, 20)]
|
||
[InlineData ("012 456 89 end", "012+++++++++456+++++++++89++++++++end", 37, 23)]
|
||
|
||
// Unicode
|
||
// Even # of chars
|
||
// 0123456789
|
||
[InlineData ("пÑРвРÑ", "пÑРвРÑ", 10, 0, "+", true)]
|
||
[InlineData ("пÑРвРÑ", "пÑÐ++вÐ+Ñ", 11, 1)]
|
||
[InlineData ("пÑРвРÑ", "пÑРвРÑ", 12, 2, "++", true)]
|
||
[InlineData ("пÑРвРÑ", "пÑÐ+++вÐ++Ñ", 13, 3)]
|
||
[InlineData ("пÑРвРÑ", "пÑРвРÑ", 14, 4, "+++", true)]
|
||
[InlineData ("пÑРвРÑ", "пÑÐ++++вÐ+++Ñ", 15, 5)]
|
||
[InlineData ("пÑРвРÑ", "пÑРвРÑ", 16, 6, "++++", true)]
|
||
[InlineData ("пÑРвРÑ", "пÑРвРÑ", 30, 20, "+++++++++++", true)]
|
||
[InlineData ("пÑРвРÑ", "пÑÐ+++++++++++++вÐ++++++++++++Ñ", 33, 23)]
|
||
|
||
// Unicode
|
||
// Odd # of chars
|
||
// 0123456789
|
||
[InlineData ("Ð ÑРвРÑ", "Ð ÑРвРÑ", 10, 0, "+", true)]
|
||
[InlineData ("Ð ÑРвРÑ", "Ð++ÑÐ+вÐ+Ñ", 11, 1)]
|
||
[InlineData ("Ð ÑРвРÑ", "Ð++ÑÐ++вÐ+Ñ", 12, 2)]
|
||
[InlineData ("Ð ÑРвРÑ", "Ð ÑРвРÑ", 13, 3, "++", true)]
|
||
[InlineData ("Ð ÑРвРÑ", "Ð+++ÑÐ++вÐ++Ñ", 14, 4)]
|
||
[InlineData ("Ð ÑРвРÑ", "Ð+++ÑÐ+++вÐ++Ñ", 15, 5)]
|
||
[InlineData ("Ð ÑРвРÑ", "Ð ÑРвРÑ", 16, 6, "+++", true)]
|
||
[InlineData ("Ð ÑРвРÑ", "Ð++++++++ÑÐ++++++++вÐ+++++++Ñ", 30, 20)]
|
||
[InlineData ("Ð ÑРвРÑ", "Ð+++++++++ÑÐ+++++++++вÐ++++++++Ñ", 33, 23)]
|
||
public void Justify_Sentence (
|
||
string text,
|
||
string justifiedText,
|
||
int forceToWidth,
|
||
int widthOffset,
|
||
string replaceWith = null,
|
||
bool replace = false
|
||
)
|
||
{
|
||
var fillChar = '+';
|
||
|
||
Assert.Equal (forceToWidth, text.GetRuneCount () + widthOffset);
|
||
|
||
if (replace)
|
||
{
|
||
justifiedText = text.Replace (" ", replaceWith);
|
||
}
|
||
|
||
Assert.Equal (justifiedText, TextFormatter.Justify (text, forceToWidth, fillChar));
|
||
Assert.True (Math.Abs (forceToWidth - justifiedText.GetRuneCount ()) < text.Count (s => s == ' '));
|
||
Assert.True (Math.Abs (forceToWidth - justifiedText.GetColumns ()) < text.Count (s => s == ' '));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("word")] // Even # of chars
|
||
[InlineData ("word.")] // Odd # of chars
|
||
[InlineData ("пÑивеÑ")] // Unicode (even #)
|
||
[InlineData ("пÑивеÑ.")] // Unicode (odd # of chars)
|
||
public void Justify_SingleWord (string text)
|
||
{
|
||
string justifiedText = text;
|
||
var fillChar = '+';
|
||
|
||
int width = text.GetRuneCount ();
|
||
Assert.Equal (justifiedText, TextFormatter.Justify (text, width, fillChar));
|
||
width = text.GetRuneCount () + 1;
|
||
Assert.Equal (justifiedText, TextFormatter.Justify (text, width, fillChar));
|
||
width = text.GetRuneCount () + 2;
|
||
Assert.Equal (justifiedText, TextFormatter.Justify (text, width, fillChar));
|
||
width = text.GetRuneCount () + 10;
|
||
Assert.Equal (justifiedText, TextFormatter.Justify (text, width, fillChar));
|
||
width = text.GetRuneCount () + 11;
|
||
Assert.Equal (justifiedText, TextFormatter.Justify (text, width, fillChar));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("Single Line 界", 14)]
|
||
[InlineData ("First Line 界\nSecond Line 界\nThird Line 界\n", 14)]
|
||
public void MaxWidthLine_With_And_Without_Newlines (string text, int expected) { Assert.Equal (expected, TextFormatter.GetWidestLineLength (text)); }
|
||
|
||
[Theory]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
0,
|
||
0,
|
||
false,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
0,
|
||
1,
|
||
false,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
1,
|
||
0,
|
||
false,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
0,
|
||
0,
|
||
true,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
0,
|
||
1,
|
||
true,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
1,
|
||
0,
|
||
true,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
6,
|
||
5,
|
||
false,
|
||
new [] { "First " }
|
||
)]
|
||
[InlineData ("1\n2\n3\n4\n5\n6", 6, 5, false, new [] { "1 2 3 " })]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
6,
|
||
5,
|
||
true,
|
||
new [] { "First ", "Second", "Third ", "Forty ", "Fiftee" }
|
||
)]
|
||
[InlineData ("第一行\n第二行\n第三行\n四十行\n第十五行\n七十行", 5, 5, false, new [] { "第一" })]
|
||
[InlineData ("第一行\n第二行\n第三行\n四十行\n第十五行\n七十行", 5, 5, true, new [] { "第一", "第二", "第三", "四十", "第十" })]
|
||
public void MultiLine_WordWrap_False_Horizontal_Direction (
|
||
string text,
|
||
int maxWidth,
|
||
int maxHeight,
|
||
bool multiLine,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
var tf = new TextFormatter
|
||
{
|
||
Text = text, Size = new (maxWidth, maxHeight), WordWrap = false, MultiLine = multiLine
|
||
};
|
||
|
||
Assert.False (tf.AutoSize);
|
||
Assert.False (tf.WordWrap);
|
||
Assert.True (tf.MultiLine == multiLine);
|
||
Assert.Equal (TextDirection.LeftRight_TopBottom, tf.Direction);
|
||
|
||
List<string> splitLines = tf.GetLines ();
|
||
Assert.Equal (splitLines.Count, resultLines.Count ());
|
||
Assert.Equal (splitLines, resultLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
0,
|
||
0,
|
||
false,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
0,
|
||
1,
|
||
false,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
1,
|
||
0,
|
||
false,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
0,
|
||
0,
|
||
true,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
0,
|
||
1,
|
||
true,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
1,
|
||
0,
|
||
true,
|
||
new [] { "" }
|
||
)]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
6,
|
||
5,
|
||
false,
|
||
new [] { "First" }
|
||
)]
|
||
[InlineData ("1\n2\n3\n4\n5\n6", 6, 5, false, new [] { "1 2 3" })]
|
||
[InlineData (
|
||
"First Line\nSecond Line\nThird Line\nForty Line\nFifteenth Line\nSeventy Line",
|
||
6,
|
||
5,
|
||
true,
|
||
new [] { "First", "Secon", "Third", "Forty", "Fifte", "Seven" }
|
||
)]
|
||
[InlineData ("第一行\n第二行\n第三行\n四十行\n第十五行\n七十行", 5, 5, false, new [] { "第一行 第" })]
|
||
[InlineData ("第一行\n第二行\n第三行\n四十行\n第十五行\n七十行", 5, 5, true, new [] { "第一行", "第二行" })]
|
||
public void MultiLine_WordWrap_False_Vertical_Direction (
|
||
string text,
|
||
int maxWidth,
|
||
int maxHeight,
|
||
bool multiLine,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
var tf = new TextFormatter
|
||
{
|
||
Text = text,
|
||
Size = new (maxWidth, maxHeight),
|
||
WordWrap = false,
|
||
MultiLine = multiLine,
|
||
Direction = TextDirection.TopBottom_LeftRight
|
||
};
|
||
|
||
Assert.False (tf.AutoSize);
|
||
Assert.False (tf.WordWrap);
|
||
Assert.True (tf.MultiLine == multiLine);
|
||
Assert.Equal (TextDirection.TopBottom_LeftRight, tf.Direction);
|
||
|
||
List<string> splitLines = tf.GetLines ();
|
||
Assert.Equal (splitLines.Count, resultLines.Count ());
|
||
Assert.Equal (splitLines, resultLines);
|
||
}
|
||
|
||
[Fact]
|
||
public void NeedsFormat_Sets ()
|
||
{
|
||
var testText = "test";
|
||
var testBounds = new Rectangle (0, 0, 100, 1);
|
||
var tf = new TextFormatter ();
|
||
|
||
tf.Text = "test";
|
||
Assert.True (tf.NeedsFormat); // get_Lines causes a Format
|
||
Assert.NotEmpty (tf.GetLines ());
|
||
Assert.False (tf.NeedsFormat); // get_Lines causes a Format
|
||
Assert.Equal (testText, tf.Text);
|
||
tf.Draw (testBounds, new Attribute (), new Attribute ());
|
||
Assert.False (tf.NeedsFormat);
|
||
|
||
tf.Size = new (1, 1);
|
||
Assert.True (tf.NeedsFormat);
|
||
Assert.NotEmpty (tf.GetLines ());
|
||
Assert.False (tf.NeedsFormat); // get_Lines causes a Format
|
||
|
||
tf.Alignment = TextAlignment.Centered;
|
||
Assert.True (tf.NeedsFormat);
|
||
Assert.NotEmpty (tf.GetLines ());
|
||
Assert.False (tf.NeedsFormat); // get_Lines causes a Format
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("", -1, TextAlignment.Left, false, 0)]
|
||
[InlineData (null, 0, TextAlignment.Left, false, 1)]
|
||
[InlineData (null, 0, TextAlignment.Left, true, 1)]
|
||
[InlineData ("", 0, TextAlignment.Left, false, 1)]
|
||
[InlineData ("", 0, TextAlignment.Left, true, 1)]
|
||
public void Reformat_Invalid (string text, int maxWidth, TextAlignment textAlignment, bool wrap, int linesCount)
|
||
{
|
||
if (maxWidth < 0)
|
||
{
|
||
Assert.Throws<ArgumentOutOfRangeException> (
|
||
() =>
|
||
TextFormatter.Format (text, maxWidth, textAlignment, wrap)
|
||
);
|
||
}
|
||
else
|
||
{
|
||
List<string> list = TextFormatter.Format (text, maxWidth, textAlignment, wrap);
|
||
Assert.NotEmpty (list);
|
||
Assert.True (list.Count == linesCount);
|
||
Assert.Equal (string.Empty, list [0]);
|
||
}
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("A sentence has words.\nLine 2.", 0, -29, TextAlignment.Left, false, 1, true)]
|
||
[InlineData ("A sentence has words.\nLine 2.", 1, -28, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.\nLine 2.", 5, -24, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.\nLine 2.", 28, -1, TextAlignment.Left, false, 1, false)]
|
||
|
||
// no clip
|
||
[InlineData ("A sentence has words.\nLine 2.", 29, 0, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.\nLine 2.", 30, 1, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.\r\nLine 2.", 0, -30, TextAlignment.Left, false, 1, true)]
|
||
[InlineData ("A sentence has words.\r\nLine 2.", 1, -29, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.\r\nLine 2.", 5, -25, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.\r\nLine 2.", 29, -1, TextAlignment.Left, false, 1, false, 1)]
|
||
[InlineData ("A sentence has words.\r\nLine 2.", 30, 0, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.\r\nLine 2.", 31, 1, TextAlignment.Left, false, 1, false)]
|
||
public void Reformat_NoWordrap_NewLines_MultiLine_False (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
TextAlignment textAlignment,
|
||
bool wrap,
|
||
int linesCount,
|
||
bool stringEmpty,
|
||
int clipWidthOffset = 0
|
||
)
|
||
{
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth) + clipWidthOffset;
|
||
List<string> list = TextFormatter.Format (text, maxWidth, textAlignment, wrap);
|
||
Assert.NotEmpty (list);
|
||
Assert.True (list.Count == linesCount);
|
||
|
||
if (stringEmpty)
|
||
{
|
||
Assert.Equal (string.Empty, list [0]);
|
||
}
|
||
else
|
||
{
|
||
Assert.NotEqual (string.Empty, list [0]);
|
||
}
|
||
|
||
if (text.Contains ("\r\n") && maxWidth > 0)
|
||
{
|
||
Assert.Equal (
|
||
StringExtensions.ToString (text.ToRunes () [..expectedClippedWidth])
|
||
.Replace ("\r\n", " "),
|
||
list [0]
|
||
);
|
||
}
|
||
else if (text.Contains ('\n') && maxWidth > 0)
|
||
{
|
||
Assert.Equal (
|
||
StringExtensions.ToString (text.ToRunes () [..expectedClippedWidth])
|
||
.Replace ("\n", " "),
|
||
list [0]
|
||
);
|
||
}
|
||
else
|
||
{
|
||
Assert.Equal (StringExtensions.ToString (text.ToRunes () [..expectedClippedWidth]), list [0]);
|
||
}
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("A sentence has words.\nLine 2.", 0, -29, TextAlignment.Left, false, 1, true, new [] { "" })]
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
1,
|
||
-28,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A", "L" }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
5,
|
||
-24,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sen", "Line " }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
28,
|
||
-1,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
//// no clip
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
29,
|
||
0,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
30,
|
||
1,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
[InlineData ("A sentence has words.\r\nLine 2.", 0, -30, TextAlignment.Left, false, 1, true, new [] { "" })]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
1,
|
||
-29,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A", "L" }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
5,
|
||
-25,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sen", "Line " }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
29,
|
||
-1,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
30,
|
||
0,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
31,
|
||
1,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
public void Reformat_NoWordrap_NewLines_MultiLine_True (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
TextAlignment textAlignment,
|
||
bool wrap,
|
||
int linesCount,
|
||
bool stringEmpty,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
|
||
List<string> list = TextFormatter.Format (
|
||
text,
|
||
maxWidth,
|
||
textAlignment,
|
||
wrap,
|
||
false,
|
||
0,
|
||
TextDirection.LeftRight_TopBottom,
|
||
true
|
||
);
|
||
Assert.NotEmpty (list);
|
||
Assert.True (list.Count == linesCount);
|
||
|
||
if (stringEmpty)
|
||
{
|
||
Assert.Equal (string.Empty, list [0]);
|
||
}
|
||
else
|
||
{
|
||
Assert.NotEqual (string.Empty, list [0]);
|
||
}
|
||
|
||
Assert.Equal (list, resultLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("A sentence has words.\nLine 2.", 0, -29, TextAlignment.Left, false, 1, true, new [] { "" })]
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
1,
|
||
-28,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A", "L" }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
5,
|
||
-24,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sen", "Line " }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
28,
|
||
-1,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
//// no clip
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
29,
|
||
0,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nLine 2.",
|
||
30,
|
||
1,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
[InlineData ("A sentence has words.\r\nLine 2.", 0, -30, TextAlignment.Left, false, 1, true, new [] { "" })]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
1,
|
||
-29,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A", "L" }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
5,
|
||
-25,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sen", "Line " }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
29,
|
||
-1,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
30,
|
||
0,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\r\nLine 2.",
|
||
31,
|
||
1,
|
||
TextAlignment.Left,
|
||
false,
|
||
2,
|
||
false,
|
||
new [] { "A sentence has words.", "Line 2." }
|
||
)]
|
||
public void Reformat_NoWordrap_NewLines_MultiLine_True_Vertical (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
TextAlignment textAlignment,
|
||
bool wrap,
|
||
int linesCount,
|
||
bool stringEmpty,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
|
||
List<string> list = TextFormatter.Format (
|
||
text,
|
||
maxWidth,
|
||
textAlignment,
|
||
wrap,
|
||
false,
|
||
0,
|
||
TextDirection.TopBottom_LeftRight,
|
||
true
|
||
);
|
||
Assert.NotEmpty (list);
|
||
Assert.True (list.Count == linesCount);
|
||
|
||
if (stringEmpty)
|
||
{
|
||
Assert.Equal (string.Empty, list [0]);
|
||
}
|
||
else
|
||
{
|
||
Assert.NotEqual (string.Empty, list [0]);
|
||
}
|
||
|
||
Assert.Equal (list, resultLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("", 0, 0, TextAlignment.Left, false, 1, true)]
|
||
[InlineData ("", 1, 1, TextAlignment.Left, false, 1, true)]
|
||
[InlineData ("A sentence has words.", 0, -21, TextAlignment.Left, false, 1, true)]
|
||
[InlineData ("A sentence has words.", 1, -20, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.", 5, -16, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.", 20, -1, TextAlignment.Left, false, 1, false)]
|
||
|
||
// no clip
|
||
[InlineData ("A sentence has words.", 21, 0, TextAlignment.Left, false, 1, false)]
|
||
[InlineData ("A sentence has words.", 22, 1, TextAlignment.Left, false, 1, false)]
|
||
public void Reformat_NoWordrap_SingleLine (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
TextAlignment textAlignment,
|
||
bool wrap,
|
||
int linesCount,
|
||
bool stringEmpty
|
||
)
|
||
{
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
List<string> list = TextFormatter.Format (text, maxWidth, textAlignment, wrap);
|
||
Assert.NotEmpty (list);
|
||
Assert.True (list.Count == linesCount);
|
||
|
||
if (stringEmpty)
|
||
{
|
||
Assert.Equal (string.Empty, list [0]);
|
||
}
|
||
else
|
||
{
|
||
Assert.NotEqual (string.Empty, list [0]);
|
||
}
|
||
|
||
Assert.Equal (StringExtensions.ToString (text.ToRunes () [..expectedClippedWidth]), list [0]);
|
||
}
|
||
|
||
[Theory]
|
||
|
||
// Unicode
|
||
[InlineData (
|
||
"\u2460\u2461\u2462\n\u2460\u2461\u2462\u2463\u2464",
|
||
8,
|
||
-1,
|
||
TextAlignment.Left,
|
||
true,
|
||
false,
|
||
new [] { "\u2460\u2461\u2462", "\u2460\u2461\u2462\u2463\u2464" }
|
||
)]
|
||
|
||
// no clip
|
||
[InlineData (
|
||
"\u2460\u2461\u2462\n\u2460\u2461\u2462\u2463\u2464",
|
||
9,
|
||
0,
|
||
TextAlignment.Left,
|
||
true,
|
||
false,
|
||
new [] { "\u2460\u2461\u2462", "\u2460\u2461\u2462\u2463\u2464" }
|
||
)]
|
||
[InlineData (
|
||
"\u2460\u2461\u2462\n\u2460\u2461\u2462\u2463\u2464",
|
||
10,
|
||
1,
|
||
TextAlignment.Left,
|
||
true,
|
||
false,
|
||
new [] { "\u2460\u2461\u2462", "\u2460\u2461\u2462\u2463\u2464" }
|
||
)]
|
||
public void Reformat_Unicode_Wrap_Spaces_NewLines (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
TextAlignment textAlignment,
|
||
bool wrap,
|
||
bool preserveTrailingSpaces,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
List<string> list = TextFormatter.Format (text, maxWidth, textAlignment, wrap, preserveTrailingSpaces);
|
||
Assert.Equal (list.Count, resultLines.Count ());
|
||
Assert.Equal (resultLines, list);
|
||
}
|
||
|
||
[Theory]
|
||
|
||
// Unicode
|
||
// Even # of chars
|
||
// 0123456789
|
||
[InlineData ("\u2660пÑРвРÑ", 10, -1, TextAlignment.Left, true, false, new [] { "\u2660пÑРвÐ", "Ñ" })]
|
||
|
||
// no clip
|
||
[InlineData ("\u2660пÑРвРÑ", 11, 0, TextAlignment.Left, true, false, new [] { "\u2660пÑРвРÑ" })]
|
||
[InlineData ("\u2660пÑРвРÑ", 12, 1, TextAlignment.Left, true, false, new [] { "\u2660пÑРвРÑ" })]
|
||
|
||
// Unicode
|
||
// Odd # of chars
|
||
// 0123456789
|
||
[InlineData ("\u2660 ÑРвРÑ", 9, -1, TextAlignment.Left, true, false, new [] { "\u2660 ÑРвÐ", "Ñ" })]
|
||
|
||
// no clip
|
||
[InlineData ("\u2660 ÑРвРÑ", 10, 0, TextAlignment.Left, true, false, new [] { "\u2660 ÑРвРÑ" })]
|
||
[InlineData ("\u2660 ÑРвРÑ", 11, 1, TextAlignment.Left, true, false, new [] { "\u2660 ÑРвРÑ" })]
|
||
public void Reformat_Unicode_Wrap_Spaces_No_NewLines (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
TextAlignment textAlignment,
|
||
bool wrap,
|
||
bool preserveTrailingSpaces,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
List<string> list = TextFormatter.Format (text, maxWidth, textAlignment, wrap, preserveTrailingSpaces);
|
||
Assert.Equal (list.Count, resultLines.Count ());
|
||
Assert.Equal (resultLines, list);
|
||
}
|
||
|
||
[Theory]
|
||
|
||
// Even # of spaces
|
||
// 0123456789
|
||
[InlineData ("012 456 89", 0, -10, TextAlignment.Left, true, true, true, new [] { "" })]
|
||
[InlineData (
|
||
"012 456 89",
|
||
1,
|
||
-9,
|
||
TextAlignment.Left,
|
||
true,
|
||
true,
|
||
false,
|
||
new [] { "0", "1", "2", " ", "4", "5", "6", " ", "8", "9" },
|
||
"01245689"
|
||
)]
|
||
[InlineData ("012 456 89", 5, -5, TextAlignment.Left, true, true, false, new [] { "012 ", "456 ", "89" })]
|
||
[InlineData ("012 456 89", 9, -1, TextAlignment.Left, true, true, false, new [] { "012 456 ", "89" })]
|
||
|
||
// no clip
|
||
[InlineData ("012 456 89", 10, 0, TextAlignment.Left, true, true, false, new [] { "012 456 89" })]
|
||
[InlineData ("012 456 89", 11, 1, TextAlignment.Left, true, true, false, new [] { "012 456 89" })]
|
||
|
||
// Odd # of spaces
|
||
// 01234567890123
|
||
[InlineData ("012 456 89 end", 13, -1, TextAlignment.Left, true, true, false, new [] { "012 456 89 ", "end" })]
|
||
|
||
// no clip
|
||
[InlineData ("012 456 89 end", 14, 0, TextAlignment.Left, true, true, false, new [] { "012 456 89 end" })]
|
||
[InlineData ("012 456 89 end", 15, 1, TextAlignment.Left, true, true, false, new [] { "012 456 89 end" })]
|
||
public void Reformat_Wrap_Spaces_No_NewLines (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
TextAlignment textAlignment,
|
||
bool wrap,
|
||
bool preserveTrailingSpaces,
|
||
bool stringEmpty,
|
||
IEnumerable<string> resultLines,
|
||
string noSpaceText = ""
|
||
)
|
||
{
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
List<string> list = TextFormatter.Format (text, maxWidth, textAlignment, wrap, preserveTrailingSpaces);
|
||
Assert.NotEmpty (list);
|
||
Assert.True (list.Count == resultLines.Count ());
|
||
|
||
if (stringEmpty)
|
||
{
|
||
Assert.Equal (string.Empty, list [0]);
|
||
}
|
||
else
|
||
{
|
||
Assert.NotEqual (string.Empty, list [0]);
|
||
}
|
||
|
||
Assert.Equal (resultLines, list);
|
||
|
||
if (maxWidth > 0)
|
||
{
|
||
// remove whitespace chars
|
||
if (maxWidth < 5)
|
||
{
|
||
expectedClippedWidth = text.GetRuneCount () - text.Sum (r => r == ' ' ? 1 : 0);
|
||
}
|
||
else
|
||
{
|
||
expectedClippedWidth = Math.Min (
|
||
text.GetRuneCount (),
|
||
maxWidth - text.Sum (r => r == ' ' ? 1 : 0)
|
||
);
|
||
}
|
||
|
||
list = TextFormatter.Format (text, maxWidth, TextAlignment.Left, wrap);
|
||
|
||
if (maxWidth == 1)
|
||
{
|
||
Assert.Equal (expectedClippedWidth, list.Count);
|
||
Assert.Equal (noSpaceText, string.Concat (list.ToArray ()));
|
||
}
|
||
|
||
if (maxWidth > 1 && maxWidth < 10)
|
||
{
|
||
Assert.Equal (
|
||
StringExtensions.ToString (text.ToRunes () [..expectedClippedWidth]),
|
||
list [0]
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (null)]
|
||
[InlineData ("")]
|
||
[InlineData ("a")]
|
||
public void RemoveHotKeySpecifier_InValid_ReturnsOriginal (string text)
|
||
{
|
||
var hotKeySpecifier = (Rune)'_';
|
||
|
||
if (text == null)
|
||
{
|
||
Assert.Null (TextFormatter.RemoveHotKeySpecifier (text, 0, hotKeySpecifier));
|
||
Assert.Null (TextFormatter.RemoveHotKeySpecifier (text, -1, hotKeySpecifier));
|
||
Assert.Null (TextFormatter.RemoveHotKeySpecifier (text, 100, hotKeySpecifier));
|
||
}
|
||
else
|
||
{
|
||
Assert.Equal (text, TextFormatter.RemoveHotKeySpecifier (text, 0, hotKeySpecifier));
|
||
Assert.Equal (text, TextFormatter.RemoveHotKeySpecifier (text, -1, hotKeySpecifier));
|
||
Assert.Equal (text, TextFormatter.RemoveHotKeySpecifier (text, 100, hotKeySpecifier));
|
||
}
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("all lower case", 0)]
|
||
[InlineData ("K Before", 0)]
|
||
[InlineData ("aK Second", 1)]
|
||
[InlineData ("Last K", 5)]
|
||
[InlineData ("fter K", 7)]
|
||
[InlineData ("Multiple K and R", 9)]
|
||
[InlineData ("Non-english: Кдать", 13)]
|
||
public void RemoveHotKeySpecifier_Valid_Legacy_ReturnsOriginal (string text, int hotPos)
|
||
{
|
||
var hotKeySpecifier = (Rune)'_';
|
||
|
||
Assert.Equal (text, TextFormatter.RemoveHotKeySpecifier (text, hotPos, hotKeySpecifier));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("_K Before", 0, "K Before")]
|
||
[InlineData ("a_K Second", 1, "aK Second")]
|
||
[InlineData ("Last _K", 5, "Last K")]
|
||
[InlineData ("After K_", 7, "After K")]
|
||
[InlineData ("Multiple _K and _R", 9, "Multiple K and _R")]
|
||
[InlineData ("Non-english: _Кдать", 13, "Non-english: Кдать")]
|
||
public void RemoveHotKeySpecifier_Valid_ReturnsStripped (string text, int hotPos, string expectedText)
|
||
{
|
||
var hotKeySpecifier = (Rune)'_';
|
||
|
||
Assert.Equal (expectedText, TextFormatter.RemoveHotKeySpecifier (text, hotPos, hotKeySpecifier));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("test", 0, 't', "test")]
|
||
[InlineData ("test", 1, 'e', "test")]
|
||
[InlineData ("Ok", 0, 'O', "Ok")]
|
||
[InlineData ("[◦ Ok ◦]", 3, 'O', "[◦ Ok ◦]")]
|
||
[InlineData ("^k", 0, '^', "^k")]
|
||
public void ReplaceHotKeyWithTag (string text, int hotPos, uint tag, string expected)
|
||
{
|
||
var tf = new TextFormatter ();
|
||
List<Rune> runes = text.ToRuneList ();
|
||
Rune rune;
|
||
|
||
if (Rune.TryGetRuneAt (text, hotPos, out rune))
|
||
{
|
||
Assert.Equal (rune, (Rune)tag);
|
||
}
|
||
|
||
string result = TextFormatter.ReplaceHotKeyWithTag (text, hotPos);
|
||
Assert.Equal (result, expected);
|
||
Assert.Equal ((Rune)tag, result.ToRunes () [hotPos]);
|
||
Assert.Equal (text.GetRuneCount (), runes.Count);
|
||
Assert.Equal (text, StringExtensions.ToString (runes));
|
||
}
|
||
|
||
[Theory]
|
||
[MemberData (nameof (SplitEnvironmentNewLine))]
|
||
public void SplitNewLine_Ending__With_Or_Without_NewLine_Probably_CRLF (
|
||
string text,
|
||
IEnumerable<string> expected
|
||
)
|
||
{
|
||
List<string> splited = TextFormatter.SplitNewLine (text);
|
||
Assert.Equal (expected, splited);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (
|
||
"First Line 界\nSecond Line 界\nThird Line 界\n",
|
||
new [] { "First Line 界", "Second Line 界", "Third Line 界", "" }
|
||
)]
|
||
public void SplitNewLine_Ending_With_NewLine_Only_LF (string text, IEnumerable<string> expected)
|
||
{
|
||
List<string> splited = TextFormatter.SplitNewLine (text);
|
||
Assert.Equal (expected, splited);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (
|
||
"First Line 界\nSecond Line 界\nThird Line 界",
|
||
new [] { "First Line 界", "Second Line 界", "Third Line 界" }
|
||
)]
|
||
public void SplitNewLine_Ending_Without_NewLine_Only_LF (string text, IEnumerable<string> expected)
|
||
{
|
||
List<string> splited = TextFormatter.SplitNewLine (text);
|
||
Assert.Equal (expected, splited);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("New Test 你", 10, 10, 20320, 20320, 9, "你")]
|
||
[InlineData ("New Test \U0001d539", 10, 11, 120121, 55349, 9, "𝔹")]
|
||
public void String_Array_Is_Not_Always_Equal_ToRunes_Array (
|
||
string text,
|
||
int runesLength,
|
||
int stringLength,
|
||
int runeValue,
|
||
int stringValue,
|
||
int index,
|
||
string expected
|
||
)
|
||
{
|
||
Rune [] usToRunes = text.ToRunes ();
|
||
Assert.Equal (runesLength, usToRunes.Length);
|
||
Assert.Equal (stringLength, text.Length);
|
||
Assert.Equal (runeValue, usToRunes [index].Value);
|
||
Assert.Equal (stringValue, text [index]);
|
||
Assert.Equal (expected, usToRunes [index].ToString ());
|
||
|
||
if (char.IsHighSurrogate (text [index]))
|
||
{
|
||
// Rune array length isn't equal to string array
|
||
Assert.Equal (expected, new string (new [] { text [index], text [index + 1] }));
|
||
}
|
||
else
|
||
{
|
||
// Rune array length is equal to string array
|
||
Assert.Equal (expected, text [index].ToString ());
|
||
}
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (17, 1, TextDirection.LeftRight_TopBottom, 4, "This is a Tab")]
|
||
[InlineData (1, 17, TextDirection.TopBottom_LeftRight, 4, "T\nh\ni\ns\n \ni\ns\n \na\n \n \n \n \n \nT\na\nb")]
|
||
[InlineData (13, 1, TextDirection.LeftRight_TopBottom, 0, "This is a Tab")]
|
||
[InlineData (1, 13, TextDirection.TopBottom_LeftRight, 0, "T\nh\ni\ns\n \ni\ns\n \na\n \nT\na\nb")]
|
||
public void TabWith_PreserveTrailingSpaces_False (
|
||
int width,
|
||
int height,
|
||
TextDirection textDirection,
|
||
int tabWidth,
|
||
string expected
|
||
)
|
||
{
|
||
var driver = new FakeDriver ();
|
||
driver.Init ();
|
||
|
||
var text = "This is a \tTab";
|
||
var tf = new TextFormatter ();
|
||
tf.AutoSize = true;
|
||
tf.Direction = textDirection;
|
||
tf.TabWidth = tabWidth;
|
||
tf.Text = text;
|
||
|
||
Assert.True (tf.WordWrap);
|
||
Assert.False (tf.PreserveTrailingSpaces);
|
||
Assert.Equal (new (width, height), tf.Size);
|
||
|
||
tf.Draw (
|
||
new (0, 0, width, height),
|
||
new Attribute (ColorName.White, ColorName.Black),
|
||
new Attribute (ColorName.Blue, ColorName.Black),
|
||
default (Rectangle),
|
||
driver
|
||
);
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expected, _output, driver);
|
||
|
||
driver.End ();
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (17, 1, TextDirection.LeftRight_TopBottom, 4, "This is a Tab")]
|
||
[InlineData (1, 17, TextDirection.TopBottom_LeftRight, 4, "T\nh\ni\ns\n \ni\ns\n \na\n \n \n \n \n \nT\na\nb")]
|
||
[InlineData (13, 1, TextDirection.LeftRight_TopBottom, 0, "This is a Tab")]
|
||
[InlineData (1, 13, TextDirection.TopBottom_LeftRight, 0, "T\nh\ni\ns\n \ni\ns\n \na\n \nT\na\nb")]
|
||
public void TabWith_PreserveTrailingSpaces_True (
|
||
int width,
|
||
int height,
|
||
TextDirection textDirection,
|
||
int tabWidth,
|
||
string expected
|
||
)
|
||
{
|
||
var driver = new FakeDriver ();
|
||
driver.Init ();
|
||
|
||
var text = "This is a \tTab";
|
||
var tf = new TextFormatter ();
|
||
tf.AutoSize = true;
|
||
|
||
tf.Direction = textDirection;
|
||
tf.TabWidth = tabWidth;
|
||
tf.PreserveTrailingSpaces = true;
|
||
tf.Text = text;
|
||
|
||
Assert.True (tf.WordWrap);
|
||
Assert.Equal (new (width, height), tf.Size);
|
||
|
||
tf.Draw (
|
||
new (0, 0, width, height),
|
||
new Attribute (ColorName.White, ColorName.Black),
|
||
new Attribute (ColorName.Blue, ColorName.Black),
|
||
default (Rectangle),
|
||
driver
|
||
);
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expected, _output, driver);
|
||
|
||
driver.End ();
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (17, 1, TextDirection.LeftRight_TopBottom, 4, "This is a Tab")]
|
||
[InlineData (1, 17, TextDirection.TopBottom_LeftRight, 4, "T\nh\ni\ns\n \ni\ns\n \na\n \n \n \n \n \nT\na\nb")]
|
||
[InlineData (13, 1, TextDirection.LeftRight_TopBottom, 0, "This is a Tab")]
|
||
[InlineData (1, 13, TextDirection.TopBottom_LeftRight, 0, "T\nh\ni\ns\n \ni\ns\n \na\n \nT\na\nb")]
|
||
public void TabWith_WordWrap_True (
|
||
int width,
|
||
int height,
|
||
TextDirection textDirection,
|
||
int tabWidth,
|
||
string expected
|
||
)
|
||
{
|
||
var driver = new FakeDriver ();
|
||
driver.Init ();
|
||
|
||
var text = "This is a \tTab";
|
||
var tf = new TextFormatter ();
|
||
tf.AutoSize = true;
|
||
|
||
tf.Direction = textDirection;
|
||
tf.TabWidth = tabWidth;
|
||
tf.WordWrap = true;
|
||
tf.Text = text;
|
||
|
||
Assert.False (tf.PreserveTrailingSpaces);
|
||
Assert.Equal (new (width, height), tf.Size);
|
||
|
||
tf.Draw (
|
||
new (0, 0, width, height),
|
||
new Attribute (ColorName.White, ColorName.Black),
|
||
new Attribute (ColorName.Blue, ColorName.Black),
|
||
default (Rectangle),
|
||
driver
|
||
);
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expected, _output, driver);
|
||
|
||
driver.End ();
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("123456789", 3, "123")]
|
||
[InlineData ("Hello World", 8, "Hello Wo")]
|
||
public void TestClipOrPad_LongWord (string text, int fillPad, string expectedText)
|
||
{
|
||
// word is long but we want it to fill # space only
|
||
Assert.Equal (expectedText, TextFormatter.ClipOrPad (text, fillPad));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("fff", 6, "fff ")]
|
||
[InlineData ("Hello World", 16, "Hello World ")]
|
||
public void TestClipOrPad_ShortWord (string text, int fillPad, string expectedText)
|
||
{
|
||
// word is short but we want it to fill # so it should be padded
|
||
Assert.Equal (expectedText, TextFormatter.ClipOrPad (text, fillPad));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("你你", TextDirection.LeftRight_TopBottom, 4, 1)]
|
||
[InlineData ("AB", TextDirection.LeftRight_TopBottom, 2, 1)]
|
||
[InlineData ("你你", TextDirection.TopBottom_LeftRight, 2, 2)]
|
||
[InlineData ("AB", TextDirection.TopBottom_LeftRight, 1, 2)]
|
||
public void AutoSize_True_TextDirection_Correct_Size (string text, TextDirection textDirection, int expectedWidth, int expectedHeight)
|
||
{
|
||
var tf = new TextFormatter { Direction = textDirection, Text = text };
|
||
Assert.False (tf.AutoSize);
|
||
|
||
// If autosize is false, no auto sizing!
|
||
Assert.Equal (Size.Empty, tf.Size);
|
||
|
||
tf.Size = new (1, 1); // This should have no impact (autosize overrides)
|
||
tf.AutoSize = true;
|
||
|
||
Assert.Equal (new Size (expectedWidth, expectedHeight), tf.Size);
|
||
}
|
||
|
||
//[Theory]
|
||
//[InlineData (TextAlignment.Left, false)]
|
||
//[InlineData (TextAlignment.Centered, true)]
|
||
//[InlineData (TextAlignment.Right, false)]
|
||
//[InlineData (TextAlignment.Justified, true)]
|
||
//public void TestSize_DirectionChange_AutoSize_True_Or_False_Horizontal (
|
||
// TextAlignment textAlignment,
|
||
// bool autoSize
|
||
//)
|
||
//{
|
||
// var tf = new TextFormatter
|
||
// {
|
||
// Direction = TextDirection.LeftRight_TopBottom, Text = "你你", Alignment = textAlignment, AutoSize = autoSize
|
||
// };
|
||
// Assert.Equal (4, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
|
||
// tf.Direction = TextDirection.TopBottom_LeftRight;
|
||
|
||
// if (autoSize/* && textAlignment != TextAlignment.Justified*/)
|
||
// {
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (2, tf.Size.Height);
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (4, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
//}
|
||
|
||
//[Theory]
|
||
//[InlineData (VerticalTextAlignment.Top, false)]
|
||
//[InlineData (VerticalTextAlignment.Middle, true)]
|
||
//[InlineData (VerticalTextAlignment.Bottom, false)]
|
||
//[InlineData (VerticalTextAlignment.Justified, true)]
|
||
//public void TestSize_DirectionChange_AutoSize_True_Or_False_Vertical (
|
||
// VerticalTextAlignment textAlignment,
|
||
// bool autoSize
|
||
//)
|
||
//{
|
||
// var tf = new TextFormatter
|
||
// {
|
||
// Direction = TextDirection.TopBottom_LeftRight,
|
||
// Text = "你你",
|
||
// VerticalAlignment = textAlignment,
|
||
// AutoSize = autoSize
|
||
// };
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (2, tf.Size.Height);
|
||
|
||
// tf.Direction = TextDirection.LeftRight_TopBottom;
|
||
|
||
// if (autoSize/* && textAlignment != VerticalTextAlignment.Justified*/)
|
||
// {
|
||
// Assert.Equal (4, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (2, tf.Size.Height);
|
||
// }
|
||
//}
|
||
|
||
//[Theory]
|
||
//[InlineData (TextDirection.LeftRight_TopBottom, false)]
|
||
//[InlineData (TextDirection.LeftRight_TopBottom, true)]
|
||
//[InlineData (TextDirection.TopBottom_LeftRight, false)]
|
||
//[InlineData (TextDirection.TopBottom_LeftRight, true)]
|
||
//public void TestSize_SizeChange_AutoSize_True_Or_False (TextDirection textDirection, bool autoSize)
|
||
//{
|
||
// var tf = new TextFormatter { Direction = textDirection, Text = "你你", AutoSize = autoSize };
|
||
|
||
// if (textDirection == TextDirection.LeftRight_TopBottom)
|
||
// {
|
||
// Assert.Equal (4, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (2, tf.Size.Height);
|
||
// }
|
||
|
||
// tf.Size = new (1, 1);
|
||
|
||
// if (autoSize)
|
||
// {
|
||
// if (textDirection == TextDirection.LeftRight_TopBottom)
|
||
// {
|
||
// Assert.Equal (4, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (2, tf.Size.Height);
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (1, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
//}
|
||
|
||
//[Theory]
|
||
//[InlineData (TextAlignment.Left, false)]
|
||
//[InlineData (TextAlignment.Centered, true)]
|
||
//[InlineData (TextAlignment.Right, false)]
|
||
//[InlineData (TextAlignment.Justified, true)]
|
||
//public void TestSize_SizeChange_AutoSize_True_Or_False_Horizontal (TextAlignment textAlignment, bool autoSize)
|
||
//{
|
||
// var tf = new TextFormatter
|
||
// {
|
||
// Direction = TextDirection.LeftRight_TopBottom, Text = "你你", Alignment = textAlignment, AutoSize = autoSize
|
||
// };
|
||
// Assert.Equal (4, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
|
||
// tf.Size = new (1, 1);
|
||
|
||
// if (autoSize)
|
||
// {
|
||
// Assert.Equal (4, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (1, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
//}
|
||
|
||
//[Theory]
|
||
//[InlineData (VerticalTextAlignment.Top, false)]
|
||
//[InlineData (VerticalTextAlignment.Middle, true)]
|
||
//[InlineData (VerticalTextAlignment.Bottom, false)]
|
||
//[InlineData (VerticalTextAlignment.Justified, true)]
|
||
//public void TestSize_SizeChange_AutoSize_True_Or_False_Vertical (
|
||
// VerticalTextAlignment textAlignment,
|
||
// bool autoSize
|
||
//)
|
||
//{
|
||
// var tf = new TextFormatter
|
||
// {
|
||
// Direction = TextDirection.TopBottom_LeftRight,
|
||
// Text = "你你",
|
||
// VerticalAlignment = textAlignment,
|
||
// AutoSize = autoSize
|
||
// };
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (2, tf.Size.Height);
|
||
|
||
// tf.Size = new (1, 1);
|
||
|
||
// if (autoSize)
|
||
// {
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (2, tf.Size.Height);
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (1, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
//}
|
||
|
||
[Theory]
|
||
[InlineData ("你", TextDirection.LeftRight_TopBottom, false, 0, 0)]
|
||
[InlineData ("你", TextDirection.LeftRight_TopBottom, true, 2, 1)]
|
||
[InlineData ("你", TextDirection.TopBottom_LeftRight, false, 0, 0)]
|
||
[InlineData ("你", TextDirection.TopBottom_LeftRight, true, 2, 1)]
|
||
|
||
[InlineData ("你你", TextDirection.LeftRight_TopBottom, false, 0, 0)]
|
||
[InlineData ("你你", TextDirection.LeftRight_TopBottom, true, 4, 1)]
|
||
[InlineData ("你你", TextDirection.TopBottom_LeftRight, false, 0, 0)]
|
||
[InlineData ("你你", TextDirection.TopBottom_LeftRight, true, 2, 2)]
|
||
public void Text_Set_SizeIsCorrect (string text, TextDirection textDirection, bool autoSize, int expectedWidth, int expectedHeight)
|
||
{
|
||
var tf = new TextFormatter { Direction = textDirection, Text = text, AutoSize = autoSize };
|
||
Assert.Equal (new Size (expectedWidth, expectedHeight), tf.Size);
|
||
}
|
||
|
||
//[Theory]
|
||
//[InlineData (TextDirection.LeftRight_TopBottom, false)]
|
||
//[InlineData (TextDirection.LeftRight_TopBottom, true)]
|
||
//[InlineData (TextDirection.TopBottom_LeftRight, false)]
|
||
//[InlineData (TextDirection.TopBottom_LeftRight, true)]
|
||
//public void TestSize_TextChange (TextDirection textDirection, bool autoSize)
|
||
//{
|
||
// var tf = new TextFormatter { Direction = textDirection, Text = "你", AutoSize = autoSize };
|
||
// Assert.Equal (new Size (2, 1), tf.Size);
|
||
// tf.Text = "你你";
|
||
|
||
// Assert.Equal (autoSize, tf.AutoSize);
|
||
|
||
// if (autoSize)
|
||
// {
|
||
// if (textDirection == TextDirection.LeftRight_TopBottom)
|
||
// {
|
||
// Assert.Equal (4, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (2, tf.Size.Height);
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// Assert.Equal (2, tf.Size.Width);
|
||
// Assert.Equal (1, tf.Size.Height);
|
||
// }
|
||
//}
|
||
|
||
[Fact]
|
||
public void WordWrap_BigWidth ()
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
var text = "Constantinople";
|
||
wrappedLines = TextFormatter.WordWrapText (text, 100);
|
||
Assert.True (wrappedLines.Count == 1);
|
||
Assert.Equal ("Constantinople", wrappedLines [0]);
|
||
}
|
||
|
||
[Fact]
|
||
public void WordWrap_Invalid ()
|
||
{
|
||
var text = string.Empty;
|
||
var width = 0;
|
||
|
||
Assert.Empty (TextFormatter.WordWrapText (null, width));
|
||
Assert.Empty (TextFormatter.WordWrapText (text, width));
|
||
Assert.Throws<ArgumentOutOfRangeException> (() => TextFormatter.WordWrapText (text, -1));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("A sentence has words.", 3, -18, new [] { "A", "sen", "ten", "ce", "has", "wor", "ds." })]
|
||
[InlineData (
|
||
"A sentence has words.",
|
||
2,
|
||
-19,
|
||
new [] { "A", "se", "nt", "en", "ce", "ha", "s", "wo", "rd", "s." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.",
|
||
1,
|
||
-20,
|
||
new [] { "A", "s", "e", "n", "t", "e", "n", "c", "e", "h", "a", "s", "w", "o", "r", "d", "s", "." }
|
||
)]
|
||
public void WordWrap_Narrow_Default (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
// Calls WordWrapText (text, width) and thus preserveTrailingSpaces defaults to false
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("A sentence has words.", 21, 0, new [] { "A sentence has words." })]
|
||
[InlineData ("A sentence has words.", 20, -1, new [] { "A sentence has", "words." })]
|
||
[InlineData ("A sentence has words.", 15, -6, new [] { "A sentence has", "words." })]
|
||
[InlineData ("A sentence has words.", 14, -7, new [] { "A sentence has", "words." })]
|
||
[InlineData ("A sentence has words.", 13, -8, new [] { "A sentence", "has words." })]
|
||
|
||
// Unicode
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.",
|
||
42,
|
||
0,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has words." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.",
|
||
41,
|
||
-1,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has", "words." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.",
|
||
36,
|
||
-6,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has", "words." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.",
|
||
35,
|
||
-7,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has", "words." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.",
|
||
34,
|
||
-8,
|
||
new [] { "A Unicode sentence (пÑивеÑ)", "has words." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.",
|
||
25,
|
||
-17,
|
||
new [] { "A Unicode sentence", "(пÑивеÑ) has words." }
|
||
)]
|
||
public void WordWrap_NoNewLines_Default (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
// Calls WordWrapText (text, width) and thus preserveTrailingSpaces defaults to false
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("これが最初の行です。 こんにちは世界。 これが2行目です。", 29, 0, new [] { "これが最初の行です。", "こんにちは世界。", "これが2行目です。" })]
|
||
public void WordWrap_PreserveTrailingSpaces_False_Unicode_Wide_Runes (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("文に は言葉 があり ます。", 14, 0, new [] { "文に は言葉", "があり ます。" })]
|
||
[InlineData ("文に は言葉 があり ます。", 3, -11, new [] { "文", "に", "は", "言", "葉", "が", "あ", "り", "ま", "す", "。" })]
|
||
[InlineData ("文に は言葉 があり ます。", 2, -12, new [] { "文", "に", "は", "言", "葉", "が", "あ", "り", "ま", "す", "。" })]
|
||
[InlineData (
|
||
"文に は言葉 があり ます。",
|
||
1,
|
||
-13,
|
||
new [] { " ", " ", " " }
|
||
)] // Just Spaces; should result in a single space for each line
|
||
public void WordWrap_PreserveTrailingSpaces_False_Wide_Runes (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (null, 1, new string [] { })] // null input
|
||
[InlineData ("", 1, new string [] { })] // Empty input
|
||
[InlineData ("1 34", 1, new [] { "1", "3", "4" })] // Single Spaces
|
||
[InlineData ("1", 1, new [] { "1" })] // Short input
|
||
[InlineData ("12", 1, new [] { "1", "2" })]
|
||
[InlineData ("123", 1, new [] { "1", "2", "3" })]
|
||
[InlineData ("123456", 1, new [] { "1", "2", "3", "4", "5", "6" })] // No spaces
|
||
[InlineData (" ", 1, new [] { " " })] // Just Spaces; should result in a single space
|
||
[InlineData (" ", 1, new [] { " " })]
|
||
[InlineData (" ", 1, new [] { " ", " " })]
|
||
[InlineData (" ", 1, new [] { " ", " " })]
|
||
[InlineData ("12 456", 1, new [] { "1", "2", "4", "5", "6" })] // Single Spaces
|
||
[InlineData (" 2 456", 1, new [] { " ", "2", "4", "5", "6" })] // Leading spaces should be preserved.
|
||
[InlineData (" 2 456 8", 1, new [] { " ", "2", "4", "5", "6", "8" })]
|
||
[InlineData (
|
||
"A sentence has words. ",
|
||
1,
|
||
new [] { "A", "s", "e", "n", "t", "e", "n", "c", "e", "h", "a", "s", "w", "o", "r", "d", "s", "." }
|
||
)] // Complex example
|
||
[InlineData ("12 567", 1, new [] { "1", "2", " ", "5", "6", "7" })] // Double Spaces
|
||
[InlineData (" 3 567", 1, new [] { " ", "3", "5", "6", "7" })] // Double Leading spaces should be preserved.
|
||
[InlineData (" 3 678 1", 1, new [] { " ", "3", " ", "6", "7", "8", " ", "1" })]
|
||
[InlineData ("1 456", 1, new [] { "1", " ", "4", "5", "6" })]
|
||
[InlineData (
|
||
"A sentence has words. ",
|
||
1,
|
||
new []
|
||
{
|
||
"A", " ", "s", "e", "n", "t", "e", "n", "c", "e", " ", "h", "a", "s", "w", "o", "r", "d", "s", ".", " "
|
||
}
|
||
)] // Double space Complex example
|
||
public void WordWrap_PreserveTrailingSpaces_False_With_Simple_Runes_Width_1 (
|
||
string text,
|
||
int width,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines = TextFormatter.WordWrapText (text, width);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
var breakLines = "";
|
||
|
||
foreach (string line in wrappedLines)
|
||
{
|
||
breakLines += $"{line}{Environment.NewLine}";
|
||
}
|
||
|
||
var expected = string.Empty;
|
||
|
||
foreach (string line in resultLines)
|
||
{
|
||
expected += $"{line}{Environment.NewLine}";
|
||
}
|
||
|
||
Assert.Equal (expected, breakLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (null, 3, new string [] { })] // null input
|
||
[InlineData ("", 3, new string [] { })] // Empty input
|
||
[InlineData ("1", 3, new [] { "1" })] // Short input
|
||
[InlineData ("12", 3, new [] { "12" })]
|
||
[InlineData ("123", 3, new [] { "123" })]
|
||
[InlineData ("123456", 3, new [] { "123", "456" })] // No spaces
|
||
[InlineData ("1234567", 3, new [] { "123", "456", "7" })] // No spaces
|
||
[InlineData (" ", 3, new [] { " " })] // Just Spaces; should result in a single space
|
||
[InlineData (" ", 3, new [] { " " })]
|
||
[InlineData (" ", 3, new [] { " " })]
|
||
[InlineData (" ", 3, new [] { " " })]
|
||
[InlineData ("12 456", 3, new [] { "12", "456" })] // Single Spaces
|
||
[InlineData (" 2 456", 3, new [] { " 2", "456" })] // Leading spaces should be preserved.
|
||
[InlineData (" 2 456 8", 3, new [] { " 2", "456", "8" })]
|
||
[InlineData (
|
||
"A sentence has words. ",
|
||
3,
|
||
new [] { "A", "sen", "ten", "ce", "has", "wor", "ds." }
|
||
)] // Complex example
|
||
[InlineData ("12 567", 3, new [] { "12 ", "567" })] // Double Spaces
|
||
[InlineData (" 3 567", 3, new [] { " 3", "567" })] // Double Leading spaces should be preserved.
|
||
[InlineData (" 3 678 1", 3, new [] { " 3", " 67", "8 ", "1" })]
|
||
[InlineData ("1 456", 3, new [] { "1 ", "456" })]
|
||
[InlineData (
|
||
"A sentence has words. ",
|
||
3,
|
||
new [] { "A ", "sen", "ten", "ce ", " ", "has", "wor", "ds.", " " }
|
||
)] // Double space Complex example
|
||
public void WordWrap_PreserveTrailingSpaces_False_With_Simple_Runes_Width_3 (
|
||
string text,
|
||
int width,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines = TextFormatter.WordWrapText (text, width);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
var breakLines = "";
|
||
|
||
foreach (string line in wrappedLines)
|
||
{
|
||
breakLines += $"{line}{Environment.NewLine}";
|
||
}
|
||
|
||
var expected = string.Empty;
|
||
|
||
foreach (string line in resultLines)
|
||
{
|
||
expected += $"{line}{Environment.NewLine}";
|
||
}
|
||
|
||
Assert.Equal (expected, breakLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (null, 50, new string [] { })] // null input
|
||
[InlineData ("", 50, new string [] { })] // Empty input
|
||
[InlineData ("1", 50, new [] { "1" })] // Short input
|
||
[InlineData ("12", 50, new [] { "12" })]
|
||
[InlineData ("123", 50, new [] { "123" })]
|
||
[InlineData ("123456", 50, new [] { "123456" })] // No spaces
|
||
[InlineData ("1234567", 50, new [] { "1234567" })] // No spaces
|
||
[InlineData (" ", 50, new [] { " " })] // Just Spaces; should result in a single space
|
||
[InlineData (" ", 50, new [] { " " })]
|
||
[InlineData (" ", 50, new [] { " " })]
|
||
[InlineData ("12 456", 50, new [] { "12 456" })] // Single Spaces
|
||
[InlineData (" 2 456", 50, new [] { " 2 456" })] // Leading spaces should be preserved.
|
||
[InlineData (" 2 456 8", 50, new [] { " 2 456 8" })]
|
||
[InlineData ("A sentence has words. ", 50, new [] { "A sentence has words. " })] // Complex example
|
||
[InlineData ("12 567", 50, new [] { "12 567" })] // Double Spaces
|
||
[InlineData (" 3 567", 50, new [] { " 3 567" })] // Double Leading spaces should be preserved.
|
||
[InlineData (" 3 678 1", 50, new [] { " 3 678 1" })]
|
||
[InlineData ("1 456", 50, new [] { "1 456" })]
|
||
[InlineData (
|
||
"A sentence has words. ",
|
||
50,
|
||
new [] { "A sentence has words. " }
|
||
)] // Double space Complex example
|
||
public void WordWrap_PreserveTrailingSpaces_False_With_Simple_Runes_Width_50 (
|
||
string text,
|
||
int width,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines = TextFormatter.WordWrapText (text, width);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
var breakLines = "";
|
||
|
||
foreach (string line in wrappedLines)
|
||
{
|
||
breakLines += $"{line}{Environment.NewLine}";
|
||
}
|
||
|
||
var expected = string.Empty;
|
||
|
||
foreach (string line in resultLines)
|
||
{
|
||
expected += $"{line}{Environment.NewLine}";
|
||
}
|
||
|
||
Assert.Equal (expected, breakLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("A sentence has words.", 14, -7, new [] { "A sentence ", "has words." })]
|
||
[InlineData ("A sentence has words.", 8, -13, new [] { "A ", "sentence", " has ", "words." })]
|
||
[InlineData ("A sentence has words.", 6, -15, new [] { "A ", "senten", "ce ", "has ", "words." })]
|
||
[InlineData ("A sentence has words.", 3, -18, new [] { "A ", "sen", "ten", "ce ", "has", " ", "wor", "ds." })]
|
||
[InlineData (
|
||
"A sentence has words.",
|
||
2,
|
||
-19,
|
||
new [] { "A ", "se", "nt", "en", "ce", " ", "ha", "s ", "wo", "rd", "s." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.",
|
||
1,
|
||
-20,
|
||
new []
|
||
{
|
||
"A", " ", "s", "e", "n", "t", "e", "n", "c", "e", " ", "h", "a", "s", " ", "w", "o", "r", "d", "s", "."
|
||
}
|
||
)]
|
||
public void WordWrap_PreserveTrailingSpaces_True (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth, true);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("文に は言葉 があり ます。", 14, 0, new [] { "文に は言葉 ", "があり ます。" })]
|
||
[InlineData ("文に は言葉 があり ます。", 3, -11, new [] { "文", "に ", "は", "言", "葉 ", "が", "あ", "り ", "ま", "す", "。" })]
|
||
[InlineData (
|
||
"文に は言葉 があり ます。",
|
||
2,
|
||
-12,
|
||
new [] { "文", "に", " ", "は", "言", "葉", " ", "が", "あ", "り", " ", "ま", "す", "。" }
|
||
)]
|
||
[InlineData ("文に は言葉 があり ます。", 1, -13, new string [] { })]
|
||
public void WordWrap_PreserveTrailingSpaces_True_Wide_Runes (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth, true);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("A sentence has words. ", 3, new [] { "A ", "sen", "ten", "ce ", "has", " ", "wor", "ds.", " " })]
|
||
[InlineData (
|
||
"A sentence has words. ",
|
||
3,
|
||
new [] { "A ", " ", "sen", "ten", "ce ", " ", " ", " ", "has", " ", "wor", "ds.", " " }
|
||
)]
|
||
public void WordWrap_PreserveTrailingSpaces_True_With_Simple_Runes_Width_3 (
|
||
string text,
|
||
int width,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines = TextFormatter.WordWrapText (text, width, true);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
var breakLines = "";
|
||
|
||
foreach (string line in wrappedLines)
|
||
{
|
||
breakLines += $"{line}{Environment.NewLine}";
|
||
}
|
||
|
||
var expected = string.Empty;
|
||
|
||
foreach (string line in resultLines)
|
||
{
|
||
expected += $"{line}{Environment.NewLine}";
|
||
}
|
||
|
||
Assert.Equal (expected, breakLines);
|
||
|
||
// Double space Complex example - this is how VS 2022 does it
|
||
//text = "A sentence has words. ";
|
||
//breakLines = "";
|
||
//wrappedLines = TextFormatter.WordWrapText (text, width, preserveTrailingSpaces: true);
|
||
//foreach (var line in wrappedLines) {
|
||
// breakLines += $"{line}{Environment.NewLine}";
|
||
//}
|
||
//expected = "A " + Environment.NewLine +
|
||
// " se" + Environment.NewLine +
|
||
// " nt" + Environment.NewLine +
|
||
// " en" + Environment.NewLine +
|
||
// " ce" + Environment.NewLine +
|
||
// " " + Environment.NewLine +
|
||
// " " + Environment.NewLine +
|
||
// " " + Environment.NewLine +
|
||
// " ha" + Environment.NewLine +
|
||
// " s " + Environment.NewLine +
|
||
// " wo" + Environment.NewLine +
|
||
// " rd" + Environment.NewLine +
|
||
// " s." + Environment.NewLine;
|
||
//Assert.Equal (expected, breakLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("A sentence\t\t\t has words.", 14, -10, new [] { "A sentence\t", "\t\t has ", "words." })]
|
||
[InlineData (
|
||
"A sentence\t\t\t has words.",
|
||
8,
|
||
-16,
|
||
new [] { "A ", "sentence", "\t\t", "\t ", "has ", "words." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence\t\t\t has words.",
|
||
3,
|
||
-21,
|
||
new [] { "A ", "sen", "ten", "ce", "\t", "\t", "\t", " ", "has", " ", "wor", "ds." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence\t\t\t has words.",
|
||
2,
|
||
-22,
|
||
new [] { "A ", "se", "nt", "en", "ce", "\t", "\t", "\t", " ", "ha", "s ", "wo", "rd", "s." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence\t\t\t has words.",
|
||
1,
|
||
-23,
|
||
new []
|
||
{
|
||
"A",
|
||
" ",
|
||
"s",
|
||
"e",
|
||
"n",
|
||
"t",
|
||
"e",
|
||
"n",
|
||
"c",
|
||
"e",
|
||
"\t",
|
||
"\t",
|
||
"\t",
|
||
" ",
|
||
"h",
|
||
"a",
|
||
"s",
|
||
" ",
|
||
"w",
|
||
"o",
|
||
"r",
|
||
"d",
|
||
"s",
|
||
"."
|
||
}
|
||
)]
|
||
public void WordWrap_PreserveTrailingSpaces_True_With_Tab (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines,
|
||
int tabWidth = 4
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth, true, tabWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("Constantinople", 14, 0, new [] { "Constantinople" })]
|
||
[InlineData ("Constantinople", 12, -2, new [] { "Constantinop", "le" })]
|
||
[InlineData ("Constantinople", 9, -5, new [] { "Constanti", "nople" })]
|
||
[InlineData ("Constantinople", 7, -7, new [] { "Constan", "tinople" })]
|
||
[InlineData ("Constantinople", 5, -9, new [] { "Const", "antin", "ople" })]
|
||
[InlineData ("Constantinople", 4, -10, new [] { "Cons", "tant", "inop", "le" })]
|
||
[InlineData (
|
||
"Constantinople",
|
||
1,
|
||
-13,
|
||
new [] { "C", "o", "n", "s", "t", "a", "n", "t", "i", "n", "o", "p", "l", "e" }
|
||
)]
|
||
public void WordWrap_SingleWordLine (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("This\u00A0is\n\u00A0a\u00A0sentence.", 20, 0, new [] { "This\u00A0is\u00A0a\u00A0sentence." })]
|
||
[InlineData ("This\u00A0is\n\u00A0a\u00A0sentence.", 19, -1, new [] { "This\u00A0is\u00A0a\u00A0sentence." })]
|
||
[InlineData (
|
||
"\u00A0\u00A0\u00A0\u00A0\u00A0test\u00A0sentence.",
|
||
19,
|
||
0,
|
||
new [] { "\u00A0\u00A0\u00A0\u00A0\u00A0test\u00A0sentence." }
|
||
)]
|
||
public void WordWrap_Unicode_2LinesWithNonBreakingSpace (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("This\u00A0is\u00A0a\u00A0sentence.", 19, 0, new [] { "This\u00A0is\u00A0a\u00A0sentence." })]
|
||
[InlineData ("This\u00A0is\u00A0a\u00A0sentence.", 18, -1, new [] { "This\u00A0is\u00A0a\u00A0sentence", "." })]
|
||
[InlineData ("This\u00A0is\u00A0a\u00A0sentence.", 17, -2, new [] { "This\u00A0is\u00A0a\u00A0sentenc", "e." })]
|
||
[InlineData ("This\u00A0is\u00A0a\u00A0sentence.", 14, -5, new [] { "This\u00A0is\u00A0a\u00A0sent", "ence." })]
|
||
[InlineData ("This\u00A0is\u00A0a\u00A0sentence.", 10, -9, new [] { "This\u00A0is\u00A0a\u00A0", "sentence." })]
|
||
[InlineData (
|
||
"This\u00A0is\u00A0a\u00A0sentence.",
|
||
7,
|
||
-12,
|
||
new [] { "This\u00A0is", "\u00A0a\u00A0sent", "ence." }
|
||
)]
|
||
[InlineData (
|
||
"This\u00A0is\u00A0a\u00A0sentence.",
|
||
5,
|
||
-14,
|
||
new [] { "This\u00A0", "is\u00A0a\u00A0", "sente", "nce." }
|
||
)]
|
||
[InlineData (
|
||
"This\u00A0is\u00A0a\u00A0sentence.",
|
||
1,
|
||
-18,
|
||
new []
|
||
{
|
||
"T", "h", "i", "s", "\u00A0", "i", "s", "\u00A0", "a", "\u00A0", "s", "e", "n", "t", "e", "n", "c", "e", "."
|
||
}
|
||
)]
|
||
public void WordWrap_Unicode_LineWithNonBreakingSpace (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData (
|
||
"กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ",
|
||
51,
|
||
0,
|
||
new [] { "กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ" }
|
||
)]
|
||
[InlineData (
|
||
"กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ",
|
||
50,
|
||
-1,
|
||
new [] { "กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ" }
|
||
)]
|
||
[InlineData (
|
||
"กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ",
|
||
46,
|
||
-5,
|
||
new [] { "กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮ", "ฯะัาำ" }
|
||
)]
|
||
[InlineData (
|
||
"กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ",
|
||
26,
|
||
-25,
|
||
new [] { "กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบ", "ปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ" }
|
||
)]
|
||
[InlineData (
|
||
"กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ",
|
||
17,
|
||
-34,
|
||
new [] { "กขฃคฅฆงจฉชซฌญฎฏฐฑ", "ฒณดตถทธนบปผฝพฟภมย", "รฤลฦวศษสหฬอฮฯะัาำ" }
|
||
)]
|
||
[InlineData (
|
||
"กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ",
|
||
13,
|
||
-38,
|
||
new [] { "กขฃคฅฆงจฉชซฌญ", "ฎฏฐฑฒณดตถทธนบ", "ปผฝพฟภมยรฤลฦว", "ศษสหฬอฮฯะัาำ" }
|
||
)]
|
||
[InlineData (
|
||
"กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรฤลฦวศษสหฬอฮฯะัาำ",
|
||
1,
|
||
-50,
|
||
new []
|
||
{
|
||
"ก",
|
||
"ข",
|
||
"ฃ",
|
||
"ค",
|
||
"ฅ",
|
||
"ฆ",
|
||
"ง",
|
||
"จ",
|
||
"ฉ",
|
||
"ช",
|
||
"ซ",
|
||
"ฌ",
|
||
"ญ",
|
||
"ฎ",
|
||
"ฏ",
|
||
"ฐ",
|
||
"ฑ",
|
||
"ฒ",
|
||
"ณ",
|
||
"ด",
|
||
"ต",
|
||
"ถ",
|
||
"ท",
|
||
"ธ",
|
||
"น",
|
||
"บ",
|
||
"ป",
|
||
"ผ",
|
||
"ฝ",
|
||
"พ",
|
||
"ฟ",
|
||
"ภ",
|
||
"ม",
|
||
"ย",
|
||
"ร",
|
||
"ฤ",
|
||
"ล",
|
||
"ฦ",
|
||
"ว",
|
||
"ศ",
|
||
"ษ",
|
||
"ส",
|
||
"ห",
|
||
"ฬ",
|
||
"อ",
|
||
"ฮ",
|
||
"ฯ",
|
||
"ะั",
|
||
"า",
|
||
"ำ"
|
||
}
|
||
)]
|
||
public void WordWrap_Unicode_SingleWordLine (
|
||
string text,
|
||
int maxWidth,
|
||
int widthOffset,
|
||
IEnumerable<string> resultLines
|
||
)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
IEnumerable<Rune> zeroWidth = text.EnumerateRunes ().Where (r => r.GetColumns () == 0);
|
||
Assert.Single (zeroWidth);
|
||
Assert.Equal ('ั', zeroWidth.ElementAt (0).Value);
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth
|
||
>= (wrappedLines.Count > 0
|
||
? wrappedLines.Max (
|
||
l => l.GetRuneCount ()
|
||
+ zeroWidth.Count ()
|
||
- 1
|
||
+ widthOffset
|
||
)
|
||
: 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
|
||
/// <summary>WordWrap strips CRLF</summary>
|
||
[Theory]
|
||
[InlineData (
|
||
"A sentence has words.\nA paragraph has lines.",
|
||
44,
|
||
0,
|
||
new [] { "A sentence has words.A paragraph has lines." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nA paragraph has lines.",
|
||
43,
|
||
-1,
|
||
new [] { "A sentence has words.A paragraph has lines." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nA paragraph has lines.",
|
||
38,
|
||
-6,
|
||
new [] { "A sentence has words.A paragraph has", "lines." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nA paragraph has lines.",
|
||
34,
|
||
-10,
|
||
new [] { "A sentence has words.A paragraph", "has lines." }
|
||
)]
|
||
[InlineData (
|
||
"A sentence has words.\nA paragraph has lines.",
|
||
27,
|
||
-17,
|
||
new [] { "A sentence has words.A", "paragraph has lines." }
|
||
)]
|
||
|
||
// Unicode
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.\nA Unicode Пункт has Линии.",
|
||
69,
|
||
0,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has words.A Unicode Пункт has Линии." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.\nA Unicode Пункт has Линии.",
|
||
68,
|
||
-1,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has words.A Unicode Пункт has Линии." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.\nA Unicode Пункт has Линии.",
|
||
63,
|
||
-6,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has words.A Unicode Пункт has", "Линии." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.\nA Unicode Пункт has Линии.",
|
||
59,
|
||
-10,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has words.A Unicode Пункт", "has Линии." }
|
||
)]
|
||
[InlineData (
|
||
"A Unicode sentence (пÑивеÑ) has words.\nA Unicode Пункт has Линии.",
|
||
52,
|
||
-17,
|
||
new [] { "A Unicode sentence (пÑивеÑ) has words.A Unicode", "Пункт has Линии." }
|
||
)]
|
||
public void WordWrap_WithNewLines (string text, int maxWidth, int widthOffset, IEnumerable<string> resultLines)
|
||
{
|
||
List<string> wrappedLines;
|
||
|
||
Assert.Equal (maxWidth, text.GetRuneCount () + widthOffset);
|
||
int expectedClippedWidth = Math.Min (text.GetRuneCount (), maxWidth);
|
||
wrappedLines = TextFormatter.WordWrapText (text, maxWidth);
|
||
Assert.Equal (wrappedLines.Count, resultLines.Count ());
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetRuneCount ()) : 0)
|
||
);
|
||
|
||
Assert.True (
|
||
expectedClippedWidth >= (wrappedLines.Count > 0 ? wrappedLines.Max (l => l.GetColumns ()) : 0)
|
||
);
|
||
Assert.Equal (resultLines, wrappedLines);
|
||
}
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 0, false, "")]
|
||
[InlineData ("A", 1, false, "A")]
|
||
[InlineData ("A", 2, false, "A")]
|
||
[InlineData ("AB", 1, false, "A")]
|
||
[InlineData ("AB", 2, false, "AB")]
|
||
[InlineData ("ABC", 3, false, "ABC")]
|
||
[InlineData ("ABC", 4, false, "ABC")]
|
||
[InlineData ("ABC", 6, false, "ABC")]
|
||
|
||
[InlineData ("A", 0, true, "")]
|
||
[InlineData ("A", 1, true, "A")]
|
||
[InlineData ("A", 2, true, "A")]
|
||
[InlineData ("AB", 1, true, "A")]
|
||
[InlineData ("AB", 2, true, "AB")]
|
||
[InlineData ("ABC", 3, true, "ABC")]
|
||
[InlineData ("ABC", 4, true, "ABC")]
|
||
[InlineData ("ABC", 6, true, "ABC")]
|
||
public void Draw_Horizontal_Left (string text, int width, bool autoSize, string expectedText)
|
||
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Alignment = TextAlignment.Left,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, 1);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, width, 1), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 0, false, "")]
|
||
[InlineData ("A", 1, false, "A")]
|
||
[InlineData ("A", 2, false, " A")]
|
||
[InlineData ("AB", 1, false, "B")]
|
||
[InlineData ("AB", 2, false, "AB")]
|
||
[InlineData ("ABC", 3, false, "ABC")]
|
||
[InlineData ("ABC", 4, false, " ABC")]
|
||
[InlineData ("ABC", 6, false, " ABC")]
|
||
|
||
[InlineData ("A", 0, true, "")]
|
||
[InlineData ("A", 1, true, "A")]
|
||
[InlineData ("A", 2, true, " A")]
|
||
[InlineData ("AB", 1, true, "B")]
|
||
[InlineData ("AB", 2, true, "AB")]
|
||
[InlineData ("ABC", 3, true, "ABC")]
|
||
[InlineData ("ABC", 4, true, " ABC")]
|
||
[InlineData ("ABC", 6, true, " ABC")]
|
||
public void Draw_Horizontal_Right (string text, int width, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Alignment = TextAlignment.Right,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, 1);
|
||
}
|
||
|
||
tf.Draw (new Rectangle (Point.Empty, new (width, 1)), Attribute.Default, Attribute.Default);
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 0, false, "")]
|
||
[InlineData ("A", 1, false, "A")]
|
||
[InlineData ("A", 2, false, "A")]
|
||
[InlineData ("A", 3, false, " A")]
|
||
[InlineData ("AB", 1, false, "A")]
|
||
[InlineData ("AB", 2, false, "AB")]
|
||
[InlineData ("ABC", 3, false, "ABC")]
|
||
[InlineData ("ABC", 4, false, "ABC")]
|
||
[InlineData ("ABC", 5, false, " ABC")]
|
||
[InlineData ("ABC", 6, false, " ABC")]
|
||
[InlineData ("ABC", 9, false, " ABC")]
|
||
|
||
[InlineData ("A", 0, true, "")]
|
||
[InlineData ("A", 1, true, "A")]
|
||
[InlineData ("A", 2, true, "A")]
|
||
[InlineData ("A", 3, true, " A")]
|
||
[InlineData ("AB", 1, true, "A")]
|
||
[InlineData ("AB", 2, true, "AB")]
|
||
[InlineData ("ABC", 3, true, "ABC")]
|
||
[InlineData ("ABC", 4, true, "ABC")]
|
||
[InlineData ("ABC", 5, true, " ABC")]
|
||
[InlineData ("ABC", 6, true, " ABC")]
|
||
[InlineData ("ABC", 9, true, " ABC")]
|
||
public void Draw_Horizontal_Centered (string text, int width, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Alignment = TextAlignment.Centered,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, 1);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, width, 1), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 0, false, "")]
|
||
[InlineData ("A", 1, false, "A")]
|
||
[InlineData ("A", 2, false, "A")]
|
||
[InlineData ("A B", 3, false, "A B")]
|
||
[InlineData ("A B", 1, false, "A")]
|
||
[InlineData ("A B", 2, false, "A")]
|
||
[InlineData ("A B", 3, false, "A B")]
|
||
[InlineData ("A B", 4, false, "A B")]
|
||
[InlineData ("A B", 5, false, "A B")]
|
||
[InlineData ("A B", 6, false, "A B")]
|
||
[InlineData ("A B", 10, false, "A B")]
|
||
[InlineData ("ABC ABC", 10, false, "ABC ABC")]
|
||
|
||
[InlineData ("A", 0, true, "")]
|
||
[InlineData ("A", 1, true, "A")]
|
||
[InlineData ("A", 2, true, "A")]
|
||
[InlineData ("A B", 3, true, "A B")]
|
||
[InlineData ("A B", 1, true, "A")]
|
||
[InlineData ("A B", 2, true, "A")]
|
||
[InlineData ("A B", 3, true, "A B")]
|
||
[InlineData ("A B", 4, true, "A B")]
|
||
[InlineData ("A B", 5, true, "A B")]
|
||
[InlineData ("A B", 6, true, "A B")]
|
||
[InlineData ("A B", 10, true, "A B")]
|
||
[InlineData ("ABC ABC", 10, true, "ABC ABC")]
|
||
public void Draw_Horizontal_Justified (string text, int width, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Alignment = TextAlignment.Justified,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, 1);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, width, 1), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 5, 5, false, "A")]
|
||
[InlineData ("AB12", 5, 5, false, @"
|
||
A
|
||
B
|
||
1
|
||
2")]
|
||
[InlineData ("AB\n12", 5, 5, false, @"
|
||
A1
|
||
B2")]
|
||
[InlineData ("", 5, 1, false, "")]
|
||
|
||
[InlineData ("Hello Worlds", 1, 12, true, @"
|
||
H
|
||
e
|
||
l
|
||
l
|
||
o
|
||
|
||
W
|
||
o
|
||
r
|
||
l
|
||
d
|
||
s")]
|
||
|
||
[InlineData ("Hello Worlds", 1, 12, false, @"
|
||
H
|
||
e
|
||
l
|
||
l
|
||
o
|
||
|
||
W
|
||
o
|
||
r
|
||
l
|
||
d
|
||
s")]
|
||
|
||
[InlineData ("Hello Worlds", 12, 1, false, @"HelloWorlds")]
|
||
|
||
public void Draw_Vertical_TopBottom_LeftRight (string text, int width, int height, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
AutoSize = autoSize,
|
||
Direction = TextDirection.TopBottom_LeftRight,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, height);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, 20, 20), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("Hello World", 15, 1, "Hello World")]
|
||
[InlineData ("Well Done\nNice Work", 15, 2, @"
|
||
Well Done
|
||
Nice Work")]
|
||
[InlineData ("你好 世界", 15, 1, "你好 世界")]
|
||
[InlineData ("做 得好\n幹 得好", 15, 2, @"
|
||
做 得好
|
||
幹 得好")]
|
||
public void Justify_Horizontal (string text, int width, int height, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Alignment = TextAlignment.Justified,
|
||
Size = new Size (width, height),
|
||
MultiLine = true
|
||
};
|
||
|
||
tf.Draw (new Rectangle (0, 0, width, height), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("Hello World", 1, 15, "H\ne\nl\nl\no\n \n \n \n \n \nW\no\nr\nl\nd")]
|
||
[InlineData ("Well Done\nNice Work", 2, 15, @"
|
||
WN
|
||
ei
|
||
lc
|
||
le
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
DW
|
||
oo
|
||
nr
|
||
ek")]
|
||
[InlineData ("你好 世界", 2, 15, "你\n好\n \n \n \n \n \n \n \n \n \n \n \n世\n界")]
|
||
[InlineData ("做 得好\n幹 得好", 4, 15, @"
|
||
做幹
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
得得
|
||
好好")]
|
||
public void Justify_Vertical (string text, int width, int height, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Direction = TextDirection.TopBottom_LeftRight,
|
||
VerticalAlignment = VerticalTextAlignment.Justified,
|
||
Size = new Size (width, height),
|
||
MultiLine = true
|
||
};
|
||
|
||
tf.Draw (new Rectangle (0, 0, width, height), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 0, 1, false, "", 0)]
|
||
[InlineData ("A", 1, 1, false, "A", 0)]
|
||
[InlineData ("A", 2, 2, false, " A", 1)]
|
||
[InlineData ("AB", 1, 1, false, "B", 0)]
|
||
[InlineData ("AB", 2, 2, false, " A\n B", 0)]
|
||
[InlineData ("ABC", 3, 2, false, " B\n C", 0)]
|
||
[InlineData ("ABC", 4, 2, false, " B\n C", 0)]
|
||
[InlineData ("ABC", 6, 2, false, " B\n C", 0)]
|
||
[InlineData ("こんにちは", 0, 1, false, "", 0)]
|
||
[InlineData ("こんにちは", 1, 0, false, "", 0)]
|
||
[InlineData ("こんにちは", 1, 1, false, "", 0)]
|
||
[InlineData ("こんにちは", 2, 1, false, "は", 0)]
|
||
[InlineData ("こんにちは", 2, 2, false, "ち\nは", 0)]
|
||
[InlineData ("こんにちは", 2, 3, false, "に\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 2, 4, false, "ん\nに\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 2, 5, false, "こ\nん\nに\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 2, 6, false, "こ\nん\nに\nち\nは", 1)]
|
||
[InlineData ("ABCD\nこんにちは", 4, 7, false, " こ\n Aん\n Bに\n Cち\n Dは", 2)]
|
||
[InlineData ("こんにちは\nABCD", 3, 7, false, "こ \nんA\nにB\nちC\nはD", 2)]
|
||
|
||
[InlineData ("A", 0, 1, true, "", 0)]
|
||
[InlineData ("A", 1, 1, true, "A", 0)]
|
||
[InlineData ("A", 2, 2, true, " A", 1)]
|
||
[InlineData ("AB", 1, 1, true, "B", 0)]
|
||
[InlineData ("AB", 2, 2, true, " A\n B", 0)]
|
||
[InlineData ("ABC", 3, 2, true, " B\n C", 0)]
|
||
[InlineData ("ABC", 4, 2, true, " B\n C", 0)]
|
||
[InlineData ("ABC", 6, 2, true, " B\n C", 0)]
|
||
[InlineData ("こんにちは", 0, 1, true, "", 0)]
|
||
[InlineData ("こんにちは", 1, 0, true, "", 0)]
|
||
[InlineData ("こんにちは", 1, 1, true, "", 0)]
|
||
[InlineData ("こんにちは", 2, 1, true, "は", 0)]
|
||
[InlineData ("こんにちは", 2, 2, true, "ち\nは", 0)]
|
||
[InlineData ("こんにちは", 2, 3, true, "に\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 2, 4, true, "ん\nに\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 2, 5, true, "こ\nん\nに\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 2, 6, true, "こ\nん\nに\nち\nは", 1)]
|
||
[InlineData ("ABCD\nこんにちは", 4, 7, true, " こ\n Aん\n Bに\n Cち\n Dは", 2)]
|
||
[InlineData ("こんにちは\nABCD", 3, 7, true, "こ \nんA\nにB\nちC\nはD", 2)]
|
||
public void Draw_Vertical_Bottom_Horizontal_Right (string text, int width, int height, bool autoSize, string expectedText, int expectedY)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Alignment = TextAlignment.Right,
|
||
Direction = TextDirection.TopBottom_LeftRight,
|
||
VerticalAlignment = VerticalTextAlignment.Bottom,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, height);
|
||
}
|
||
|
||
tf.Draw (new Rectangle (Point.Empty, new (width, height)), Attribute.Default, Attribute.Default);
|
||
Rectangle rect = TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
Assert.Equal (expectedY, rect.Y);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 5, false, "A")]
|
||
[InlineData ("AB12", 5, false, @"
|
||
A
|
||
B
|
||
1
|
||
2")]
|
||
[InlineData ("AB\n12", 5, false, @"
|
||
A1
|
||
B2")]
|
||
[InlineData ("", 1, false, "")]
|
||
[InlineData ("AB1 2", 2, false, @"
|
||
A12
|
||
B ")]
|
||
[InlineData ("こんにちは", 1, false, @"
|
||
こん")]
|
||
[InlineData ("こんにちは", 2, false, @"
|
||
こに
|
||
んち")]
|
||
[InlineData ("こんにちは", 5, false, @"
|
||
こ
|
||
ん
|
||
に
|
||
ち
|
||
は")]
|
||
|
||
[InlineData ("A", 5, true, "A")]
|
||
[InlineData ("AB12", 5, true, @"
|
||
A
|
||
B
|
||
1
|
||
2")]
|
||
[InlineData ("AB\n12", 5, true, @"
|
||
A1
|
||
B2")]
|
||
[InlineData ("", 1, true, "")]
|
||
[InlineData ("AB1 2", 2, true, @"
|
||
A
|
||
B")]
|
||
[InlineData ("こんにちは", 1, true, @"
|
||
こ")]
|
||
[InlineData ("こんにちは", 2, true, @"
|
||
こ
|
||
ん")]
|
||
[InlineData ("こんにちは", 5, true, @"
|
||
こ
|
||
ん
|
||
に
|
||
ち
|
||
は")]
|
||
public void Draw_Vertical_TopBottom_LeftRight_Top (string text, int height, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
AutoSize = autoSize,
|
||
Direction = TextDirection.TopBottom_LeftRight,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (5, height);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, 5, height), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
|
||
// The expectedY param is to probe that the expectedText param start at that Y coordinate
|
||
|
||
[InlineData ("A", 0, false, "", 0)]
|
||
[InlineData ("A", 1, false, "A", 0)]
|
||
[InlineData ("A", 2, false, "A", 0)]
|
||
[InlineData ("A", 3, false, "A", 1)]
|
||
[InlineData ("AB", 1, false, "A", 0)]
|
||
[InlineData ("AB", 2, false, "A\nB", 0)]
|
||
[InlineData ("ABC", 2, false, "A\nB", 0)]
|
||
[InlineData ("ABC", 3, false, "A\nB\nC", 0)]
|
||
[InlineData ("ABC", 4, false, "A\nB\nC", 0)]
|
||
[InlineData ("ABC", 5, false, "A\nB\nC", 1)]
|
||
[InlineData ("ABC", 6, false, "A\nB\nC", 1)]
|
||
[InlineData ("ABC", 9, false, "A\nB\nC", 3)]
|
||
[InlineData ("ABCD", 2, false, "B\nC", 0)]
|
||
[InlineData ("こんにちは", 0, false, "", 0)]
|
||
[InlineData ("こんにちは", 1, false, "に", 0)]
|
||
[InlineData ("こんにちは", 2, false, "ん\nに", 0)]
|
||
[InlineData ("こんにちは", 3, false, "ん\nに\nち", 0)]
|
||
[InlineData ("こんにちは", 4, false, "こ\nん\nに\nち", 0)]
|
||
[InlineData ("こんにちは", 5, false, "こ\nん\nに\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 6, false, "こ\nん\nに\nち\nは", 0)]
|
||
[InlineData ("ABCD\nこんにちは", 7, false, "Aこ\nBん\nCに\nDち\n は", 1)]
|
||
[InlineData ("こんにちは\nABCD", 7, false, "こA\nんB\nにC\nちD\nは ", 1)]
|
||
|
||
[InlineData ("A", 0, true, "", 0)]
|
||
[InlineData ("A", 1, true, "A", 0)]
|
||
[InlineData ("A", 2, true, "A", 0)]
|
||
[InlineData ("A", 3, true, "A", 1)]
|
||
[InlineData ("AB", 1, true, "A", 0)]
|
||
[InlineData ("AB", 2, true, "A\nB", 0)]
|
||
[InlineData ("ABC", 2, true, "A\nB", 0)]
|
||
[InlineData ("ABC", 3, true, "A\nB\nC", 0)]
|
||
[InlineData ("ABC", 4, true, "A\nB\nC", 0)]
|
||
[InlineData ("ABC", 5, true, "A\nB\nC", 1)]
|
||
[InlineData ("ABC", 6, true, "A\nB\nC", 1)]
|
||
[InlineData ("ABC", 9, true, "A\nB\nC", 3)]
|
||
[InlineData ("ABCD", 2, true, "B\nC", 0)]
|
||
[InlineData ("こんにちは", 0, true, "", 0)]
|
||
[InlineData ("こんにちは", 1, true, "に", 0)]
|
||
[InlineData ("こんにちは", 2, true, "ん\nに", 0)]
|
||
[InlineData ("こんにちは", 3, true, "ん\nに\nち", 0)]
|
||
[InlineData ("こんにちは", 4, true, "こ\nん\nに\nち", 0)]
|
||
[InlineData ("こんにちは", 5, true, "こ\nん\nに\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 6, true, "こ\nん\nに\nち\nは", 0)]
|
||
[InlineData ("こんにちは", 7, true, "こ\nん\nに\nち\nは", 1)]
|
||
[InlineData ("ABCD\nこんにちは", 7, true, "Aこ\nBん\nCに\nDち\n は", 1)]
|
||
[InlineData ("こんにちは\nABCD", 7, true, "こA\nんB\nにC\nちD\nは ", 1)]
|
||
public void Draw_Vertical_TopBottom_LeftRight_Middle (string text, int height, bool autoSize, string expectedText, int expectedY)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Direction = TextDirection.TopBottom_LeftRight,
|
||
VerticalAlignment = VerticalTextAlignment.Middle,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
int width = text.ToRunes ().Max (r => r.GetColumns ());
|
||
|
||
if (text.Contains ("\n"))
|
||
{
|
||
width++;
|
||
}
|
||
|
||
tf.Size = new Size (width, height);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, 5, height), Attribute.Default, Attribute.Default);
|
||
|
||
Rectangle rect = TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
Assert.Equal (expectedY, rect.Y);
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData ("1234", 4)]
|
||
[InlineData ("_1234", 4)]
|
||
public void AutoSize_HotKey_Size_Correct (string text, int expected)
|
||
{
|
||
// Horizontal
|
||
TextFormatter tf = new ()
|
||
{
|
||
AutoSize = true,
|
||
HotKeySpecifier = (Rune)'_',
|
||
Text = text,
|
||
};
|
||
Assert.Equal (new (expected, 1), tf.Size);
|
||
|
||
// Vertical
|
||
tf = new ()
|
||
{
|
||
HotKeySpecifier = (Rune)'_',
|
||
Direction = TextDirection.TopBottom_LeftRight,
|
||
Text = text,
|
||
AutoSize = true,
|
||
};
|
||
Assert.Equal (new (1, expected), tf.Size);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 1, 0, false, "")]
|
||
[InlineData ("A", 0, 1, false, "")]
|
||
[InlineData ("AB1 2", 2, 1, false, "2")]
|
||
[InlineData ("AB12", 5, 1, false, "21BA")]
|
||
[InlineData ("AB\n12", 5, 2, false, "BA\n21")]
|
||
[InlineData ("ABC 123 456", 7, 2, false, "654 321\nCBA ")]
|
||
[InlineData ("こんにちは", 1, 1, false, "")]
|
||
[InlineData ("こんにちは", 2, 1, false, "は")]
|
||
[InlineData ("こんにちは", 5, 1, false, "はち")]
|
||
[InlineData ("こんにちは", 10, 1, false, "はちにんこ")]
|
||
[InlineData ("こんにちは\nAB\n12", 10, 3, false, "はちにんこ\nBA \n21 ")]
|
||
|
||
[InlineData ("A", 1, 0, true, "")]
|
||
[InlineData ("A", 0, 1, true, "")]
|
||
[InlineData ("AB1 2", 2, 1, true, "2")]
|
||
[InlineData ("AB12", 5, 1, true, "21BA")]
|
||
[InlineData ("AB\n12", 5, 2, true, "BA\n21")]
|
||
[InlineData ("ABC 123 456", 7, 2, true, "654 321")]
|
||
[InlineData ("こんにちは", 1, 1, true, "")]
|
||
[InlineData ("こんにちは", 2, 1, true, "は")]
|
||
[InlineData ("こんにちは", 5, 1, true, "はち")]
|
||
[InlineData ("こんにちは", 10, 1, true, "はちにんこ")]
|
||
[InlineData ("こんにちは\nAB\n12", 10, 3, true, "はちにんこ\nBA \n21 ")]
|
||
public void Draw_Horizontal_RightLeft_TopBottom (string text, int width, int height, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Direction = TextDirection.RightLeft_TopBottom,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, height);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, width, height), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 1, 0, false, "")]
|
||
[InlineData ("A", 0, 1, false, "")]
|
||
[InlineData ("AB1 2", 2, 1, false, "2")]
|
||
[InlineData ("AB12", 5, 1, false, "21BA")]
|
||
[InlineData ("AB\n12", 5, 2, false, "21\nBA")]
|
||
[InlineData ("ABC 123 456", 7, 2, false, "CBA \n654 321")]
|
||
[InlineData ("こんにちは", 1, 1, false, "")]
|
||
[InlineData ("こんにちは", 2, 1, false, "は")]
|
||
[InlineData ("こんにちは", 5, 1, false, "はち")]
|
||
[InlineData ("こんにちは", 10, 1, false, "はちにんこ")]
|
||
[InlineData ("こんにちは\nAB\n12", 10, 3, false, "21 \nBA \nはちにんこ")]
|
||
|
||
[InlineData ("A", 1, 0, true, "")]
|
||
[InlineData ("A", 0, 1, true, "")]
|
||
[InlineData ("AB1 2", 2, 1, true, "2")]
|
||
[InlineData ("AB12", 5, 1, true, "21BA")]
|
||
[InlineData ("AB\n12", 5, 2, true, "21\nBA")]
|
||
[InlineData ("ABC 123 456", 7, 2, true, "654 321")]
|
||
[InlineData ("こんにちは", 1, 1, true, "")]
|
||
[InlineData ("こんにちは", 2, 1, true, "は")]
|
||
[InlineData ("こんにちは", 5, 1, true, "はち")]
|
||
[InlineData ("こんにちは", 10, 1, true, "はちにんこ")]
|
||
[InlineData ("こんにちは\nAB\n12", 10, 3, true, "21 \nBA \nはちにんこ")]
|
||
public void Draw_Horizontal_RightLeft_BottomTop (string text, int width, int height, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Direction = TextDirection.RightLeft_BottomTop,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, height);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, width, height), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 1, 0, false, "")]
|
||
[InlineData ("A", 0, 1, false, "")]
|
||
[InlineData ("AB1 2", 1, 2, false, "2")]
|
||
[InlineData ("AB12", 1, 5, false, "2\n1\nB\nA")]
|
||
[InlineData ("AB\n12", 2, 5, false, "B2\nA1")]
|
||
[InlineData ("ABC 123 456", 2, 7, false, "6C\n5B\n4A\n \n3 \n2 \n1 ")]
|
||
[InlineData ("こんにちは", 1, 1, false, "")]
|
||
[InlineData ("こんにちは", 2, 1, false, "は")]
|
||
[InlineData ("こんにちは", 2, 5, false, "は\nち\nに\nん\nこ")]
|
||
[InlineData ("こんにちは", 2, 10, false, "は\nち\nに\nん\nこ")]
|
||
[InlineData ("こんにちは\nAB\n12", 4, 10, false, "はB2\nちA1\nに \nん \nこ ")]
|
||
|
||
[InlineData ("A", 1, 0, true, "")]
|
||
[InlineData ("A", 0, 1, true, "")]
|
||
[InlineData ("AB1 2", 1, 2, true, "2")]
|
||
[InlineData ("AB12", 1, 5, true, "2\n1\nB\nA")]
|
||
[InlineData ("AB\n12", 2, 5, true, "B2\nA1")]
|
||
[InlineData ("ABC 123 456", 2, 7, true, "6\n5\n4\n \n3\n2\n1")]
|
||
[InlineData ("こんにちは", 1, 1, true, "")]
|
||
[InlineData ("こんにちは", 2, 1, true, "は")]
|
||
[InlineData ("こんにちは", 2, 5, true, "は\nち\nに\nん\nこ")]
|
||
[InlineData ("こんにちは", 2, 10, true, "は\nち\nに\nん\nこ")]
|
||
[InlineData ("こんにちは\nAB\n12", 4, 10, true, "はB2\nちA1\nに \nん \nこ ")]
|
||
public void Draw_Vertical_BottomTop_LeftRight (string text, int width, int height, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Direction = TextDirection.BottomTop_LeftRight,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, height);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, width, height), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("A", 1, 0, false, "")]
|
||
[InlineData ("A", 0, 1, false, "")]
|
||
[InlineData ("AB1 2", 1, 2, false, "2")]
|
||
[InlineData ("AB12", 1, 5, false, "2\n1\nB\nA")]
|
||
[InlineData ("AB\n12", 2, 5, false, "2B\n1A")]
|
||
[InlineData ("ABC 123 456", 2, 7, false, "C6\nB5\nA4\n \n 3\n 2\n 1")]
|
||
[InlineData ("こんにちは", 1, 1, false, "")]
|
||
[InlineData ("こんにちは", 2, 1, false, "は")]
|
||
[InlineData ("こんにちは", 2, 5, false, "は\nち\nに\nん\nこ")]
|
||
[InlineData ("こんにちは", 2, 10, false, "は\nち\nに\nん\nこ")]
|
||
[InlineData ("こんにちは\nAB\n12", 4, 10, false, "2Bは\n1Aち\n に\n ん\n こ")]
|
||
|
||
[InlineData ("A", 1, 0, true, "")]
|
||
[InlineData ("A", 0, 1, true, "")]
|
||
[InlineData ("AB1 2", 1, 2, true, "2")]
|
||
[InlineData ("AB12", 1, 5, true, "2\n1\nB\nA")]
|
||
[InlineData ("AB\n12", 2, 5, true, "2B\n1A")]
|
||
[InlineData ("ABC 123 456", 2, 7, true, "6\n5\n4\n \n3\n2\n1")]
|
||
[InlineData ("こんにちは", 1, 1, true, "")]
|
||
[InlineData ("こんにちは", 2, 1, true, "は")]
|
||
[InlineData ("こんにちは", 2, 5, true, "は\nち\nに\nん\nこ")]
|
||
[InlineData ("こんにちは", 2, 10, true, "は\nち\nに\nん\nこ")]
|
||
[InlineData ("こんにちは\nAB\n12", 4, 10, true, "2Bは\n1Aち\n に\n ん\n こ")]
|
||
public void Draw_Vertical_BottomTop_RightLeft (string text, int width, int height, bool autoSize, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Text = text,
|
||
Direction = TextDirection.BottomTop_RightLeft,
|
||
AutoSize = autoSize,
|
||
};
|
||
|
||
if (!autoSize)
|
||
{
|
||
tf.Size = new Size (width, height);
|
||
}
|
||
tf.Draw (new Rectangle (0, 0, width, height), Attribute.Default, Attribute.Default);
|
||
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
|
||
// Draw tests - Note that these depend on View
|
||
|
||
[Fact]
|
||
[TestRespondersDisposed]
|
||
public void Draw_Vertical_Throws_IndexOutOfRangeException_With_Negative_Bounds ()
|
||
{
|
||
Application.Init (new FakeDriver ());
|
||
|
||
Toplevel top = new ();
|
||
|
||
var view = new View { Y = -2, Height = 10, TextDirection = TextDirection.TopBottom_LeftRight, Text = "view" };
|
||
top.Add (view);
|
||
|
||
Application.Iteration += (s, a) =>
|
||
{
|
||
Assert.Equal (-2, view.Y);
|
||
|
||
Application.RequestStop ();
|
||
};
|
||
|
||
try
|
||
{
|
||
Application.Run (top);
|
||
}
|
||
catch (IndexOutOfRangeException ex)
|
||
{
|
||
// After the fix this exception will not be caught.
|
||
Assert.IsType<IndexOutOfRangeException> (ex);
|
||
}
|
||
|
||
top.Dispose ();
|
||
// Shutdown must be called to safely clean up Application if Init has been called
|
||
Application.Shutdown ();
|
||
}
|
||
|
||
//TODO: Expand this test to cover Vertical Alignment as well
|
||
[SetupFakeDriver]
|
||
[Theory]
|
||
[InlineData ("0 2 4", TextAlignment.Left, TextDirection.LeftRight_BottomTop, @"
|
||
0 2 4**
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******")]
|
||
[InlineData ("0 2 4", TextAlignment.Right, TextDirection.LeftRight_BottomTop, @"
|
||
**0 2 4
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******")]
|
||
[InlineData ("0 2 4", TextAlignment.Centered, TextDirection.LeftRight_BottomTop, @"
|
||
*0 2 4*
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******")]
|
||
|
||
[InlineData ("0 2 4", TextAlignment.Justified, TextDirection.LeftRight_BottomTop, @"
|
||
0 2 4
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******")]
|
||
|
||
[InlineData ("0 2 4", TextAlignment.Left, TextDirection.LeftRight_BottomTop, @"
|
||
0 2 4**
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******")]
|
||
[InlineData ("0 你 4", TextAlignment.Right, TextDirection.LeftRight_BottomTop, @"
|
||
*0 你 4
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******")]
|
||
[InlineData ("0 你 4", TextAlignment.Centered, TextDirection.LeftRight_BottomTop, @"
|
||
0 你 4*
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******")]
|
||
|
||
[InlineData ("0 你 4", TextAlignment.Justified, TextDirection.LeftRight_BottomTop, @"
|
||
0 你 4
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******
|
||
*******")]
|
||
public void Draw_Text_Alignment (string text, TextAlignment horizontalTextAlignment, TextDirection textDirection, string expectedText)
|
||
{
|
||
TextFormatter tf = new ()
|
||
{
|
||
Alignment = horizontalTextAlignment,
|
||
Direction = textDirection,
|
||
Size = new (7, 7),
|
||
Text = text
|
||
};
|
||
|
||
Application.Driver.FillRect (new Rectangle (0, 0, 7, 7), (Rune)'*');
|
||
tf.Draw (new Rectangle (0, 0, 7, 7), Attribute.Default, Attribute.Default);
|
||
TestHelpers.AssertDriverContentsWithFrameAre (expectedText, _output);
|
||
}
|
||
}
|