Files
Terminal.Gui/UnitTests/Configuration/ThemeTests.cs
dodexahedron 92a601254e Fixes #3170. Color improvements (#3204)
* Reduces indentation by remove the namespace braces.

* Reduces indentation and removes unused using.

* Ensures clear selection if it isn't selecting.

* Turn on nullability context for TryParse and update usages as needed.

* Use IsNullOrWhiteSpace, which includes IsNullOrEmpty

All-whitespace values are also illegal, so may as well handle that here too

* Respect the nullable here

* It's a struct

* Use byte.MaxValue and add remark

* Just use the bytes directly

* Must respect endianness

* Add uint constructor so consumers don't have to do unchecked math

* Completely re-work parsing and implement ISpanParsable<Color>

All parsing is now almost-0 allocation, and is significantly faster than before

* Extension methods required by new code

* Use standard Math.Clamp method here

* Add some new unit tests for TryParse

* De-duplicate code and handle more cases

* Enable nullability context for the file

* Go ahead and enable the language features and analysis

* Implicit usings remove a lot of boilerplate usings.

* Add these to the dictionary to shut spell check up

* Make this thing a record struct and a union, and update constructors

This commit won't build. I'm just breaking out changes a little bit.

* Some additional XmlDoc standardizing

* Make FindClosestColor and CalculateColorDistance use the vector for SIMD

* Add a TryFormat method for support of I*Formattable

* Add an interface for support of custom formatting of Colors

* Pass by in reference

* Parse string delegates to Parse span

* Parse now does all the work

* Remove the old new code from TryParse

* Some new cast operators

* Add IFormattable.ToString implementation

* Add the rest of the code for Color in its current (unfinished) state

* Move that interface to its own file

* Add ColorParseException class

* Move Attribute to its own file, too.

* Re-implement these operators as explicit methods

* Get rid of fuzzy equality operators and update tests to use the named methods that replace them

* Add an explicit test case for ToString with null format string and explicitly specified Invariant culture

* Fix byte orders for hex format to be standard ARGB

* Prove that ToString and Parse can round-trip values

* Unroll this test into parameterized cases

* Fix a couple of comments to match byte order

* Update R# dictionary to match correct byte orders

* Remove stray comment

* Separate all types in this to their own files

* Convert this one to use the handy extension

* Add test for Argb property

* Add a file nesting rule to make some incoming file changes display nicely

* Move constructor tests to their own file and add some new tests

* Add implicit cast from uint

* More constructor tests

* Since this is now a record, the equality operators are compiler generated

Still spot-checking a few arbitrary values for completeness

* Override ToString to delegate to Attribute

* Simplify and clean up ToString. Delegate to ColorScheme

* Update the test to match new output

* These should be fields, really. It's a value type.

* Add some type checks for change control

* Allow unsafe and turn on implicit usings

* Make this one better

* Rename tests and remove redundant checks (the type checks already guarantee field consistency)

* Reorganize a bit

* Make these test 16 random values

* Existing operator tests converted

* That one is now redundant with both of the other tests that check all the named colors

* Move this to type checks and simplify a little bit

* These lambdas can be static

* Move operators to another file.

* Add global using for System.Text because it's EVERYWHERE

* Reorganization of Color and some related types.

Updated usages to reflect changes

* Update tests to reflect changes in Terminal.Gui

* Add missing keyword

* Add entry to dictionary

* Add dotsettings for Terminal.Gui

Only specifies language level

* Commit unsaved changes for usings here

* Implement last remaining TryFormat method

* A little cleanup/formality

* Sorting rules

Sort methods by name and interface they implement

* Sort code

* Match namespace for tests

None!

* Unroll ordinal check and reorganize.

* Sort before writing new tests

* These got reversed...

* Add test to prove explicit cast to Vector3 works properly

* Sort these too

* Add test for uint->Color implicit operator

* Add test for Color->uint implicit operator

* Correct this test name and re-order

* Add test for implicit conversion from Vector3 to Color

* Add test for implicit conversion from Vector4 to Color

* These also got reversed, like with Vector3

* Add test for implicit conversion from Color to Vector4

* Add test for GetHashCode

