Release vNext

[csharpfritz]

No description provided.

In general, to fix a “useless assignment to local variable” issue you either (1) remove the unused variable and keep only the side-effectful expression, or (2) start using the variable meaningfully if it was intended for later use. Here, the test never uses cut after assignment; the important effect is rendering the Timer with the specified parameters so that OnTick updates tickCount. That effect comes from calling Render<Timer>(...), not from storing its return value.

The best minimal fix, without changing any test behavior, is to remove the cut variable in Timer_OnTick_IsInvokedAfterInterval and keep Render<Timer>(...) as a stand‑alone call expression. Concretely, in src/BlazorWebFormsComponents.Test/Timer/TimerTests.razor, replace the line var cut = Render<Timer>(p => p with just Render<Timer>(p => p. No other lines in this file need to change, and no new imports or definitions are required.

In general, to fix a "useless assignment to local variable" where the right-hand side has important side effects, you remove the assignment but keep the expression, so the side effects still occur while the unused local variable is eliminated. If the value is actually needed, you instead add appropriate uses or assertions that read the variable; but here, nothing in the test reads cut.

For this specific file, only the test Timer_EnabledFalse_DoesNotTick is affected. On line 70, change var cut = Render<Timer>(...) to simply call Render<Timer>(...) without assigning it to a variable, since the test only needs the component to be rendered so that OnTick could fire (and, in this scenario, should not fire because Enabled is false). No other tests or lines need to change; no additional methods, imports, or definitions are required.

Generally, to fix this kind of issue, replace loops that iterate an entire collection and skip elements with continue (or wrap the body in an if guard) by a loop that iterates a filtered sequence using LINQ’s Where method. The filtering predicate should be the logical negation of the skip condition so that only the elements of interest are enumerated inside the loop body.

In this file, only the test FileUpload_Render_OnlyExpectedAttributes needs updating. Specifically, lines 50–54:

foreach (var attr in input.Attributes)
{
    // Skip Blazor framework-internal attributes (e.g. blazor:elementreference)
    if (attr.Name.StartsWith("blazor:")) continue;

should be rewritten to iterate over a filtered sequence of attributes:

foreach (var attr in input.Attributes.Where(a => !a.Name.StartsWith("blazor:")))
{
    // Skip Blazor framework-internal attributes (e.g. blazor:elementreference)

The rest of the body, including the allowed.ShouldContain assertion, remains unchanged. This preserves behavior (we still skip attributes whose names start with "blazor:") while making the filtering explicit. Where is an extension method in System.Linq; in most Blazor test projects it is already available via global usings, but if not, a using System.Linq; directive would be required at the top of this file.

General approach: Avoid dereferencing skin.Width (a nullable property) directly without a null-safe guard. In tests, instead of using .Value.Value, assert directly on the Width property or use the null-forgiving operator or null-conditional access in a way that maintains test semantics but removes the risky dereference.

Best targeted fix here: In ForControl_NamedSkin_SetsProperties, replace the assertion skin.Width.Value.Value.ShouldBe(120); with an assertion that uses Shouldly directly on the Width property: skin.Width.ShouldBe(new Unit("120px"));. This keeps the test’s intent (verifying that the width is set to 120px), avoids dereferencing a possibly-null property, and does not change runtime functionality; it merely changes how the assertion is expressed. It also leverages the existing Unit type and comparison semantics instead of manually unpacking internal values.

Concretely:

• Edit src/BlazorWebFormsComponents.Test/Theming/ThemeConfigurationFluentTests.cs.
• In the ForControl_NamedSkin_SetsProperties test, change line 37 from skin.Width.Value.Value.ShouldBe(120); to skin.Width.ShouldBe(new Unit("120px"));.
• No new imports or methods are required, as Unit is already used in the same test and Shouldly is already imported.

In general, to fix a “dereferenced variable may be null” issue, you either ensure the value cannot be null (by construction) or you add an explicit null check/guard before dereferencing. In a unit test, the least intrusive fix is to assert non-nullness before accessing members, aligning with the test’s purpose of validating correct behavior rather than relying on implicit assumptions.

For this specific test, the best minimal change is to add two assertions after retrieving goSkin:

• goSkin.ShouldNotBeNull(); to ensure the skin exists.
• goSkin.Width.ShouldNotBeNull(); to ensure Width was actually configured.

Then the existing assertion goSkin.Width.Value.Value.ShouldBe(120); can safely dereference Width. This keeps existing functionality and expectations intact, uses the already-imported Shouldly library, and requires no new methods or imports. All changes are within src/BlazorWebFormsComponents.Test/Theming/ThemeConfigurationFluentTests.cs, inside the FullFluentExample_MatchesSpecSignature test, just before the dereference on line 203.

In general, to fix a "missed ternary opportunity" where both branches of an if statement only assign to the same variable, replace the if/else block with a single assignment that uses the ternary (? :) operator to choose the assigned value based on the condition. This shortens the code and makes the programmer’s intent—“assign one of two values depending on the condition”—explicit.

Specifically in src/BlazorWebFormsComponents/Style/Fonts/FontInfo.cs, in the Name property setter, you should replace the if (!string.IsNullOrEmpty(value)) / else block on lines 22–25 with a single assignment using the ternary operator to set _names to value when value is not null or empty, or null otherwise. No additional methods, imports, or definitions are required, and no other parts of the file need to change.