* Make sure these are all under the same namespace

* Remove a now-redundant test

* Reorganize formatting and parsing tests to another type part

* Tests moved back to Terminal.Gui.DrawingTests namespace as before.

* Add tests for the constructor taking 3 or 4 integers and sort

* Cleanup

 - Renamed some tests
 - Make a test even clearer
 - Removed redundant code
 - Got rid of unused parameter in Constructor_WithColorName_AllChannelsCorrect

* That needs to be from the reverse map

Not broken - just was sub-optimal due to my error.

* Enable nullability context in this file

Not sure how it got removed but whatev

* Respect nullability context in this file now that it's on 🤦‍♂️

* Add tests for expected exceptions with whitespace or null values

* Add test for parameterless constructor

* A couple more places for reference passing and some SkipLocalsInit attributes.

* Some XmlDoc corrections to reflect the final implementation

* Remove namespace qualifier

* Can't use these because of lambdas :(

* Removed a collection that never ended up being needed.

* Add bracing, newline, and modifier style rules

* Add spacing rules inside parens/brackets

* This was still under the Terminal.Gui.Drawing namespace. Revert that.

* Applied updated formatting settings and addressed XmlDoc reviews in #3204

* More places where spaces got added in dependent code.

Also a couple of null checks fixed to not use the equality operator

* More dependent code format fixes

* Finished re-formatting modified code that got spaces added everywhere

* Visual studio didn't actually write this file to disk til I closed out of VS...

Grr

* Delete the ReSharper settings files from this branch.

---------

Co-authored-by: BDisp <bd.bdisp@gmail.com>
2024-01-24 09:58:02 -07:00

184 lines
6.2 KiB
C#

using Xunit;
using Terminal.Gui;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Text.Json;
using static Terminal.Gui.ConfigurationManager;
using Attribute = Terminal.Gui.Attribute;
namespace Terminal.Gui.ConfigurationTests {
public class ThemeTests {
public static readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions () {
Converters = {
new AttributeJsonConverter (),
new ColorJsonConverter ()
}
};
[Fact]
public void TestApply_UpdatesColors ()
{
// Arrange
ConfigurationManager.Reset ();
Assert.False (Colors.ColorSchemes.ContainsKey ("test"));
var theme = new ThemeScope ();
Assert.NotEmpty (theme);
Themes.Add ("testTheme", theme);
var colorScheme = new ColorScheme { Normal = new Attribute (Color.Red, Color.Green) };
theme ["ColorSchemes"].PropertyValue = new Dictionary<string, ColorScheme> () {
{ "test", colorScheme }
};
Assert.Equal (new Color (Color.Red), ((Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue) ["test"].Normal.Foreground);
Assert.Equal (new Color (Color.Green), ((Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue) ["test"].Normal.Background);
// Act
Themes.Theme = "testTheme";
Themes! [ThemeManager.SelectedTheme]!.Apply ();
// Assert
var updatedScheme = Colors.ColorSchemes ["test"];
Assert.Equal (new Color (Color.Red), updatedScheme.Normal.Foreground);
Assert.Equal (new Color (Color.Green), updatedScheme.Normal.Background);
// remove test ColorScheme from Colors to avoid failures on others unit tests with ColorScheme
Colors.ColorSchemes.Remove ("test");
Assert.Equal (5, Colors.ColorSchemes.Count);
}
[Fact]
public void TestApply ()
{
ConfigurationManager.Reset ();
var theme = new ThemeScope ();
Assert.NotEmpty (theme);
Themes.Add ("testTheme", theme);
Assert.Equal (LineStyle.Single, FrameView.DefaultBorderStyle);
theme ["FrameView.DefaultBorderStyle"].PropertyValue = LineStyle.Double; // default is Single
Themes.Theme = "testTheme";
Themes! [ThemeManager.SelectedTheme]!.Apply ();
Assert.Equal (LineStyle.Double, FrameView.DefaultBorderStyle);
}
[Fact]
public void TestUpdatFrom_Change ()
{
// arrange
ConfigurationManager.Reset ();
var theme = new ThemeScope ();
Assert.NotEmpty (theme);
var colorScheme = new ColorScheme {
// note: ColorScheme's can't be partial; default for each attribute
// is always White/Black
Normal = new Attribute (Color.Red, Color.Green),
Focus = new Attribute (Color.Cyan, Color.BrightCyan),
HotNormal = new Attribute (Color.Yellow, Color.BrightYellow),
HotFocus = new Attribute (Color.Green, Color.BrightGreen),
Disabled = new Attribute (Color.Gray, Color.DarkGray),
};
theme ["ColorSchemes"].PropertyValue = Colors.Reset ();
((Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue) ["test"] = colorScheme;
var colorSchemes = (Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue;
Assert.Equal (colorScheme.Normal, colorSchemes ["Test"].Normal);
Assert.Equal (colorScheme.Focus, colorSchemes ["Test"].Focus);
// Change just Normal
var newTheme = new ThemeScope ();
var newColorScheme = new ColorScheme {
Normal = new Attribute (Color.Blue, Color.BrightBlue),
Focus = colorScheme.Focus,
HotNormal = colorScheme.HotNormal,
HotFocus = colorScheme.HotFocus,
Disabled = colorScheme.Disabled,
};
newTheme ["ColorSchemes"].PropertyValue = Colors.Reset ();
((Dictionary<string, ColorScheme>)newTheme ["ColorSchemes"].PropertyValue) ["test"] = newColorScheme;
// Act
theme.Update (newTheme);
// Assert
colorSchemes = (Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue;
// Normal should have changed
Assert.Equal (new Color (Color.Blue), colorSchemes ["Test"].Normal.Foreground);
Assert.Equal (new Color (Color.BrightBlue), colorSchemes ["Test"].Normal.Background);
Assert.Equal (new Color (Color.Cyan), colorSchemes ["Test"].Focus.Foreground);
Assert.Equal (new Color (Color.BrightCyan), colorSchemes ["Test"].Focus.Background);
}
[Fact]
public void TestUpdatFrom_Add ()
{
// arrange
ConfigurationManager.Reset ();
var theme = new ThemeScope ();
Assert.NotEmpty (theme);
Assert.Equal (5, Colors.ColorSchemes.Count);
theme ["ColorSchemes"].PropertyValue = Colors.ColorSchemes;
var colorSchemes = (Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue;
Assert.Equal (Colors.ColorSchemes.Count, colorSchemes.Count);
var newTheme = new ThemeScope ();
var colorScheme = new ColorScheme {
// note: ColorScheme's can't be partial; default for each attribute
// is always White/Black
Normal = new Attribute (Color.Red, Color.Green),
Focus = new Attribute (Color.Cyan, Color.BrightCyan),
HotNormal = new Attribute (Color.Yellow, Color.BrightYellow),
HotFocus = new Attribute (Color.Green, Color.BrightGreen),
Disabled = new Attribute (Color.Gray, Color.DarkGray),
};
newTheme ["ColorSchemes"].PropertyValue = Colors.Reset ();
Assert.Equal (5, Colors.ColorSchemes.Count);
// add a new ColorScheme to the newTheme
((Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue) ["test"] = colorScheme;
colorSchemes = (Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue;
Assert.Equal (Colors.ColorSchemes.Count, colorSchemes.Count);
// Act
theme.Update (newTheme);
// Assert
colorSchemes = (Dictionary<string, ColorScheme>)theme ["ColorSchemes"].PropertyValue;
Assert.Equal (colorSchemes ["Test"].Normal, colorScheme.Normal);
Assert.Equal (colorSchemes ["Test"].Focus, colorScheme.Focus);
}
[Fact]
public void TestSerialize_RoundTrip ()
{
var theme = new ThemeScope ();
theme ["Dialog.DefaultButtonAlignment"].PropertyValue = Dialog.ButtonAlignments.Right;
var json = JsonSerializer.Serialize (theme, _jsonOptions);
var deserialized = JsonSerializer.Deserialize<ThemeScope> (json, _jsonOptions);
Assert.Equal (Dialog.ButtonAlignments.Right, (Dialog.ButtonAlignments)deserialized ["Dialog.DefaultButtonAlignment"].PropertyValue);
}
}
}