Version updated

This reverts commit d816d841a8.

.editorconfig

@@ -0,0 +1,244 @@
+# Remove the line below if you want to inherit .editorconfig settings from higher directories
+root = true
+
+# C# files
+[*.cs]
+
+#### Core EditorConfig Options ####
+
+# Indentation and spacing
+indent_size = 4
+indent_style = space
+tab_width = 4
+
+# New line preferences
+end_of_line = crlf
+insert_final_newline = false
+
+#### .NET Code Actions ####
+
+# Type members
+dotnet_hide_advanced_members = false
+dotnet_member_insertion_location = with_other_members_of_the_same_kind
+dotnet_property_generation_behavior = prefer_throwing_properties
+
+# Symbol search
+dotnet_search_reference_assemblies = true
+
+#### .NET Coding Conventions ####
+
+# Organize usings
+dotnet_separate_import_directive_groups = false
+dotnet_sort_system_directives_first = false
+file_header_template = unset
+
+# this. and Me. preferences
+dotnet_style_qualification_for_event = false
+dotnet_style_qualification_for_field = false
+dotnet_style_qualification_for_method = false
+dotnet_style_qualification_for_property = false
+
+# Language keywords vs BCL types preferences
+dotnet_style_predefined_type_for_locals_parameters_members = true
+dotnet_style_predefined_type_for_member_access = true
+
+# Parentheses preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity
+
+# Modifier preferences
+dotnet_style_require_accessibility_modifiers = for_non_interface_members
+
+# Expression-level preferences
+dotnet_prefer_system_hash_code = true
+dotnet_style_coalesce_expression = true
+dotnet_style_collection_initializer = true
+dotnet_style_explicit_tuple_names = true
+dotnet_style_namespace_match_folder = true
+dotnet_style_null_propagation = true
+dotnet_style_object_initializer = true
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+dotnet_style_prefer_auto_properties = true
+dotnet_style_prefer_collection_expression = when_types_loosely_match
+dotnet_style_prefer_compound_assignment = true
+dotnet_style_prefer_conditional_expression_over_assignment = true
+dotnet_style_prefer_conditional_expression_over_return = true
+dotnet_style_prefer_foreach_explicit_cast_in_source = when_strongly_typed
+dotnet_style_prefer_inferred_anonymous_type_member_names = true
+dotnet_style_prefer_inferred_tuple_names = true
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true
+dotnet_style_prefer_simplified_boolean_expressions = true
+dotnet_style_prefer_simplified_interpolation = true
+
+# Field preferences
+dotnet_style_readonly_field = true
+
+# Parameter preferences
+dotnet_code_quality_unused_parameters = all
+
+# Suppression preferences
+dotnet_remove_unnecessary_suppression_exclusions = none
+
+# New line preferences
+dotnet_style_allow_multiple_blank_lines_experimental = true
+dotnet_style_allow_statement_immediately_after_block_experimental = true
+
+#### C# Coding Conventions ####
+
+# var preferences
+csharp_style_var_elsewhere = false
+csharp_style_var_for_built_in_types = false
+csharp_style_var_when_type_is_apparent = false
+
+# Expression-bodied members
+csharp_style_expression_bodied_accessors = true
+csharp_style_expression_bodied_constructors = false
+csharp_style_expression_bodied_indexers = true
+csharp_style_expression_bodied_lambdas = true
+csharp_style_expression_bodied_local_functions = false
+csharp_style_expression_bodied_methods = false
+csharp_style_expression_bodied_operators = false
+csharp_style_expression_bodied_properties = true
+
+# Pattern matching preferences
+csharp_style_pattern_matching_over_as_with_null_check = true
+csharp_style_pattern_matching_over_is_with_cast_check = true
+csharp_style_prefer_extended_property_pattern = true
+csharp_style_prefer_not_pattern = true
+csharp_style_prefer_pattern_matching = true
+csharp_style_prefer_switch_expression = true
+
+# Null-checking preferences
+csharp_style_conditional_delegate_call = true
+
+# Modifier preferences
+csharp_prefer_static_anonymous_function = true
+csharp_prefer_static_local_function = true
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async
+csharp_style_prefer_readonly_struct = true
+csharp_style_prefer_readonly_struct_member = true
+
+# Code-block preferences
+csharp_prefer_braces = true
+csharp_prefer_simple_using_statement = true
+csharp_prefer_system_threading_lock = true
+csharp_style_namespace_declarations = block_scoped
+csharp_style_prefer_method_group_conversion = true
+csharp_style_prefer_primary_constructors = true
+csharp_style_prefer_top_level_statements = true
+
+# Expression-level preferences
+csharp_prefer_simple_default_expression = true
+csharp_style_deconstructed_variable_declaration = true
+csharp_style_implicit_object_creation_when_type_is_apparent = true
+csharp_style_inlined_variable_declaration = true
+csharp_style_prefer_index_operator = true
+csharp_style_prefer_local_over_anonymous_function = true
+csharp_style_prefer_null_check_over_type_check = true
+csharp_style_prefer_range_operator = true
+csharp_style_prefer_tuple_swap = true
+csharp_style_prefer_utf8_string_literals = true
+csharp_style_throw_expression = true
+csharp_style_unused_value_assignment_preference = discard_variable
+csharp_style_unused_value_expression_statement_preference = discard_variable
+
+# 'using' directive preferences
+csharp_using_directive_placement = outside_namespace
+
+# New line preferences
+csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true
+csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true
+csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = true
+csharp_style_allow_blank_lines_between_consecutive_braces_experimental = true
+csharp_style_allow_embedded_statements_on_same_line_experimental = true
+
+#### C# Formatting Rules ####
+
+# New line preferences
+csharp_new_line_before_catch = true
+csharp_new_line_before_else = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_open_brace = all
+csharp_new_line_between_query_expression_clauses = true
+
+# Indentation preferences
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents = true
+csharp_indent_case_contents_when_block = true
+csharp_indent_labels = no_change
+csharp_indent_switch_labels = true
+
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_after_comma = true
+csharp_space_after_dot = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_around_declaration_statements = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_before_comma = false
+csharp_space_before_dot = false
+csharp_space_before_open_square_brackets = false
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_between_square_brackets = false
+
+# Wrapping preferences
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = true
+
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case

.github/ISSUE_TEMPLATE/bug_report.md

@@ -11,7 +11,7 @@ assignees: ''
 
 IMPORTANT: Read this first!!!
 
-1. If you own a Radzen Professional or Еnterprise subscription you can report your issue or ask us a question via email at info@radzen.com. Radzen staff will reply within 24 hours (Professional) or 16 hours (Enterprise)
+1. If you own a Radzen Blazor subscription you can report your issue or ask us a question via email at info@radzen.com. Radzen staff will reply within 24 hours (Pro) or 16 hours (Team)
 2. The Radzen staff guarantees a response to issues in this repo only to paid subscribers. 
 3. If you have a HOW TO question start a new forum thread in the Radzen Community forum: https://forum.radzen.com. Radzen staff will close issues that are HOWTO questions.
 4. Please adhere to the issue template. Specify all the steps required to reproduce the issue or link a project which reproduces it easily (without requiring extra steps such as restoring a database).

.github/ISSUE_TEMPLATE/config.yml

@@ -5,4 +5,4 @@ contact_links:
     about: Please ask and answer questions here.
   - name: Radzen Commercial Support 
     url: info@radzen.com
-    about: Radzen Professional or Enterprise subscribers can get dedicated support over email.
+    about: Radzen Blazor subscribers can get dedicated support over email.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -11,7 +11,7 @@ assignees: ''
 
 IMPORTANT: Read this first!!!
 
-1. If you own a Radzen Professional or Еnterprise subscription you can request your feature via email at info@radzen.com. Radzen staff will reply within 24 hours (Professional) or 16 hours (Enterprise)
+1. If you own a Radzen Blazor subscription you can request your feature via email at info@radzen.com. Radzen staff will reply within 24 hours (Pro) or 16 hours (Team)
 2. The Radzen staff guarantees a response to issues in this repo only to paid subscribers. 
 3. If you have a HOW TO question start a new forum thread in the Radzen Community forum: https://forum.radzen.com. Radzen staff will close issues that are HOWTO questions.
 4. Please adhere to the issue template. 

.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+# This workflow will build a .NET project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net
+
+name: .NET
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 9.0.x
+    
+    - name: Build
+      run: dotnet build Radzen.Blazor/Radzen.Blazor.csproj
+    - name: Test
+      run: dotnet test Radzen.Blazor.Tests/Radzen.Blazor.Tests.csproj

.gitignore

@@ -341,3 +341,10 @@ Radzen.DocFX/_exported_templates
 Radzen.DocFX/api/*.yml
 !Radzen.DocFX/api/index.md
 Radzen.DocFX/api/.manifest
+Radzen.Blazor.min.js
+/.claude
+/SANKEY_PATTERN_COMPARISON.md
+*.md
+/.gitignore
+/.gitignore
+RadzenBlazorDemos/wwwroot/demos

CONTRIBUTING.md

@@ -19,7 +19,7 @@ You can ask your question here. Please use the [Radzen.Blazor Components](https:
 
 ### Dedicated technical support
 
-Radzen staff provides technical support with guaranteed response time to Radzen Professional and Enterprise subscribers. The pricing options are available [here](https://www.radzen.com/pricing/).
+Radzen staff provides technical support with guaranteed response time to Radzen Professional and Enterprise subscribers. The pricing options are available [here](https://www.radzen.com/pricing).
 
 ## How Can I Contribute?
 

Dockerfile

@@ -1,30 +1,23 @@
-# syntax=docker/dockerfile:1
-FROM mono:latest
-
-ENV DOCFX_VER 2.58.4
-
-RUN apt-get update && apt-get install unzip wget git -y && wget -q -P /tmp https://github.com/dotnet/docfx/releases/download/v${DOCFX_VER}/docfx.zip && \
-    mkdir -p /opt/docfx && \
-    unzip /tmp/docfx.zip -d /opt/docfx && \
-    echo '#!/bin/bash\nmono /opt/docfx/docfx.exe $@' > /usr/bin/docfx && \
-    chmod +x /usr/bin/docfx && \
-    rm -rf /tmp/*
+FROM mcr.microsoft.com/dotnet/sdk:9.0
 
 COPY Radzen.Blazor /app/Radzen.Blazor
-COPY Radzen.DocFX /app/DocFX
+COPY Radzen.DocFX /app/Radzen.DocFX
 COPY RadzenBlazorDemos /app/RadzenBlazorDemos
-WORKDIR /app
-RUN docfx DocFX/docfx.json
+COPY RadzenBlazorDemos.Host /app/RadzenBlazorDemos.Host
 
-FROM mcr.microsoft.com/dotnet/sdk:6.0-focal
-
-COPY --from=0 /app/RadzenBlazorDemos /app
 WORKDIR /app
+
+RUN dotnet tool install -g docfx
+ENV PATH="$PATH:/root/.dotnet/tools"
+RUN wget https://dot.net/v1/dotnet-install.sh \
+    && bash dotnet-install.sh --channel 8.0 --runtime dotnet --install-dir /usr/share/dotnet
+RUN dotnet build -c Release Radzen.Blazor/Radzen.Blazor.csproj -f net8.0
+RUN docfx Radzen.DocFX/docfx.json
+
+WORKDIR /app/RadzenBlazorDemos.Host
 RUN dotnet publish -c Release -o out
-COPY RadzenBlazorDemos/northwind.db /app/out
-COPY RadzenBlazorDemos/northwind.sql /app/out
 
-ENV ASPNETCORE_URLS http://*:5000
-WORKDIR /app/out
+ENV ASPNETCORE_URLS=http://*:5000
+WORKDIR /app/RadzenBlazorDemos.Host/out
 
-ENTRYPOINT ["dotnet", "RadzenBlazorDemos.dll"]
+ENTRYPOINT ["dotnet", "RadzenBlazorDemos.Host.dll"]

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018-2022 Radzen Ltd
+Copyright (c) 2018-2025 Radzen Ltd
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,64 +1,57 @@
-# Radzen Blazor Components
+![Radzen Blazor Components](https://raw.githubusercontent.com/radzenhq/radzen-blazor/master/RadzenBlazorDemos/wwwroot/images/radzen-blazor-components.png)
 
-The home of the [Radzen Blazor components](https://blazor.radzen.com)
+Radzen Blazor Components
+========================
 
-## Commercial support
+The most sophisticated free UI component library for Blazor, featuring **100+ native components**.
 
-Paid support for the Radzen Blazor Components is available as part of the [Radzen Professional subscription](https://www.radzen.com/pricing/). 
+See Online Demos or Read the Docs
 
-Our flagship product Radzen provides tons of productivity features for Blazor developers:
-- The first in the industry WYSIWYG Blazor design time canvas
+ [![License - MIT](https://img.shields.io/github/license/radzenhq/radzen-blazor?logo=github&style=for-the-badge)](https://github.com/radzenhq/radzen-blazor/blob/master/LICENSE)[![NuGet Downloads](https://img.shields.io/nuget/dt/Radzen.Blazor?color=%232694F9&label=nuget%20downloads&logo=nuget&style=for-the-badge) ](https://www.nuget.org/packages/Radzen.Blazor)![Last Commit](https://img.shields.io/github/last-commit/radzenhq/radzen-blazor?logo=github&style=for-the-badge) [![Github Contributors](https://img.shields.io/github/contributors/radzenhq/radzen-blazor?logo=github&style=for-the-badge) ](https://github.com/radzenhq/radzen-blazor/graphs/contributors)[![Radzen Blazor Components - Online Demos](https://img.shields.io/badge/demos-online-brightgreen?color=%232694F9&logo=blazor&style=for-the-badge) ](https://blazor.radzen.com)[![Radzen Blazor Components - Documentation](https://img.shields.io/badge/docs-online-brightgreen?color=%232694F9&logo=blazor&style=for-the-badge)](https://blazor.radzen.com/docs)
+
+## Why choose Radzen Blazor Components?
+
+### :sparkles: Free
+
+Radzen Blazor Components are open source and free for commercial use. You can install them from [NuGet](https://www.nuget.org/packages/Radzen.Blazor) or build your own copy from source.
+
+Paid support is available as part of the [Radzen Blazor subscription](https://www.radzen.com/pricing).
+
+### :computer: Native
+
+The components are implemented in C# and take full advantage of the Blazor framework. They do not depend on or wrap existing JavaScript frameworks or libraries.
+
+Blazor Server and Blazor WebAssembly are fully supported.
+
+### :seedling: Growing
+
+We add new components and features on a regular basis.
+
+Short development cycle. We release as soon as new stuff is available. No more quarterly releases.
+
+## Support exceeding your expectations
+
+### :speech_balloon: Community Support
+Everybody is welcome to visit the [Radzen Community forum](https://forum.radzen.com/). Join the growing community and participate in the discussions!
+
+### :dart: Dedicated Support
+
+The Radzen team monitors the forum threads, but does not guarantee a response to every question. For guaranteed responses you may consider the dedicated support option.
+
+Dedicated support for the Radzen Blazor Components is available as part of the [Radzen Blazor subscription](https://www.radzen.com/pricing).
+
+Our flagship product [Radzen Blazor Studio](https://www.radzen.com/blazor-studio) provides tons of productivity features for Blazor developers:
+- An industry-leading WYSIWYG Blazor design time canvas
 - Scaffolding a complete CRUD applications from a database
 - Built-in security - authentication and authorization
 - Visual Studio Code and Professional support
 - Deployment to IIS and Azure
 - Dedicated support with 24 hour guaranteed response time
-- Active community forum
 
-## Get started with the Radzen Blazor Components
+## Get started with Radzen Blazor Components
 
-### Install
+Check the [getting started](https://blazor.radzen.com/get-started) instructions to start making awesome Blazor applications.
 
-Radzen Blazor Components are distributed as the Radzen.Blazor nuget package. You can add them to your project in one of the following ways
-- Install the package from command line by running dotnet add package Radzen.Blazor
-- Add the project from the Visual Nuget Package Manager 
-- Manually edit the .csproj file and add a project reference
+## Run demos locally
 
-### Import the namespace
-
-Open the `_Imports.razor` file of your Blazor application and add this line `@using Radzen.Blazor`.
-
-### Include a theme
-
-Open the `_Host.cshtml` file (server-side Blazor) or `wwwroot/index.html` (client-side Blazor) and include a theme CSS file by adding this snippet `<link rel="stylesheet" href="_content/Radzen.Blazor/css/default.css">` or `<link rel="stylesheet" href="_content/Radzen.Blazor/css/default-base.css">` if you either include Bootstrap manually or don't use it at all.
-
-### Include Radzen.Blazor.js
-
-Open the `_Host.cshtml` file (server-side Blazor) or `wwwroot/index.html` (client-side Blazor) and include this snippet `<script src="_content/Radzen.Blazor/Radzen.Blazor.js"></script>`
-
-### Use a component
-Use any Radzen Blazor component by typing its tag name in a Blazor page e.g. 
-```html
-<RadzenButton Text="Hi"></RadzenButton>
-```
-
-#### Data-binding a property
-```razor
-<RadzenButton Text=@text />
-<RadzenTextBox @bind-Value=@text />
-@code {
-  string text = "Hi";
-}
-```
-
-#### Handing events
-
-```razor
-<RadzenButton Click="@ButtonClicked" Text="Hi"></RadzenButton>
-@code {
-  void ButtonClicked()
-  {
-
-  }
-}
-```
+Use Radzen.Server.sln to open and run demos as Blazor server application or Radzen.WebAssembly.sln to open and run demos as Blazor WebAssembly application. Radzen.sln has reference to all projects including tests.

Radzen.Blazor.Tests/AIChatTests.cs

@@ -0,0 +1,171 @@
+using Bunit;
+using Microsoft.Extensions.DependencyInjection;
+using Radzen;
+using System;
+using System.Net.Http;
+using Microsoft.Extensions.Options;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class AIChatTests
+    {
+        private void RegisterChatService(TestContext ctx)
+        {
+            // Register a dummy HttpClient and default options for AIChatService
+            ctx.Services.AddSingleton(new HttpClient());
+            ctx.Services.AddScoped<IAIChatService, AIChatService>();
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldRenderWithDefaultProperties()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            Assert.Contains("Type your message...", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldRenderWithCustomTitle()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.Title, "Custom Chat"));
+            Assert.Contains("Custom Chat", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldRenderWithCustomPlaceholder()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.Placeholder, "Enter your message here..."));
+            Assert.Contains("Enter your message here...", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldRenderWithCustomEmptyMessage()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.EmptyMessage, "No messages yet"));
+            Assert.Contains("No messages yet", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldShowClearButtonByDefault()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            Assert.Contains("rz-chat-header-clear", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldHideClearButtonWhenShowClearButtonIsFalse()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.ShowClearButton, false));
+            Assert.DoesNotContain("clear_all", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldBeDisabledWhenDisabledIsTrue()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.Disabled, true));
+            Assert.Contains("disabled", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldBeReadOnlyWhenReadOnlyIsTrue()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters
+                .Add(p => p.ReadOnly, true));
+            Assert.Contains("readonly", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldHaveCorrectCssClass()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            Assert.Contains("rz-chat", component.Markup);
+        }
+
+        [Fact]
+        public void ChatMessage_ShouldHaveCorrectProperties()
+        {
+            // Arrange
+            var message = new ChatMessage
+            {
+                Content = "Test message",
+                IsUser = true,
+                Timestamp = DateTime.Now
+            };
+            // Assert
+            Assert.NotEmpty(message.Id);
+            Assert.Equal("Test message", message.Content);
+            Assert.True(message.IsUser);
+            Assert.False(message.IsStreaming);
+        }
+
+        [Fact]
+        public void RadzenAIChat_AddMessage_ShouldAddMessageToList()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            // Act
+            component.Instance.AddMessage("Test message", true);
+            // Assert
+            var messages = component.Instance.GetMessages();
+            Assert.Single(messages);
+            Assert.Equal("Test message", messages[0].Content);
+            Assert.True(messages[0].IsUser);
+        }
+
+        [Fact]
+        public void RadzenAIChat_ClearChat_ShouldRemoveAllMessages()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>();
+            component.Instance.AddMessage("Test message 1", true);
+            component.Instance.AddMessage("Test message 2", false);
+            // Act
+            component.InvokeAsync(async () => await component.Instance.ClearChat()).Wait();
+            // Assert
+            Assert.Empty(component.Instance.GetMessages());
+        }
+
+        [Fact]
+        public void RadzenAIChat_ShouldLimitMessagesToMaxMessages()
+        {
+            using var ctx = new TestContext();
+            RegisterChatService(ctx);
+            var component = ctx.RenderComponent<RadzenAIChat>(parameters => parameters.Add(p => p.MaxMessages, 3));
+            component.Instance.AddMessage("Message 1", true);
+            component.Instance.AddMessage("Message 2", false);
+            component.Instance.AddMessage("Message 3", true);
+            component.Instance.AddMessage("Message 4", false);
+            // Assert
+            var messages = component.Instance.GetMessages();
+            Assert.Equal(3, messages.Count);
+            Assert.Equal("Message 2", messages[0].Content);
+            Assert.Equal("Message 3", messages[1].Content);
+            Assert.Equal("Message 4", messages[2].Content);
+        }
+    }
+} 

Radzen.Blazor.Tests/AccordionTests.cs

@@ -0,0 +1,195 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class AccordionTests
+    {
+        [Fact]
+        public void Accordion_Renders_CssClasses()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>();
+
+            Assert.Contains(@"rz-accordion", component.Markup);
+        }
+
+        [Fact]
+        public void Accordion_Renders_AccordionItems()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Test Item");
+                    builder.AddAttribute(2, "ChildContent", (RenderFragment)(contentBuilder =>
+                    {
+                        contentBuilder.AddContent(0, "Item Content");
+                    }));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("Test Item", component.Markup);
+            Assert.Contains("Item Content", component.Markup);
+        }
+
+        [Fact]
+        public void Accordion_Renders_ItemWithIcon()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Orders");
+                    builder.AddAttribute(2, "Icon", "account_balance_wallet");
+                    builder.AddAttribute(3, "ChildContent", (RenderFragment)(contentBuilder =>
+                    {
+                        contentBuilder.AddContent(0, "Order Details");
+                    }));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("account_balance_wallet", component.Markup);
+            Assert.Contains("Orders", component.Markup);
+        }
+
+        [Fact]
+        public void Accordion_SingleExpand_OnlyOneItemExpanded()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, false); // Single expand mode
+                parameters.Add(p => p.Items, builder =>
+                {
+                    // Add first item
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Item 1");
+                    builder.AddAttribute(2, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content 1")));
+                    builder.CloseComponent();
+
+                    // Add second item
+                    builder.OpenComponent<RadzenAccordionItem>(1);
+                    builder.AddAttribute(1, "Text", "Item 2");
+                    builder.AddAttribute(2, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content 2")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.False(component.Instance.Multiple);
+        }
+
+        [Fact]
+        public void Accordion_MultipleExpand_AllowsMultipleItemsExpanded()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+            });
+
+            Assert.True(component.Instance.Multiple);
+        }
+
+        [Fact]
+        public void Accordion_Raises_ExpandEvent()
+        {
+            using var ctx = new TestContext();
+            
+            var expandRaised = false;
+            int expandedIndex = -1;
+
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Expand, EventCallback.Factory.Create<int>(this, (index) =>
+                {
+                    expandRaised = true;
+                    expandedIndex = index;
+                }));
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Test Item");
+                    builder.AddAttribute(2, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content")));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Find and click the accordion header link to expand
+            var header = component.Find(".rz-accordion-header a");
+            header.Click();
+
+            Assert.True(expandRaised);
+            Assert.Equal(0, expandedIndex);
+        }
+
+        [Fact]
+        public void Accordion_Raises_CollapseEvent()
+        {
+            using var ctx = new TestContext();
+            
+            var collapseRaised = false;
+            int collapsedIndex = -1;
+
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Collapse, EventCallback.Factory.Create<int>(this, (index) =>
+                {
+                    collapseRaised = true;
+                    collapsedIndex = index;
+                }));
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Test Item");
+                    builder.AddAttribute(2, "Selected", true); // Start expanded
+                    builder.AddAttribute(3, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content")));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Find and click the accordion header link to collapse
+            var header = component.Find(".rz-accordion-header a");
+            header.Click();
+
+            Assert.True(collapseRaised);
+            Assert.Equal(0, collapsedIndex);
+        }
+
+        [Fact]
+        public void Accordion_DisabledItem_CannotExpand()
+        {
+            using var ctx = new TestContext();
+            
+            var expandRaised = false;
+
+            var component = ctx.RenderComponent<RadzenAccordion>(parameters =>
+            {
+                parameters.Add(p => p.Expand, EventCallback.Factory.Create<int>(this, (_) => expandRaised = true));
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenAccordionItem>(0);
+                    builder.AddAttribute(1, "Text", "Disabled Item");
+                    builder.AddAttribute(2, "Disabled", true);
+                    builder.AddAttribute(3, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Content")));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Try to click the disabled item
+            var header = component.Find(".rz-accordion-header a");
+            header.Click();
+
+            // Event should not be raised for disabled item
+            Assert.False(expandRaised);
+        }
+    }
+}
+

Radzen.Blazor.Tests/AlertTests.cs

@@ -0,0 +1,195 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class AlertTests
+    {
+        [Fact]
+        public void Alert_Renders_CssClasses()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            Assert.Contains(@"rz-alert", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_AlertStyle()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlertStyle, AlertStyle.Danger));
+            Assert.Contains("rz-danger", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlertStyle, AlertStyle.Success));
+            Assert.Contains("rz-success", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlertStyle, AlertStyle.Warning));
+            Assert.Contains("rz-warning", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlertStyle, AlertStyle.Info));
+            Assert.Contains("rz-info", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_Shade()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            component.SetParametersAndRender(parameters => parameters
+                .Add(p => p.AlertStyle, AlertStyle.Primary)
+                .Add(p => p.Shade, Shade.Lighter));
+
+            Assert.Contains("rz-shade-lighter", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters
+                .Add(p => p.AlertStyle, AlertStyle.Primary)
+                .Add(p => p.Shade, Shade.Darker));
+
+            Assert.Contains("rz-shade-darker", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_Variant()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Outlined));
+            Assert.Contains("rz-variant-outlined", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Flat));
+            Assert.Contains("rz-variant-flat", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_Title()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            var title = "Alert Title";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Title, title));
+
+            Assert.Contains(title, component.Markup);
+            Assert.Contains("rz-alert-title", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_Text()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            var text = "This is an alert message";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void Alert_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>(parameters =>
+            {
+                parameters.AddChildContent("Custom alert content");
+            });
+
+            Assert.Contains("Custom alert content", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_ShowIcon_DisplaysIcon()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            // Default should show icon
+            Assert.Contains("rz-alert-icon", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ShowIcon, false));
+            Assert.DoesNotContain("rz-alert-icon", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_AllowClose_DisplaysCloseButton()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenAlert>();
+
+            // Default AllowClose is true - should contain a button with close icon
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AllowClose, true));
+            Assert.Contains("close", component.Markup);
+            Assert.Contains("rz-button", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AllowClose, false));
+            // When AllowClose is false, should not have close button
+            var buttonCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rz-button").Count;
+            Assert.Equal(0, buttonCount);
+        }
+
+        [Fact]
+        public void Alert_CloseButton_RaisesCloseEvent()
+        {
+            using var ctx = new TestContext();
+            
+            var closeRaised = false;
+
+            var component = ctx.RenderComponent<RadzenAlert>(parameters =>
+            {
+                parameters.Add(p => p.AllowClose, true);
+                parameters.Add(p => p.Close, () => closeRaised = true);
+            });
+
+            var closeButton = component.Find("button.rz-button");
+            closeButton.Click();
+
+            Assert.True(closeRaised);
+        }
+
+        [Fact]
+        public void Alert_Visible_ControlsDisplay()
+        {
+            using var ctx = new TestContext();
+            
+            var component = ctx.RenderComponent<RadzenAlert>(parameters =>
+            {
+                parameters.Add(p => p.Visible, true);
+                parameters.Add(p => p.Text, "Visible Alert");
+            });
+
+            Assert.Contains("Visible Alert", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Visible, false));
+
+            // When not visible, component should not render
+            Assert.DoesNotContain("Visible Alert", component.Markup);
+        }
+
+        [Fact]
+        public void Alert_CloseButton_SetsVisibleToFalse()
+        {
+            using var ctx = new TestContext();
+            
+            var visibleValue = true;
+
+            var component = ctx.RenderComponent<RadzenAlert>(parameters =>
+            {
+                parameters.Add(p => p.Visible, visibleValue);
+                parameters.Add(p => p.AllowClose, true);
+                parameters.Add(p => p.VisibleChanged, (bool value) => visibleValue = value);
+            });
+
+            var closeButton = component.Find("button.rz-button");
+            closeButton.Click();
+
+            Assert.False(visibleValue);
+        }
+    }
+}
+
+

Radzen.Blazor.Tests/AutoCompleteTests.cs

@@ -0,0 +1,139 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Radzen.Blazor.Tests
+{
+	public class AutoCompleteTests
+	{
+        [Fact]
+        public void AutoComplete_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenAutoComplete>();
+
+            Assert.Contains(@"rz-autocomplete", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Renders_InputElement()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenAutoComplete>();
+
+            Assert.Contains("type=\"text\"", component.Markup);
+            Assert.Contains("rz-inputtext", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenAutoComplete>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Renders_Placeholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenAutoComplete>(parameters =>
+            {
+                parameters.Add(p => p.Placeholder, "Type to search...");
+            });
+
+            Assert.Contains("placeholder=\"Type to search...\"", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Renders_WithData()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Apple", "Banana", "Cherry" };
+
+            var component = ctx.RenderComponent<RadzenAutoComplete>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-autocomplete-panel", component.Markup);
+        }
+
+        [Fact]
+        public void AutoComplete_Enum_Converts_To_Attr_Value()
+        {
+            // Options
+            Assert.Equal("off", AutoCompleteType.Off.GetAutoCompleteValue());
+            Assert.Equal("on", AutoCompleteType.On.GetAutoCompleteValue());
+            Assert.Equal("name", AutoCompleteType.Name.GetAutoCompleteValue());
+            Assert.Equal("honorific-prefix", AutoCompleteType.HonorificPrefix.GetAutoCompleteValue());
+            Assert.Equal("given-name", AutoCompleteType.GivenName.GetAutoCompleteValue());
+            Assert.Equal("additional-name", AutoCompleteType.AdditionalName.GetAutoCompleteValue());
+            Assert.Equal("family-name", AutoCompleteType.FamilyName.GetAutoCompleteValue());
+            Assert.Equal("honorific-suffix", AutoCompleteType.HonorificSuffix.GetAutoCompleteValue());
+            Assert.Equal("nickname", AutoCompleteType.Nickname.GetAutoCompleteValue());
+            Assert.Equal("email", AutoCompleteType.Email.GetAutoCompleteValue());
+            Assert.Equal("username", AutoCompleteType.Username.GetAutoCompleteValue());
+            Assert.Equal("new-password", AutoCompleteType.NewPassword.GetAutoCompleteValue());
+            Assert.Equal("current-password", AutoCompleteType.CurrentPassword.GetAutoCompleteValue());
+            Assert.Equal("one-time-code", AutoCompleteType.OneTimeCode.GetAutoCompleteValue());
+            Assert.Equal("organization-title", AutoCompleteType.OrganizationTitle.GetAutoCompleteValue());
+            Assert.Equal("organization", AutoCompleteType.Organization.GetAutoCompleteValue());
+            Assert.Equal("street-address", AutoCompleteType.StreetAddress.GetAutoCompleteValue());
+            Assert.Equal("address-line1", AutoCompleteType.AddressLine1.GetAutoCompleteValue());
+            Assert.Equal("address-line2", AutoCompleteType.AddressLine2.GetAutoCompleteValue());
+            Assert.Equal("address-line3", AutoCompleteType.AddressLine3.GetAutoCompleteValue());
+            Assert.Equal("address-level1", AutoCompleteType.AddressLevel1.GetAutoCompleteValue());
+            Assert.Equal("address-level2", AutoCompleteType.AddressLevel2.GetAutoCompleteValue());
+            Assert.Equal("address-level3", AutoCompleteType.AddressLevel3.GetAutoCompleteValue());
+            Assert.Equal("address-level4", AutoCompleteType.AddressLevel4.GetAutoCompleteValue());
+            Assert.Equal("country", AutoCompleteType.Country.GetAutoCompleteValue());
+            Assert.Equal("country-name", AutoCompleteType.CountryName.GetAutoCompleteValue());
+            Assert.Equal("postal-code", AutoCompleteType.PostalCode.GetAutoCompleteValue());
+            Assert.Equal("cc-name", AutoCompleteType.CcName.GetAutoCompleteValue());
+            Assert.Equal("cc-given-name", AutoCompleteType.CcGivenName.GetAutoCompleteValue());
+            Assert.Equal("cc-additional-name", AutoCompleteType.CcAdditionalName.GetAutoCompleteValue());
+            Assert.Equal("cc-family-name", AutoCompleteType.CcFamilyName.GetAutoCompleteValue());
+            Assert.Equal("cc-number", AutoCompleteType.CcNumber.GetAutoCompleteValue());
+            Assert.Equal("cc-exp", AutoCompleteType.CcExp.GetAutoCompleteValue());
+            Assert.Equal("cc-exp-month", AutoCompleteType.CcExpMonth.GetAutoCompleteValue());
+            Assert.Equal("cc-exp-year", AutoCompleteType.CcExpYear.GetAutoCompleteValue());
+            Assert.Equal("cc-csc", AutoCompleteType.CcCsc.GetAutoCompleteValue());
+            Assert.Equal("cc-type", AutoCompleteType.CcType.GetAutoCompleteValue());
+            Assert.Equal("transaction-currency", AutoCompleteType.TransactionCurrency.GetAutoCompleteValue());
+            Assert.Equal("transaction-amount", AutoCompleteType.TransactionAmount.GetAutoCompleteValue());
+            Assert.Equal("language", AutoCompleteType.Language.GetAutoCompleteValue());
+            Assert.Equal("bday", AutoCompleteType.Bday.GetAutoCompleteValue());
+            Assert.Equal("bday-day", AutoCompleteType.BdayDay.GetAutoCompleteValue());
+            Assert.Equal("bday-month", AutoCompleteType.BdayMonth.GetAutoCompleteValue());
+            Assert.Equal("bday-year", AutoCompleteType.BdayYear.GetAutoCompleteValue());
+            Assert.Equal("sex", AutoCompleteType.Sex.GetAutoCompleteValue());
+            Assert.Equal("tel", AutoCompleteType.Tel.GetAutoCompleteValue());
+            Assert.Equal("tel-country-code", AutoCompleteType.TelCountryCode.GetAutoCompleteValue());
+            Assert.Equal("tel-national", AutoCompleteType.TelNational.GetAutoCompleteValue());
+            Assert.Equal("tel-area-code", AutoCompleteType.TelAreaCode.GetAutoCompleteValue());
+            Assert.Equal("tel-local", AutoCompleteType.TelLocal.GetAutoCompleteValue());
+            Assert.Equal("tel-extension", AutoCompleteType.TelExtension.GetAutoCompleteValue());
+            Assert.Equal("impp", AutoCompleteType.Impp.GetAutoCompleteValue());
+            Assert.Equal("url", AutoCompleteType.Url.GetAutoCompleteValue());
+            Assert.Equal("photo", AutoCompleteType.Photo.GetAutoCompleteValue());
+            // Synonyms
+            Assert.Equal("address-level1", AutoCompleteType.State.GetAutoCompleteValue());
+            Assert.Equal("address-level1", AutoCompleteType.Province.GetAutoCompleteValue());
+            Assert.Equal("postal-code", AutoCompleteType.ZipCode.GetAutoCompleteValue());
+            Assert.Equal("given-name", AutoCompleteType.FirstName.GetAutoCompleteValue());
+            Assert.Equal("additional-name", AutoCompleteType.MiddleName.GetAutoCompleteValue());
+            Assert.Equal("family-name", AutoCompleteType.LastName.GetAutoCompleteValue());
+        }
+    }
+}

Radzen.Blazor.Tests/BreadCrumbTests.cs

@@ -0,0 +1,77 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class BreadCrumbTests
+    {
+        [Fact]
+        public void BreadCrumb_Renders_Items()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenBreadCrumb>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(c => c.ChildContent, builder =>
+          {
+              builder.OpenComponent<RadzenBreadCrumbItem>(0);
+              builder.AddAttribute(1, nameof(RadzenBreadCrumbItem.Text), "Test");
+              builder.CloseComponent();
+          });
+            });
+            //@"<RadzenBreadCrumbItem Text=""Test"" />"
+            Assert.Contains(@"class=""rz-breadcrumb-item", component.Markup);
+            Assert.Contains(">Test</", component.Markup);
+        }
+
+        [Fact]
+        public void BreadCrumb_Renders_Icon()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenBreadCrumb>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(c => c.ChildContent, builder =>
+          {
+              builder.OpenComponent<RadzenBreadCrumbItem>(0);
+              builder.AddAttribute(1, nameof(RadzenBreadCrumbItem.Text), "Test");
+              builder.AddAttribute(2, nameof(RadzenBreadCrumbItem.Icon), "add");
+              builder.CloseComponent();
+          });
+            });
+
+            //@"<RadzenBreadCrumbItem Text=""Test"" />"
+            Assert.Contains("<i", component.Markup);
+            Assert.Contains(">add</i>", component.Markup);
+        }
+
+        [Fact]
+        public void BreadCrumb_Renders_Link()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenBreadCrumb>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(c => c.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenBreadCrumbItem>(0);
+                    builder.AddAttribute(1, nameof(RadzenBreadCrumbItem.Text), "Test");
+                    builder.AddAttribute(2, nameof(RadzenBreadCrumbItem.Icon), "add");
+                    builder.AddAttribute(3, nameof(RadzenBreadCrumbItem.Path), "/badge");
+                    builder.CloseComponent();
+                });
+            });
+
+            //@"<RadzenBreadCrumbItem Text=""Test"" />"
+            Assert.Contains("<i", component.Markup);
+            Assert.Contains(">add</i>", component.Markup);
+            Assert.Contains("<a href=\"/badge", component.Markup);
+        }
+    }
+}

Radzen.Blazor.Tests/ButtonTests.cs

@@ -30,7 +30,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, icon));
 
-            Assert.Contains(@$"<i class=""rz-button-icon-left rzi"">{icon}</i>", component.Markup);
+            Assert.Contains(@$"<i class=""notranslate rz-button-icon-left rzi"">{icon}</i>", component.Markup);
         }
 
         [Fact]
@@ -48,7 +48,7 @@ namespace Radzen.Blazor.Tests
             );
 
             // does not render the actual icon when busy
-            Assert.DoesNotContain(@$"<i class=""rz-button-icon-left rzi"">{icon}</i>", component.Markup);
+            Assert.DoesNotContain(@$"<i class=""notranslate rz-button-icon-left rzi"">{icon}</i>", component.Markup);
 
             // renders the icon with busy spin animation
             Assert.Contains(@"<i style=""animation: rotation", component.Markup);
@@ -71,7 +71,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add(p => p.Icon, icon);
             });
 
-            Assert.Contains(@$"<i class=""rz-button-icon-left rzi"">{icon}</i>", component.Markup);
+            Assert.Contains(@$"<i class=""notranslate rz-button-icon-left rzi"">{icon}</i>", component.Markup);
             Assert.Contains(@$"<span class=""rz-button-text"">{text}</span>", component.Markup);
         }
 
@@ -86,7 +86,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Image, image));
 
-            Assert.Contains(@$"<img class=""rz-button-icon-left rzi"" src=""{image}"" />", component.Markup);
+            Assert.Contains(@$"<img class=""notranslate rz-button-icon-left rzi"" src=""{image}"" alt=""button"" />", component.Markup);
         }
 
         [Fact]
@@ -103,9 +103,10 @@ namespace Radzen.Blazor.Tests
             {
                 parameters.Add(p => p.Text, text);
                 parameters.Add(p => p.Image, image);
+                parameters.Add(p => p.ImageAlternateText, text);
             });
 
-            Assert.Contains(@$"<img class=""rz-button-icon-left rzi"" src=""{image}"" />", component.Markup);
+            Assert.Contains(@$"<img class=""notranslate rz-button-icon-left rzi"" src=""{image}"" alt=""{text}"" />", component.Markup);
             Assert.Contains(@$"<span class=""rz-button-text"">{text}</span>", component.Markup);
         }
 
@@ -134,11 +135,11 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.ButtonStyle, ButtonStyle.Primary));
 
-            Assert.Contains(@$"btn-primary", component.Markup);
+            Assert.Contains(@$"rz-primary", component.Markup);
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.ButtonStyle, ButtonStyle.Secondary));
 
-            Assert.Contains(@$"btn-secondary", component.Markup);
+            Assert.Contains(@$"rz-secondary", component.Markup);
         }
 
         [Fact]

Radzen.Blazor.Tests/CardTests.cs

@@ -0,0 +1,46 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class CardTests
+    {
+        [Fact]
+        public void Card_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCard>();
+
+            Assert.Contains(@"rz-card", component.Markup);
+        }
+
+        [Fact]
+        public void Card_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCard>(parameters =>
+            {
+                parameters.AddChildContent("<div>Card Content</div>");
+            });
+
+            Assert.Contains("Card Content", component.Markup);
+        }
+
+        [Fact]
+        public void Card_Renders_Variant()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCard>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Outlined));
+            Assert.Contains("rz-variant-outlined", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Filled));
+            Assert.Contains("rz-variant-filled", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, Variant.Flat));
+            Assert.Contains("rz-variant-flat", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/CarouselTests.cs

@@ -0,0 +1,173 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class CarouselTests
+    {
+        [Fact]
+        public void Carousel_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>();
+
+            Assert.Contains(@"rz-carousel", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_AllowPaging_True()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide 1")));
+                    builder.CloseComponent();
+                    
+                    builder.OpenComponent<RadzenCarouselItem>(2);
+                    builder.AddAttribute(3, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide 2")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-carousel-pager-button", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_AllowPaging_False()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, false);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide 1")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.DoesNotContain("rz-carousel-pager-button", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_AllowNavigation_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.AllowNavigation, true);
+            });
+
+            Assert.Contains("rz-carousel-prev", component.Markup);
+            Assert.Contains("rz-carousel-next", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_AllowNavigation_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.AllowNavigation, false);
+            });
+
+            Assert.DoesNotContain("rz-carousel-prev", component.Markup);
+            Assert.DoesNotContain("rz-carousel-next", component.Markup);
+            Assert.Contains("rz-carousel-no-navigation", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerPosition_Top()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerPosition, PagerPosition.Top);
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-carousel-pager-top", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerPosition_Bottom()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerPosition, PagerPosition.Bottom);
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-carousel-pager-bottom", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerPosition_TopAndBottom()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerPosition, PagerPosition.TopAndBottom);
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenCarouselItem>(0);
+                    builder.AddAttribute(1, "ChildContent", (RenderFragment)(b => b.AddContent(0, "Slide")));
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("rz-carousel-pager-top", component.Markup);
+            Assert.Contains("rz-carousel-pager-bottom", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerOverlay_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerOverlay, true);
+            });
+
+            Assert.Contains("rz-carousel-pager-overlay", component.Markup);
+        }
+
+        [Fact]
+        public void Carousel_Renders_PagerOverlay_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCarousel>(parameters =>
+            {
+                parameters.Add(p => p.PagerOverlay, false);
+            });
+
+            Assert.DoesNotContain("rz-carousel-pager-overlay", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/ChartTests.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Bunit;
+using Microsoft.Extensions.DependencyInjection;
+using Radzen.Blazor.Rendering;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Radzen.Blazor.Tests;
+
+public class ChartTests
+{
+    private readonly ITestOutputHelper output;
+    public ChartTests(ITestOutputHelper output)
+    {
+        this.output = output;
+    }
+
+    [Fact(Timeout = 30000)]
+    public async Task Chart_Tooltip_Performance()
+    {
+        using var ctx = new TestContext();
+        ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+        ctx.JSInterop.Setup<Rect>("Radzen.createChart", _ => true).SetResult(new Rect {Left = 0, Top = 0, Width = 200, Height = 200});
+        ctx.Services.AddScoped<TooltipService>();
+        ctx.JSInterop.SetupVoid("Radzen.openChartTooltip", _ => true);
+        ctx.RenderComponent<RadzenChartTooltip>();
+
+        var seriesData = Enumerable.Range(0, 5000).Select(i => new Point { X = i, Y = i });
+        var chart = ctx.RenderComponent<RadzenChart>(chartParameters =>
+            chartParameters
+                .AddChildContent<RadzenLineSeries<Point>>(seriesParameters =>
+                    seriesParameters
+                        .Add(p => p.CategoryProperty, nameof(Point.X))
+                        .Add(p => p.ValueProperty, nameof(Point.Y))
+                        .Add(p => p.Data, seriesData))
+                .AddChildContent<RadzenCategoryAxis>(axisParameters =>
+                    axisParameters
+                        .Add(p => p.Step, 100)
+                        .Add(p => p.Formatter, x =>
+                        {
+                            Thread.Sleep(100);
+                            return $"{x}";
+                        })));
+
+        var stopwatch = Stopwatch.StartNew();
+        foreach (var invocation in Enumerable.Range(0, 10))
+        {
+            await chart.InvokeAsync(() => chart.Instance.MouseMove(100, 80));
+            Assert.Equal((invocation + 1) * 2, ctx.JSInterop.Invocations.Count(x => x.Identifier == "Radzen.openChartTooltip"));
+            await chart.InvokeAsync(() => chart.Instance.MouseMove(0, 0));
+            Assert.Equal(invocation + 1, ctx.JSInterop.Invocations.Count(x => x.Identifier == "Radzen.closeTooltip"));
+        }
+        output.WriteLine($"Time took: {stopwatch.Elapsed}");
+    }
+}

Radzen.Blazor.Tests/ChatTests.cs

@@ -0,0 +1,369 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
+using Radzen.Blazor;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ChatTests
+    {
+        [Fact]
+        public void RadzenChat_ShouldRenderWithTitle()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+            );
+
+            Assert.Contains("Test Chat", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowEmptyMessageWhenNoMessages()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.EmptyMessage, "No messages yet!")
+            );
+
+            Assert.Contains("No messages yet!", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldDisplayMessages()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Hello", UserId = "user1", Timestamp = DateTime.Now },
+                new ChatMessage { Content = "Hi there!", UserId = "user2", Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            Assert.Contains("Hello", component.Markup);
+            Assert.Contains("Hi there!", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowUsersInHeader()
+        {
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowUsers, true)
+            );
+
+            Assert.Contains("John", component.Markup);
+            Assert.Contains("Jane", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowUserNamesAboveMessages()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Hello", UserId = "user2", Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+                .Add(p => p.ShowUserNames, true)
+            );
+
+            Assert.Contains("Jane", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowClearButtonWhenEnabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowClearButton, true)
+            );
+
+            var clearButton = component.Find(".rz-chat-header-clear");
+            Assert.NotNull(clearButton);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldNotShowClearButtonWhenDisabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowClearButton, false)
+            );
+
+            var clearButton = component.FindAll(".rz-chat-header-clear");
+            Assert.Empty(clearButton);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldLimitVisibleUsers()
+        {
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" },
+                new ChatUser { Id = "user3", Name = "Bob" },
+                new ChatUser { Id = "user4", Name = "Alice" },
+                new ChatUser { Id = "user5", Name = "Charlie" },
+                new ChatUser { Id = "user6", Name = "David" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowUsers, true)
+                .Add(p => p.MaxVisibleUsers, 3)
+            );
+
+            // Should show "+3" for the remaining users
+            Assert.Contains("+3", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowUserMessagesOnRight()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "My message", UserId = "user1", Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            var userMessage = component.Find(".rz-chat-message-user");
+            Assert.NotNull(userMessage);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowUserMessagesOnLeft()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Other message", UserId = "user2", Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" },
+                new ChatUser { Id = "user2", Name = "Jane" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            var participantMessage = component.Find(".rz-chat-message-participant");
+            Assert.NotNull(participantMessage);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowAvatarInitials()
+        {
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John Doe" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowUsers, true)
+            );
+
+            Assert.Contains("JD", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowAvatarImageWhenProvided()
+        {
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John", AvatarUrl = "https://example.com/avatar.jpg" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ShowUsers, true)
+            );
+
+            var avatarImage = component.Find(".rz-chat-participant-image");
+            Assert.NotNull(avatarImage);
+            Assert.Equal("https://example.com/avatar.jpg", avatarImage.GetAttribute("src"));
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldBeDisabledWhenDisabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.Disabled, true)
+            );
+
+            var textarea = component.Find(".rz-chat-textarea");
+            Assert.True(textarea.HasAttribute("disabled"));
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldBeReadOnlyWhenReadOnly()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.ReadOnly, true)
+            );
+
+            var textarea = component.Find(".rz-chat-textarea");
+            Assert.True(textarea.HasAttribute("readonly"));
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowCustomPlaceholder()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, new List<ChatUser>())
+                .Add(p => p.Messages, new List<ChatMessage>())
+                .Add(p => p.Placeholder, "Custom placeholder")
+            );
+
+            var textarea = component.Find(".rz-chat-textarea");
+            Assert.Equal("Custom placeholder", textarea.GetAttribute("placeholder"));
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowStreamingIndicator()
+        {
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Streaming message", UserId = "user1", IsStreaming = true, Timestamp = DateTime.Now }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            var streamingIcon = component.Find(".rz-chat-message-streaming-icon");
+            Assert.NotNull(streamingIcon);
+        }
+
+        [Fact]
+        public void RadzenChat_ShouldShowMessageTimestamps()
+        {
+            var timestamp = DateTime.Now.AddHours(-1);
+            var messages = new List<ChatMessage>
+            {
+                new ChatMessage { Content = "Test message", UserId = "user1", Timestamp = timestamp }
+            };
+
+            var users = new List<ChatUser>
+            {
+                new ChatUser { Id = "user1", Name = "John" }
+            };
+
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenChat>(parameters => parameters
+                .Add(p => p.Title, "Test Chat")
+                .Add(p => p.CurrentUserId, "user1")
+                .Add(p => p.Users, users)
+                .Add(p => p.Messages, messages)
+            );
+
+            Assert.Contains(timestamp.ToString("HH:mm"), component.Markup);
+        }
+    }
+}

Radzen.Blazor.Tests/CheckBoxListTests.cs

@@ -0,0 +1,168 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Radzen.Blazor.Tests
+{
+    public class CheckBoxListTests
+    {
+        class Item
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+            public bool Disabled { get; set; }
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>();
+
+            Assert.Contains(@"rz-checkbox-list", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_WithData()
+        {
+            using var ctx = new TestContext();
+            var data = new List<string> { "Option 1", "Option 2", "Option 3" };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("Option 1", component.Markup);
+            Assert.Contains("Option 2", component.Markup);
+            Assert.Contains("Option 3", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_WithCustomTextValueProperties()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "First" },
+                new Item { Id = 2, Name = "Second" }
+            };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "Name");
+                parameters.Add(p => p.ValueProperty, "Id");
+            });
+
+            Assert.Contains("First", component.Markup);
+            Assert.Contains("Second", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_Orientation_Horizontal()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Horizontal);
+            });
+
+            Assert.Contains("rz-flex-row", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_Orientation_Vertical()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Vertical);
+            });
+
+            Assert.Contains("rz-flex-column", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_AllowSelectAll()
+        {
+            using var ctx = new TestContext();
+            var data = new List<string> { "Option 1", "Option 2" };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowSelectAll, true);
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-multiselect-header", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_SelectAllText()
+        {
+            using var ctx = new TestContext();
+            var data = new List<string> { "Option 1", "Option 2" };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowSelectAll, true);
+                parameters.Add(p => p.SelectAllText, "Select All Options");
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("Select All Options", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_CheckboxInputs()
+        {
+            using var ctx = new TestContext();
+            var data = new List<string> { "Option 1", "Option 2" };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("type=\"checkbox\"", component.Markup);
+            Assert.Contains("rz-chkbox", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBoxList_Renders_DisabledItems()
+        {
+            using var ctx = new TestContext();
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "Enabled", Disabled = false },
+                new Item { Id = 2, Name = "Disabled", Disabled = true }
+            };
+
+            var component = ctx.RenderComponent<RadzenCheckBoxList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "Name");
+                parameters.Add(p => p.ValueProperty, "Id");
+                parameters.Add(p => p.DisabledProperty, "Disabled");
+            });
+
+            Assert.Contains("Enabled", component.Markup);
+            Assert.Contains("Disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/CheckBoxTests.cs

@@ -160,5 +160,83 @@ namespace Radzen.Blazor.Tests
             Assert.Contains(@$"rz-state-active", component.Markup);
             Assert.Contains(@$"rzi-times", component.Markup);
         }
+
+        [Fact]
+        public void CheckBox_Renders_ReadonlyParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenCheckBox<bool>>();
+
+            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.ReadOnly, true));
+
+            Assert.Contains(@$"readonly", component.Markup);
+        }
+
+        [Fact]
+        public void CheckBox_DoesNotRaise_ChangedEvent_ReadonlyParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenCheckBox<bool>>();
+
+            var raised = false;
+
+            component.SetParametersAndRender(parameters => parameters
+              .Add<bool>(p => p.ReadOnly, true)
+              .Add(p => p.Change, args => { raised = true; })
+            );
+
+            component.Find("div.rz-chkbox-box").Click();
+
+            Assert.False(raised);
+        }
+
+        [Fact]
+        public void CheckBox_DoesNotRaise_ValueChangedEvent_ReadonlyParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenCheckBox<bool>>();
+
+            var raised = false;
+
+            component.SetParametersAndRender(parameters => parameters
+              .Add<bool>(p => p.ReadOnly, true)
+              .Add(p => p.ValueChanged, args => { raised = true; })
+            );
+
+            component.Find("div.rz-chkbox-box").Click();
+
+            Assert.False(raised);
+        }
+
+        [Fact]
+        public void CheckBox_ValueNotChanged_ReadonlyParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenCheckBox<bool>>();
+
+            var value = true;
+
+            component.SetParametersAndRender(parameters => parameters
+              .Add<bool>(p => p.ReadOnly, true)
+              .Add<bool>(p => p.Value, value)
+            );
+
+            component.Find("div.rz-chkbox-box").Click();
+
+            Assert.Contains(@$"rz-state-active", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters
+              .Add<bool>(p => p.ReadOnly, !true)
+              .Add<bool>(p => p.Value, value)
+            );
+
+            component.Find("div.rz-chkbox-box").Click();
+
+            Assert.DoesNotContain(@$"rz-state-active", component.Markup);
+        }
     }
 }

Radzen.Blazor.Tests/ColorPickerTests.cs

@@ -0,0 +1,16 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ColorPickerTests
+    {
+        [Fact]
+        public void ColorPicker_ShouldAcceptInvalidValues()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenColorPicker>(ComponentParameter.CreateParameter("Value", "invalid"));
+        }
+    }
+}

Radzen.Blazor.Tests/ColumnTests.cs

@@ -0,0 +1,74 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ColumnTests
+    {
+        [Fact]
+        public void Column_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            Assert.Contains(@"rz-col", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>(parameters =>
+            {
+                parameters.AddChildContent("<div>Column Content</div>");
+            });
+
+            Assert.Contains("Column Content", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_SizeParameter()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, 6));
+
+            Assert.Contains("rz-col-6", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_SizeMD()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.SizeMD, 4));
+
+            Assert.Contains("rz-col-md-4", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_SizeSM()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.SizeSM, 12));
+
+            Assert.Contains("rz-col-sm-12", component.Markup);
+        }
+
+        [Fact]
+        public void Column_Renders_Offset()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenColumn>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Offset, 2));
+
+            Assert.Contains("rz-offset-2", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/DataListTests.cs

@@ -29,7 +29,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AllowPaging, true));
 
-            Assert.Contains(@$"rz-paginator-bottom", component.Markup);
+            Assert.Contains(@$"rz-pager-bottom", component.Markup);
         }
 
         [Fact]
@@ -44,8 +44,8 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<PagerPosition>(p => p.PagerPosition, PagerPosition.Top); 
             });
 
-            Assert.Contains(@$"rz-paginator", component.Markup);
-            Assert.DoesNotContain(@$"rz-paginator-bottom", component.Markup);
+            Assert.Contains(@$"rz-pager", component.Markup);
+            Assert.DoesNotContain(@$"rz-pager-bottom", component.Markup);
         }
 
         [Fact]
@@ -60,8 +60,42 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<PagerPosition>(p => p.PagerPosition, PagerPosition.TopAndBottom);
             });
 
-            Assert.Contains(@$"rz-paginator", component.Markup);
-            Assert.Contains(@$"rz-paginator-bottom", component.Markup);
+            Assert.Contains(@$"rz-pager", component.Markup);
+            Assert.Contains(@$"rz-pager-bottom", component.Markup);
+        }
+
+        [Fact]
+        public void DataList_Renders_PagerDensityDefault()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenDataList<int>>(parameterBuilder => parameterBuilder.Add<IEnumerable<int>>(p => p.Data, Enumerable.Range(0, 100)));
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add<bool>(p => p.AllowPaging, true);
+                parameters.Add<PagerPosition>(p => p.PagerPosition, PagerPosition.Top);
+                parameters.Add<Density>(p => p.Density, Density.Default);
+            });
+
+            Assert.DoesNotContain(@$"rz-density-compact", component.Markup);
+        }
+
+        [Fact]
+        public void DataList_Renders_PagerDensityCompact()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenDataList<int>>(parameterBuilder => parameterBuilder.Add<IEnumerable<int>>(p => p.Data, Enumerable.Range(0, 100)));
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add<bool>(p => p.AllowPaging, true);
+                parameters.Add<PagerPosition>(p => p.PagerPosition, PagerPosition.Top);
+                parameters.Add<Density>(p => p.Density, Density.Compact);
+            });
+
+            Assert.Contains(@$"rz-density-compact", component.Markup);
         }
 
         [Fact]
@@ -93,7 +127,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; newArgs = args; });
             });
 
-            component.Find(".rz-paginator-next").Click();
+            component.Find(".rz-pager-next").Click();
 
             Assert.True(raised);
             Assert.True(newArgs.Skip == 10);
@@ -115,7 +149,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; newArgs = args; });
             });
 
-            component.Find(".rz-paginator-last").Click();
+            component.Find(".rz-pager-last").Click();
 
             Assert.True(raised);
             Assert.True(newArgs.Skip == 90);
@@ -137,8 +171,8 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; newArgs = args; });
             });
 
-            component.Find(".rz-paginator-next").Click();
-            component.Find(".rz-paginator-prev").Click();
+            component.Find(".rz-pager-next").Click();
+            component.Find(".rz-pager-prev").Click();
 
             Assert.True(raised);
             Assert.True(newArgs.Skip == 0);
@@ -160,8 +194,8 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; newArgs = args; });
             });
 
-            component.Find(".rz-paginator-next").Click();
-            component.Find(".rz-paginator-first").Click();
+            component.Find(".rz-pager-next").Click();
+            component.Find(".rz-pager-first").Click();
 
             Assert.True(raised);
             Assert.True(newArgs.Skip == 0);
@@ -182,7 +216,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; });
             });
 
-            component.Find(".rz-paginator-first").Click();
+            component.Find(".rz-pager-first").Click();
 
             Assert.False(raised);
         }
@@ -201,7 +235,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; });
             });
 
-            component.Find(".rz-paginator-prev").Click();
+            component.Find(".rz-pager-prev").Click();
 
             Assert.False(raised);
         }
@@ -219,13 +253,13 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<bool>(p => p.AllowPaging, true);
             });
 
-            component.Find(".rz-paginator-last").Click();
+            component.Find(".rz-pager-last").Click();
 
             component.SetParametersAndRender(parameters => {
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; });
             });
 
-            component.Find(".rz-paginator-last").Click();
+            component.Find(".rz-pager-last").Click();
 
             Assert.False(raised);
         }
@@ -243,13 +277,13 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<bool>(p => p.AllowPaging, true);
             });
 
-            component.Find(".rz-paginator-last").Click();
+            component.Find(".rz-pager-last").Click();
 
             component.SetParametersAndRender(parameters => {
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; });
             });
 
-            component.Find(".rz-paginator-next").Click();
+            component.Find(".rz-pager-next").Click();
 
             Assert.False(raised);
         }
@@ -270,7 +304,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<LoadDataArgs>(p => p.LoadData, args => { raised = true; newArgs = args; });
             });
 
-            component.Find(".rz-paginator-next").Click();
+            component.Find(".rz-pager-next").Click();
 
             Assert.True(raised);
             Assert.True(newArgs.Skip == 20);

Radzen.Blazor.Tests/DatePickerTests.cs

@@ -1,6 +1,7 @@
 using Bunit;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using Xunit;
 
@@ -17,10 +18,10 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
 
+            Assert.Contains(@$"rz-datepicker", component.Markup);
             Assert.Contains(@$"rz-calendar", component.Markup);
-            Assert.Contains(@$"rz-datepicker-group", component.Markup);
-            Assert.Contains(@$"rz-datepicker-header", component.Markup);
-            Assert.Contains(@$"rz-datepicker-calendar", component.Markup);
+            Assert.Contains(@$"rz-calendar-header", component.Markup);
+            Assert.Contains(@$"rz-calendar-view", component.Markup);
         }
 
         [Fact]
@@ -48,7 +49,8 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
 
-            component.SetParametersAndRender(parameters => { 
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add<bool>(p => p.ShowTime, true);
                 parameters.Add<bool>(p => p.ShowSeconds, true);
             });
@@ -68,7 +70,8 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add<bool>(p => p.ShowTime, true);
                 parameters.Add<bool>(p => p.ShowTimeOkButton, true);
             });
@@ -90,9 +93,10 @@ namespace Radzen.Blazor.Tests
 
             var format = "d";
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add(p => p.DateFormat, format);
-                parameters.Add<object>(p => p.Value, DateTime.Now); 
+                parameters.Add<object>(p => p.Value, DateTime.Now);
             });
 
             Assert.Contains(@$"value=""{string.Format("{0:" + format + "}", DateTime.Now)}""", component.Markup);
@@ -107,7 +111,8 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add<bool>(p => p.ShowTime, true);
                 parameters.Add(p => p.HourFormat, "12");
             });
@@ -126,12 +131,13 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add<bool>(p => p.ShowTime, true);
                 parameters.Add<bool>(p => p.TimeOnly, true);
             });
 
-            Assert.DoesNotContain(@$"rz-datepicker-header", component.Markup);
+            Assert.DoesNotContain(@$"rz-calendar-header", component.Markup);
         }
 
         [Fact]
@@ -143,12 +149,13 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add<object>(p => p.Value, DateTime.Now);
-                parameters.Add<bool>(p => p.AllowClear, true); 
+                parameters.Add<bool>(p => p.AllowClear, true);
             });
 
-            Assert.Contains(@$"<i class=""rz-dropdown-clear-icon rzi rzi-times""", component.Markup);
+            Assert.Contains(@$"<i class=""notranslate rz-dropdown-clear-icon rzi rzi-times""", component.Markup);
         }
 
         [Fact]
@@ -167,6 +174,34 @@ namespace Radzen.Blazor.Tests
             Assert.Contains(@$"tabindex=""{value}""", component.Markup);
         }
 
+        [Fact]
+        public void DatePicker_Renders_EmptyCssClass_WhenValueIsEmpty()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Value, null));
+
+            Assert.Contains(@$"rz-state-empty", component.Markup);
+        }
+
+        [Fact]
+        public void DatePicker_DoesNotRender_EmptyCssClass_WhenValueIsNotEmpty()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Value, DateTime.Now));
+
+            Assert.DoesNotContain(@$"rz-state-empty", component.Markup);
+        }
+
         [Fact]
         public void DatePicker_Renders_DisabledParameter()
         {
@@ -211,7 +246,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Style, value));
 
-            Assert.Contains(@$"style=""display: inline-block;{value}""", component.Markup);
+            Assert.Contains(@$"style=""{value}""", component.Markup);
         }
 
         [Fact]
@@ -240,11 +275,12 @@ namespace Radzen.Blazor.Tests
             var raised = false;
             object newValue = null;
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add(p => p.Change, args => { raised = true; newValue = args; });
             });
 
-            component.Find(".rz-datepicker-next-icon").Click();
+            component.Find(".rz-calendar-next-icon").Click();
 
             Assert.False(raised);
         }
@@ -261,11 +297,12 @@ namespace Radzen.Blazor.Tests
             var raised = false;
             object newValue = null;
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add(p => p.ValueChanged, args => { raised = true; newValue = args; });
             });
 
-            component.Find(".rz-datepicker-next-icon").Click();
+            component.Find(".rz-calendar-next-icon").Click();
 
             Assert.False(raised);
         }
@@ -282,11 +319,12 @@ namespace Radzen.Blazor.Tests
             var raised = false;
             object newValue = null;
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add(p => p.Change, args => { raised = true; newValue = args; });
             });
 
-            component.Find(".rz-datepicker-prev-icon").Click();
+            component.Find(".rz-calendar-prev-icon").Click();
 
             Assert.False(raised);
         }
@@ -303,11 +341,12 @@ namespace Radzen.Blazor.Tests
             var raised = false;
             object newValue = null;
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add(p => p.ValueChanged, args => { raised = true; newValue = args; });
             });
 
-            component.Find(".rz-datepicker-prev-icon").Click();
+            component.Find(".rz-calendar-prev-icon").Click();
 
             Assert.False(raised);
         }
@@ -319,14 +358,15 @@ namespace Radzen.Blazor.Tests
             DateTime previousDay = DateTime.Today.AddDays(-1);
 
             using var ctx = new TestContext();
-            ctx.JSInterop.Mode = JSRuntimeMode.Loose;            
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
 
             var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
-            
-            var raised = false;
-            object newValue = null;            
 
-            component.SetParametersAndRender(parameters => {
+            var raised = false;
+            object newValue = null;
+
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add(p => p.ValueChanged, args => { raised = true; newValue = args; })
                           .Add(p => p.DateRender, args => { args.Disabled = dates.Contains(args.Date); });
             });
@@ -359,7 +399,8 @@ namespace Radzen.Blazor.Tests
             var raised = false;
             object newValue = null;
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add(p => p.ValueChanged, args => { raised = true; newValue = args; })
                           .Add(p => p.DateRender, args => { args.Disabled = dates.Contains(args.Date); });
             });
@@ -377,14 +418,80 @@ namespace Radzen.Blazor.Tests
             Assert.True(raised);
             Assert.Null(newValue);
         }
-        
+
+        [Fact]
+        public void DatePicker_Parses_Input_Using_DateFormat()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime?>>();
+
+            var raised = false;
+            object newValue = null;
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.DateFormat, "ddMM");
+                parameters.Add(p => p.ValueChanged, args => { raised = true; newValue = args; });
+            });
+
+            var inputElement = component.Find(".rz-inputtext");
+
+            string input = "3012";
+            ctx.JSInterop.Setup<string>("Radzen.getInputValue", invocation => true).SetResult(input);
+            inputElement.Change(input);
+
+            Assert.True(raised);
+            Assert.Equal(new DateTime(DateTime.Now.Year, 12, 30), newValue);
+        }
+
+
+        [Fact]
+        public void DatePicker_Parses_Input_Using_ParseInput()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime?>>();
+
+            Func<string, DateTime?> customParseInput = (input) =>
+            {
+                if (DateTime.TryParseExact(input, "ddMM", null, DateTimeStyles.None, out var result))
+                {
+                    return result;
+                }
+
+                return null;
+            };
+
+            var raised = false;
+            object newValue = null;
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.ParseInput, customParseInput);
+                parameters.Add(p => p.ValueChanged, args => { raised = true; newValue = args; });
+            });
+
+            var inputElement = component.Find(".rz-inputtext");
+
+            string input = "3012";
+            ctx.JSInterop.Setup<string>("Radzen.getInputValue", invocation => true).SetResult(input);
+            inputElement.Change(input);
+
+            Assert.True(raised);
+            Assert.Equal(new DateTime(DateTime.Now.Year, 12, 30), newValue);
+        }
+
+
         [Fact]
         public void DatePicker_Respects_DateTimeMaxValue()
         {
             using var ctx = new TestContext();
             ctx.JSInterop.Mode = JSRuntimeMode.Loose;
             ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
-            
+
             var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>(parameters =>
             {
                 parameters.Add(p => p.Value, DateTime.MaxValue);
@@ -392,26 +499,7 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains(DateTime.MaxValue.ToString(component.Instance.DateFormat), component.Markup);
 
-            var exception = Record.Exception(() => component.Find(".rz-datepicker-next-icon")
-                                                            .Click());
-            Assert.Null(exception);
-        }
-
-        [Fact]
-        public void DatePicker_Respects_DateTimeMinValue()
-        {
-            using var ctx = new TestContext();
-            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
-            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
-
-            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>(parameters =>
-            {
-                parameters.Add(p => p.Value, DateTime.MinValue);
-            });
-
-            Assert.Contains(DateTime.MinValue.ToString(component.Instance.DateFormat), component.Markup);
-
-            var exception = Record.Exception(() => component.Find(".rz-datepicker-prev-icon")
+            var exception = Record.Exception(() => component.Find(".rz-calendar-next-icon")
                                                             .Click());
             Assert.Null(exception);
         }
@@ -440,7 +528,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add(p => p.Change, args => { raised = true; newValue = args; });
             });
 
-            component.Find(".rz-datepicker-next-icon").Click();
+            component.Find(".rz-calendar-next-icon").Click();
             component.FindAll(".rz-button-text").First(x => x.TextContent == "Ok").Click();
 
             Assert.True(raised);
@@ -464,5 +552,310 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains(actionsTemplate, component.Markup);
         }
+
+        [Fact]
+        public void DatePicker_Converts_DateTimeOffSet_FromUtc_ToLocal()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var valueUtc = DateTimeOffset.UtcNow;
+            var kind = DateTimeKind.Local;
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTimeOffset>>(parameters =>
+            {
+                parameters.Add(p => p.Kind, kind);
+                parameters.Add(p => p.Value, valueUtc);
+            });
+
+            Assert.Equal(kind, (component.Instance.Value as DateTime?)?.Kind);
+            Assert.Equal(valueUtc.LocalDateTime.ToString(CultureInfo.InvariantCulture), (component.Instance.Value as DateTime?)?.ToString(CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void DatePicker_Converts_DateTimeOffSet_Local_ToUtc()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var valueUtc = DateTimeOffset.Now;
+            var kind = DateTimeKind.Utc;
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTimeOffset>>(parameters =>
+            {
+                parameters.Add(p => p.Kind, kind);
+                parameters.Add(p => p.Value, valueUtc);
+            });
+
+            Assert.Equal(kind, (component.Instance.Value as DateTime?)?.Kind);
+            Assert.Equal(valueUtc.UtcDateTime.ToString(CultureInfo.InvariantCulture), (component.Instance.Value as DateTime?)?.ToString(CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void DatePicker_Displays_Calender_Icon()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>();
+
+            Assert.Contains(@$"rzi-calendar", component.Markup);
+        }
+
+        [Fact]
+        public void DatePicker_Displays_Schedule_Icon()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>(parameters =>
+            {
+                parameters.Add(p => p.TimeOnly, true);
+            });
+
+            Assert.Contains(@$"rzi-time", component.Markup);
+        }
+
+        [Fact]
+        public void DatePicker_Supports_DateOnly()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            DateOnly? dateOnly = new DateOnly(2024, 1, 31);
+            DateOnly? valueChangedValue = null!;
+            var component = ctx.RenderComponent<RadzenDatePicker<DateOnly?>>(parameters =>
+            {
+                parameters.Add(p => p.Value, dateOnly);
+                parameters.Add(p => p.ValueChanged, args => { valueChangedValue = args; });
+            });
+
+            Assert.False(component.Instance.ShowTime);
+            var input = component.Find("input");
+            input.GetAttribute("value").MarkupMatches(dateOnly.ToString());
+
+            // update to new value
+            var inputElement = component.Find(".rz-inputtext");
+            DateOnly? enteredValue = new DateOnly(2024, 2, 28);
+            ctx.JSInterop.Setup<string>("Radzen.getInputValue", invocation => true).SetResult(enteredValue.Value.ToShortDateString());
+            inputElement.Change(enteredValue);
+
+            input.GetAttribute("value").MarkupMatches(enteredValue.ToString());
+            Assert.Equal(enteredValue, component.Instance.Value);
+            Assert.Equal(enteredValue, valueChangedValue);
+        }
+
+        [Fact]
+        public void DatePicker_Supports_TimeOnly()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            TimeOnly? timeOnly = new TimeOnly(23, 59, 59);
+            TimeOnly? valueChangedValue = null!;
+            var component = ctx.RenderComponent<RadzenDatePicker<TimeOnly>>(parameters =>
+            {
+                parameters.Add(p => p.Value, timeOnly);
+                parameters.Add(p => p.ValueChanged, args => { valueChangedValue = args; });
+            });
+
+            Assert.True(component.Instance.TimeOnly);
+            Assert.True(component.Instance.ShowTime);
+            var input = component.Find("input");
+            input.GetAttribute("value").MarkupMatches(timeOnly.ToString());
+
+            // update to new value
+            var inputElement = component.Find(".rz-inputtext");
+            TimeOnly? enteredValue = new TimeOnly(1, 4, 5);
+            ctx.JSInterop.Setup<string>("Radzen.getInputValue", invocation => true).SetResult(enteredValue.Value.ToLongTimeString());
+            inputElement.Change(enteredValue);
+
+            input.GetAttribute("value").MarkupMatches(enteredValue.ToString());
+            Assert.Equal(enteredValue, component.Instance.Value);
+            Assert.Equal(enteredValue, valueChangedValue);
+        }
+
+        [Fact]
+        public void DatePicker_ShowCalendarWeek_WeekNumberAddedInAdditionalColumn()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>(parameter =>
+            {
+                parameter.Add(p => p.ShowCalendarWeek, true);
+            });
+
+            Assert.Contains(@$"rz-calendar-week-number", component.Markup);
+            Assert.Equal(8, component.FindAll(".rz-calendar-view th").Count());
+            // check header and week number column
+            Assert.Single(component.FindAll("th.rz-datepicker-week-number"));
+            Assert.Equal(6, component.FindAll("td.rz-calendar-week-number").Count());
+        }
+
+        [Fact]
+        public void DatePicker_ShowCalendarWeekFalse_NoAdditionalColumn()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>(parameter =>
+            {
+                parameter.Add(p => p.ShowCalendarWeek, false);
+            });
+
+            Assert.DoesNotContain(@$"rz-calendar-week-number", component.Markup);
+            Assert.Equal(7, component.FindAll(".rz-calendar-view th").Count());
+        }
+
+        [Fact]
+        public void DatePicker_ShowCalendarWeekWithCustomTitle_TitleCorrectlyRendered()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>(parameter =>
+            {
+                parameter.Add(p => p.ShowCalendarWeek, true);
+                parameter.Add(p => p.CalendarWeekTitle, "Wk");
+            });
+
+            var weekNumberHeader = component.Find(".rz-calendar-view th.rz-datepicker-week-number");
+            Assert.Contains("Wk", weekNumberHeader.InnerHtml);
+        }
+
+        [Fact]
+        public void DatePicker_Multiple_Selects_IEnumerableDateTime()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            IEnumerable<DateTime> emitted = null;
+            var initial = new DateTime(2024, 1, 1);
+
+            var component = ctx.RenderComponent<RadzenDatePicker<IEnumerable<DateTime>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.ValueChanged, args => { emitted = args; });
+            });
+
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "10").ParentElement.Click());
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "12").ParentElement.Click());
+
+            Assert.NotNull(emitted);
+            var list = emitted.ToList();
+            Assert.Equal(2, list.Count);
+            Assert.Contains(new DateTime(2024, 1, 10), list.Select(d => d.Date));
+            Assert.Contains(new DateTime(2024, 1, 12), list.Select(d => d.Date));
+        }
+
+        [Fact]
+        public void DatePicker_Multiple_Selects_IEnumerableNullableDateTime()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            IEnumerable<DateTime?> emitted = null;
+            var initial = new DateTime(2024, 2, 1);
+
+            var component = ctx.RenderComponent<RadzenDatePicker<IEnumerable<DateTime?>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.ValueChanged, args => { emitted = args; });
+            });
+
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "3").ParentElement.Click());
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "14").ParentElement.Click());
+
+            Assert.NotNull(emitted);
+            var list = emitted.ToList();
+            Assert.Equal(2, list.Count);
+            Assert.Contains(new DateTime(2024, 2, 3), list.Select(d => d.Value.Date));
+            Assert.Contains(new DateTime(2024, 2, 14), list.Select(d => d.Value.Date));
+        }
+
+        [Fact]
+        public void DatePicker_Multiple_Emits_IEnumerableDateTimeOffsetNullable_WithUtcKind()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            IEnumerable<DateTimeOffset?> emitted = null;
+            var initial = new DateTime(2024, 3, 1);
+
+            var component = ctx.RenderComponent<RadzenDatePicker<IEnumerable<DateTimeOffset?>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.Kind, DateTimeKind.Utc);
+                parameters.Add(p => p.ValueChanged, args => { emitted = args; });
+            });
+
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "5").ParentElement.Click());
+            component.InvokeAsync(() => component.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "20").ParentElement.Click());
+
+            Assert.NotNull(emitted);
+            var list = emitted.ToList();
+            Assert.Equal(2, list.Count);
+            Assert.All(list, dto => Assert.Equal(TimeSpan.Zero, dto.Value.Offset));
+        }
+
+        [Fact]
+        public void DatePicker_Multiple_Emits_IEnumerableDateOnlyAndTimeOnlyNullable()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            IEnumerable<DateOnly?> emittedDates = null;
+            IEnumerable<TimeOnly?> emittedTimes = null;
+            var initial = new DateTime(2024, 4, 1);
+
+            var compDates = ctx.RenderComponent<RadzenDatePicker<IEnumerable<DateOnly?>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.ValueChanged, args => { emittedDates = args; });
+            });
+
+            compDates.InvokeAsync(() => compDates.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "7").ParentElement.Click());
+            compDates.InvokeAsync(() => compDates.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "9").ParentElement.Click());
+
+            Assert.NotNull(emittedDates);
+            var dateList = emittedDates.ToList();
+            Assert.Equal(2, dateList.Count);
+            Assert.Contains(new DateOnly(2024, 4, 7), dateList.Select(d => d.Value));
+            Assert.Contains(new DateOnly(2024, 4, 9), dateList.Select(d => d.Value));
+
+            // TimeOnly? emission should produce midnight times for selected dates
+            var compTimes = ctx.RenderComponent<RadzenDatePicker<IEnumerable<TimeOnly?>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.InitialViewDate, initial);
+                parameters.Add(p => p.ValueChanged, args => { emittedTimes = args; });
+            });
+
+            compTimes.InvokeAsync(() => compTimes.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "1").ParentElement.Click());
+            compTimes.InvokeAsync(() => compTimes.FindAll("td:not(.rz-calendar-other-month) span").First(e => e.TextContent == "2").ParentElement.Click());
+
+            Assert.NotNull(emittedTimes);
+            var timeList = emittedTimes.ToList();
+            Assert.Equal(2, timeList.Count);
+            Assert.All(timeList, t => Assert.Equal(new TimeOnly(0, 0, 0), t.Value));
+        }
     }
 }

Radzen.Blazor.Tests/DialogServiceTests.cs

@@ -0,0 +1,341 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+	public class DialogServiceTests
+	{
+		public class OpenDialogTests
+		{
+			[Fact(DisplayName = "DialogOptions default values are set correctly")]
+			public void DialogOptions_DefaultValues_AreSetCorrectly()
+			{
+				// Arrange
+				var options = new DialogOptions();
+				var dialogService = new DialogService(null, null);
+
+				// Act
+				dialogService.OpenDialog<DialogServiceTests>("Test", [], options);
+
+				// Assert
+				Assert.Equal("600px", options.Width);
+				Assert.Equal("", options.Left);
+				Assert.Equal("", options.Top);
+				Assert.Equal("", options.Bottom);
+				Assert.Equal("", options.Height);
+				Assert.Equal("", options.Style);
+				Assert.Equal("", options.CssClass);
+				Assert.Equal("", options.WrapperCssClass);
+				Assert.Equal("", options.ContentCssClass);
+			}
+
+			[Fact(DisplayName = "DialogOptions values are retained after OpenDialog call")]
+			public void DialogOptions_Values_AreRetained_AfterOpenDialogCall()
+			{
+				// Arrange
+				var options = new DialogOptions
+				{
+					Width = "800px",
+					Left = "10px",
+					Top = "20px",
+					Bottom = "30px",
+					Height = "400px",
+					Style = "background-color: red;",
+					CssClass = "custom-class",
+					WrapperCssClass = "wrapper-class",
+					ContentCssClass = "content-class"
+				};
+				var dialogService = new DialogService(null, null);
+
+				// Act
+				dialogService.OpenDialog<DialogServiceTests>("Test", [], options);
+
+				// Assert
+				Assert.Equal("800px", options.Width);
+				Assert.Equal("10px", options.Left);
+				Assert.Equal("20px", options.Top);
+				Assert.Equal("30px", options.Bottom);
+				Assert.Equal("400px", options.Height);
+				Assert.Equal("background-color: red;", options.Style);
+				Assert.Equal("custom-class", options.CssClass);
+				Assert.Equal("wrapper-class", options.WrapperCssClass);
+				Assert.Equal("content-class", options.ContentCssClass);
+			}
+
+			[Fact(DisplayName = "DialogOptions is null and default values are set correctly")]
+			public void DialogOptions_IsNull_DefaultValues_AreSetCorrectly()
+			{
+				// Arrange
+				DialogOptions resultingOptions = null;
+				var dialogService = new DialogService(null, null);
+				dialogService.OnOpen += (title, type, parameters, options) => resultingOptions = options;
+
+				// Act
+				dialogService.OpenDialog<DialogServiceTests>("Test", [], null);
+
+				// Assert
+				Assert.NotNull(resultingOptions);
+				Assert.Equal("600px", resultingOptions.Width);
+				Assert.Equal("", resultingOptions.Left);
+				Assert.Equal("", resultingOptions.Top);
+				Assert.Equal("", resultingOptions.Bottom);
+				Assert.Equal("", resultingOptions.Height);
+				Assert.Equal("", resultingOptions.Style);
+				Assert.Equal("", resultingOptions.CssClass);
+				Assert.Equal("", resultingOptions.WrapperCssClass);
+				Assert.Equal("", resultingOptions.ContentCssClass);
+			}
+
+            [Fact(DisplayName = "Open with dynamic component type reflective calls are resolved without exception")]
+            public void Open_DynamicComponentType_Reflective_Calls_Resolve()
+            {
+                // Arrange
+                string resultingTitle = null;
+                Type resultingType = null;
+                var dialogService = new DialogService(null, null);
+                dialogService.OnOpen += (title, type, _, _) =>
+                {
+                    resultingTitle = title;
+                    resultingType = type;
+                };
+                
+                dialogService.Open("Dynamic Open", typeof(RadzenButton), []);
+                
+                // Assert
+                Assert.Equal("Dynamic Open", resultingTitle);
+                Assert.Equal(typeof(RadzenButton), resultingType);
+            }
+            
+            [Fact(DisplayName = "OpenAsync with dynamic component type reflective calls are resolved without exception")]
+            public async Task OpenAsync_DynamicComponentType_Reflective_Calls_Resolve()
+            {
+                // Arrange
+                string resultingTitle = null;
+                Type resultingType = null;
+                var dialogService = new DialogService(null, null);
+                dialogService.OnOpen += (title, type, _, _) =>
+                {
+                    resultingTitle = title;
+                    resultingType = type;
+                };
+
+                var openTask = dialogService.OpenAsync("Dynamic Open", typeof(RadzenButton), []);
+                dialogService.Close();
+                await openTask;
+                
+                // Assert
+                Assert.Equal("Dynamic Open", resultingTitle);
+                Assert.Equal(typeof(RadzenButton), resultingType);
+            }
+		}
+
+		public class ConfirmTests
+		{
+			[Fact(DisplayName = "ConfirmOptions is null and default values are set correctly")]
+			public async Task ConfirmOptions_IsNull_AreSetCorrectly()
+			{
+				// Arrange
+				var dialogService = new DialogService(null, null);
+				ConfirmOptions resultingOptions = null;
+				dialogService.OnOpen += (title, type, parameters, options) => resultingOptions = options as ConfirmOptions;
+
+				using var cancellationTokenSource = new CancellationTokenSource();
+				cancellationTokenSource.Cancel();
+
+				// Act
+				try
+				{
+					await dialogService.Confirm(cancellationToken: cancellationTokenSource.Token);
+				}
+				catch (TaskCanceledException)
+				{
+					// this is expected
+				}
+
+				// Assert
+				Assert.NotNull(resultingOptions);
+                Assert.Equal("Ok", resultingOptions.OkButtonText);
+                Assert.Equal("Cancel", resultingOptions.CancelButtonText);
+                Assert.Equal("600px", resultingOptions.Width);
+				Assert.Equal("", resultingOptions.Style);
+				Assert.Equal("rz-dialog-confirm", resultingOptions.CssClass);
+				Assert.Equal("rz-dialog-wrapper", resultingOptions.WrapperCssClass);
+			}
+
+			[Fact(DisplayName = "ConfirmOptions default values are set correctly")]
+			public async Task ConfirmOptions_DefaultValues_AreSetCorrectly()
+			{
+				// Arrange
+				var dialogService = new DialogService(null, null);
+				ConfirmOptions resultingOptions = null;
+				dialogService.OnOpen += (title, type, parameters, options) => resultingOptions = options as ConfirmOptions;
+
+				using var cancellationTokenSource = new CancellationTokenSource();
+				cancellationTokenSource.Cancel();
+
+				// Act
+				try
+				{
+					await dialogService.Confirm(options: new(), cancellationToken: cancellationTokenSource.Token);
+				}
+				catch (TaskCanceledException)
+				{
+					// this is expected
+				}
+
+				// Assert
+				Assert.NotNull(resultingOptions);
+                Assert.Equal("Ok", resultingOptions.OkButtonText);
+                Assert.Equal("Cancel", resultingOptions.CancelButtonText);
+                Assert.Equal("600px", resultingOptions.Width);
+				Assert.Equal("", resultingOptions.Style);
+				Assert.Equal("rz-dialog-confirm", resultingOptions.CssClass);
+				Assert.Equal("rz-dialog-wrapper", resultingOptions.WrapperCssClass);
+			}
+			[Fact(DisplayName = "ConfirmOptions values are retained after Confirm call")]
+			public async Task Confirm_ProvidedValues_AreRetained()
+			{
+				// Arrange
+				var dialogService = new DialogService(null, null);
+				var options = new ConfirmOptions
+				{
+                    OkButtonText = "XXX",
+                    CancelButtonText = "YYY",
+                    Width = "800px",
+					Style = "background-color: red;",
+					CssClass = "custom-class",
+					WrapperCssClass = "wrapper-class"
+				};
+				ConfirmOptions resultingOptions = null;
+				dialogService.OnOpen += (title, type, parameters, options) => resultingOptions = options as ConfirmOptions;
+
+				// We break out of the dialog immediately, but the options should still be set
+				using var cancellationTokenSource = new CancellationTokenSource();
+				cancellationTokenSource.Cancel();
+
+				// Act
+				try
+				{
+					await dialogService.Confirm("Confirm?", "Confirm", options, cancellationToken: cancellationTokenSource.Token);
+				}
+				catch (TaskCanceledException)
+				{
+					// this is expected
+				}
+
+				// Assert
+				Assert.NotNull(resultingOptions);
+                Assert.Equal("XXX", resultingOptions.OkButtonText);
+                Assert.Equal("YYY", resultingOptions.CancelButtonText);
+                Assert.Equal("800px", resultingOptions.Width);
+				Assert.Equal("background-color: red;", resultingOptions.Style);
+				Assert.Equal("rz-dialog-confirm custom-class", resultingOptions.CssClass);
+				Assert.Equal("rz-dialog-wrapper wrapper-class", resultingOptions.WrapperCssClass);
+			}
+
+		}
+
+		public class AlertTests
+		{
+			[Fact(DisplayName = "AlertOptions is null and default values are set correctly")]
+			public async Task AlertOptions_IsNull_AreSetCorrectly()
+			{
+				// Arrange
+				var dialogService = new DialogService(null, null);
+				AlertOptions resultingOptions = null;
+				dialogService.OnOpen += (title, type, parameters, options) => resultingOptions = options as AlertOptions;
+
+				using var cancellationTokenSource = new CancellationTokenSource();
+				cancellationTokenSource.Cancel();
+
+				// Act
+				try
+				{
+					await dialogService.Alert(cancellationToken: cancellationTokenSource.Token);
+				}
+				catch (TaskCanceledException)
+				{
+					// this is expected
+				}
+
+				// Assert
+				Assert.NotNull(resultingOptions);
+                Assert.Equal("Ok", resultingOptions.OkButtonText);
+				Assert.Equal("600px", resultingOptions.Width);
+				Assert.Equal("", resultingOptions.Style);
+				Assert.Equal("rz-dialog-alert", resultingOptions.CssClass);
+				Assert.Equal("rz-dialog-wrapper", resultingOptions.WrapperCssClass);
+			}
+
+			[Fact(DisplayName = "AlertOptions default values are set correctly")]
+			public async Task AlertOptions_DefaultValues_AreSetCorrectly()
+			{
+				// Arrange
+				var dialogService = new DialogService(null, null);
+				AlertOptions resultingOptions = null;
+				dialogService.OnOpen += (title, type, parameters, options) => resultingOptions = options as AlertOptions;
+
+				using var cancellationTokenSource = new CancellationTokenSource();
+				cancellationTokenSource.Cancel();
+
+				// Act
+				try
+				{
+					await dialogService.Alert(options: new(), cancellationToken: cancellationTokenSource.Token);
+				}
+				catch (TaskCanceledException)
+				{
+					// this is expected
+				}
+
+				// Assert
+				Assert.NotNull(resultingOptions);
+                Assert.Equal("Ok", resultingOptions.OkButtonText);
+				Assert.Equal("600px", resultingOptions.Width);
+				Assert.Equal("", resultingOptions.Style);
+				Assert.Equal("rz-dialog-alert", resultingOptions.CssClass);
+				Assert.Equal("rz-dialog-wrapper", resultingOptions.WrapperCssClass);
+			}
+			[Fact(DisplayName = "AlertOptions values are retained after Alert call")]
+			public async Task Alert_ProvidedValues_AreRetained()
+			{
+				// Arrange
+				var dialogService = new DialogService(null, null);
+				var options = new AlertOptions
+				{
+                    OkButtonText = "XXX",
+					Width = "800px",
+					Style = "background-color: red;",
+					CssClass = "custom-class",
+					WrapperCssClass = "wrapper-class"
+				};
+				AlertOptions resultingOptions = null;
+				dialogService.OnOpen += (title, type, parameters, options) => resultingOptions = options as AlertOptions;
+
+				// We break out of the dialog immediately, but the options should still be set
+				using var cancellationTokenSource = new CancellationTokenSource();
+				cancellationTokenSource.Cancel();
+
+				// Act
+				try
+				{
+					await dialogService.Alert("Alert?", "Alert", options, cancellationToken: cancellationTokenSource.Token);
+				}
+				catch (TaskCanceledException)
+				{
+					// this is expected
+				}
+
+				// Assert
+				Assert.NotNull(resultingOptions);
+				Assert.Equal("XXX", resultingOptions.OkButtonText);
+				Assert.Equal("800px", resultingOptions.Width);
+				Assert.Equal("background-color: red;", resultingOptions.Style);
+				Assert.Equal("rz-dialog-alert custom-class", resultingOptions.CssClass);
+				Assert.Equal("rz-dialog-wrapper wrapper-class", resultingOptions.WrapperCssClass);
+			}
+		}
+	}
+}

Radzen.Blazor.Tests/Dollars.cs

@@ -0,0 +1,58 @@
+using System;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace Radzen.Blazor.Tests;
+
+[TypeConverter(typeof(DollarsTypeConverter))]
+public readonly record struct Dollars(decimal Amount) : IComparable<decimal>
+{
+    public int CompareTo(decimal other)
+    {
+        return Amount.CompareTo(other);
+    }
+
+    public string ToString(string format, CultureInfo culture = null) => Amount.ToString(format, culture ?? CultureInfo.CreateSpecificCulture("en-US"));
+    public override string ToString() => Amount.ToString("F2", CultureInfo.CreateSpecificCulture("en-US"));
+}
+
+public class DollarsTypeConverter : TypeConverter
+{
+    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+    {
+        if (sourceType == typeof(decimal) ||
+            sourceType == typeof(string)) 
+        {
+            return true;
+        }
+
+        return base.CanConvertFrom(context, sourceType);
+    }
+
+    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+    {
+        if (destinationType == typeof(decimal))
+            return true;
+        
+        return base.CanConvertTo(context, destinationType);
+    }
+
+    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+    {
+        if (value is decimal d)
+            return new Dollars(d);
+
+        if (value is string s)
+            return decimal.TryParse(s, culture, out var val) ? new Dollars(val) : null;
+        
+        return base.ConvertFrom(context, culture, value);
+    }
+
+    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+    {
+        if (destinationType == typeof(decimal) && value is Dollars d)
+            return d.Amount;
+        
+        return base.ConvertTo(context, culture, value, destinationType);
+    }
+}

Radzen.Blazor.Tests/DropDownDataGridTests.cs

@@ -0,0 +1,289 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Radzen.Blazor.Tests
+{
+    public class DropDownDataGridTests
+    {
+        class Customer
+        {
+            public int Id { get; set; }
+            public string CompanyName { get; set; }
+            public string ContactName { get; set; }
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>();
+
+            Assert.Contains(@"rz-dropdown", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_DropdownTrigger()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>();
+
+            Assert.Contains("rz-dropdown-trigger", component.Markup);
+            Assert.Contains("rzi-chevron-down", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_WithData()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2", "Item3" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-lookup-panel", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_WithCustomTextValueProperties()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Customer>
+            {
+                new Customer { Id = 1, CompanyName = "Acme Corp", ContactName = "John Doe" },
+                new Customer { Id = 2, CompanyName = "Tech Inc", ContactName = "Jane Smith" }
+            };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "CompanyName");
+                parameters.Add(p => p.ValueProperty, "Id");
+            });
+
+            Assert.Contains("rz-lookup-panel", component.Markup);
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_DataGrid()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            // DropDownDataGrid embeds a DataGrid
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_AllowFiltering()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-lookup-search", component.Markup);
+            Assert.Contains("rz-lookup-search-input", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_Placeholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>(parameters =>
+            {
+                parameters.Add(p => p.Placeholder, "Select an item");
+            });
+
+            Assert.Contains("Select an item", component.Markup);
+            Assert.Contains("rz-placeholder", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_AllowClear_WithValue()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowClear, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.Value, "Item1");
+            });
+
+            Assert.Contains("rz-dropdown-clear-icon", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_DoesNotRender_AllowClear_WhenNotAllowed()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowClear, false);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.Value, "Item1");
+            });
+
+            Assert.DoesNotContain("rz-dropdown-clear-icon", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_Multiple_Panel()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<IEnumerable<int>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+            });
+
+            Assert.Contains("rz-multiselect-panel", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_Multiple_WithChips()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2" };
+            var selectedItems = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<IEnumerable<string>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Chips, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.Value, selectedItems);
+            });
+
+            Assert.Contains("rz-dropdown-chips-wrapper", component.Markup);
+            Assert.Contains("rz-chip", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_AllowSorting()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Customer>
+            {
+                new Customer { Id = 1, CompanyName = "Acme" }
+            };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowSorting, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "CompanyName");
+            });
+
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_SearchTextPlaceholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.SearchTextPlaceholder, "Type to filter...");
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("placeholder=\"Type to filter...\"", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_EmptyText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, new List<string>());
+                parameters.Add(p => p.EmptyText, "No items found");
+            });
+
+            Assert.Contains("No items found", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_PageSize()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = Enumerable.Range(1, 20).Select(i => $"Item {i}").ToList();
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.PageSize, 10);
+            });
+
+            // DataGrid with paging should be present
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+
+        [Fact]
+        public void DropDownDataGrid_Renders_AllowRowSelectOnRowClick()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2" };
+
+            var component = ctx.RenderComponent<RadzenDropDownDataGrid<string>>(parameters =>
+            {
+                parameters.Add(p => p.AllowRowSelectOnRowClick, true);
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-data-grid", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/DropDownTests.cs

@@ -0,0 +1,743 @@
+using AngleSharp.Dom;
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class DropDownTests
+    {
+        class DataItem
+        {
+            public string Text { get; set; }
+            public int Id { get; set; }
+            public bool Disabled { get; set; }
+        }
+
+        private static IRenderedComponent<RadzenDropDown<T>> DropDown<T>(TestContext ctx, Action<ComponentParameterCollectionBuilder<RadzenDropDown<T>>> configure = null)
+        {
+            var data = new[] {
+                new DataItem { Text = "Item 1", Id = 1 },
+                new DataItem { Text = "Item 2", Id = 2 },
+            };
+
+            var component = ctx.RenderComponent<RadzenDropDown<T>>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, nameof(DataItem.Text));
+
+                if (configure != null)
+                {
+                    configure.Invoke(parameters);
+                }
+                else
+                {
+                    parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+                }
+            });
+
+            return component;
+        }
+
+
+        [Fact]
+        public async Task Dropdown_SelectItem_Method_Should_Not_Throw()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = DropDown<int>(ctx);
+
+            var items = component.FindAll(".rz-dropdown-item");
+
+            Assert.Equal(2, items.Count);
+
+            //this throws
+            await component.InvokeAsync(async () => await component.Instance.SelectItem(1));
+        }
+
+        [Fact]
+        public void DropDown_RendersItems()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = DropDown<int>(ctx);
+
+            var items = component.FindAll(".rz-dropdown-item");
+
+            Assert.Equal(2, items.Count);
+        }
+
+        [Fact]
+        public void DropDown_AppliesSelectionStyleForIntValue()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = DropDown<int>(ctx);
+
+            var items = component.FindAll(".rz-dropdown-item");
+
+            items[0].Click();
+
+            component.Render();
+
+            items = component.FindAll(".rz-dropdown-item");
+
+            Assert.Contains("rz-state-highlight", items[0].ClassList);
+        }
+
+        [Fact]
+        public void DropDown_AppliesSelectionStyleForStringValue()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = DropDown<string>(ctx, parameters =>
+            {
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Text));
+            });
+
+            var items = component.FindAll(".rz-dropdown-item");
+
+            items[0].Click();
+
+            component.Render();
+
+            items = component.FindAll(".rz-dropdown-item");
+
+            Assert.Contains("rz-state-highlight", items[0].ClassList);
+        }
+
+        [Fact]
+        public void DropDown_Respects_ItemEqualityComparer()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            List<DataItem> boundCollection = [new() { Text = "Item 2" }];
+
+            var component = DropDown<List<DataItem>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.ItemComparer, new DataItemComparer());
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, boundCollection);
+            });
+
+            var selectedItems = component.FindAll(".rz-state-highlight");
+            Assert.Equal(1, selectedItems.Count);
+            Assert.Equal("Item 2", selectedItems[0].TextContent.Trim());
+
+            // select Item 1 in list
+            var items = component.FindAll(".rz-multiselect-item");
+            items[0].Click();
+            component.Render();
+
+            selectedItems = component.FindAll(".rz-state-highlight");
+            Assert.Equal(2, selectedItems.Count);
+            Assert.Equal("Item 1", selectedItems[0].TextContent.Trim());
+        }
+
+        [Fact]
+        public void DropDown_AppliesSelectionStyleWhenMultipleSelectionIsEnabled()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = DropDown<string>(ctx, parameters =>
+            {
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Text));
+                parameters.Add(p => p.Multiple, true);
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+
+            items[0].Click();
+
+            component.Render();
+
+            items = component.FindAll(".rz-multiselect-item");
+
+            items[1].Click();
+
+            component.Render();
+
+            var selectedItems = component.FindAll(".rz-state-highlight");
+
+            Assert.Equal(2, selectedItems.Count);
+        }
+
+        [Fact]
+        public void DropDown_AppliesValueTemplateOnMultipleSelection()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var valueTemplateFragment = (RenderFragment<dynamic>)(_context =>
+            builder =>
+            {
+                builder.AddContent(0, $"value: {_context.Text}");
+            });
+
+            var component = DropDown<string>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true)
+                    .Add(p => p.ValueTemplate, valueTemplateFragment);
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+
+            items[0].Click();
+            items[1].Click();
+
+            component.Render();
+
+            var selectedItems = component.Find(".rz-inputtext");
+
+            Assert.Contains("value: Item 1,value: Item 2", selectedItems.Text());
+        }
+
+        [Fact]
+        public void DropDown_AppliesValueTemplateWhenTepmlateDefined()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var valueTemplateFragment = (RenderFragment<dynamic>)(_context =>
+            builder =>
+            {
+                builder.AddContent(0, $"value: {_context.Text}");
+            });
+
+            var templateFragment = (RenderFragment<dynamic>)(_context =>
+            builder =>
+            {
+                builder.AddContent(0, $"template: {_context.Text}");
+            });
+
+            var component = DropDown<string>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true)
+                    .Add(p => p.ValueTemplate, valueTemplateFragment)
+                    .Add(p => p.Template, templateFragment);
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+
+            items[0].Click();
+            items[1].Click();
+
+            component.Render();
+
+            var selectedItems = component.Find(".rz-inputtext");
+            var itemsText = component.FindAll(".rz-multiselect-item-content");
+
+            Assert.Collection(itemsText, item => Assert.Contains("template: Item 1", item.Text()), item => Assert.Contains("template: Item 2", item.Text()));
+            Assert.Contains("value: Item 1,value: Item 2", selectedItems.Text());
+        }
+
+        [Fact]
+        public void DropDown_AppliesValueTemplateOnMultipleSelectionChips()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var valueTemplateFragment = (RenderFragment<dynamic>)(_context =>
+            builder =>
+            {
+                builder.AddContent(0, $"value: {_context.Text}");
+            });
+
+            var component = DropDown<string>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true)
+                    .Add(p => p.ValueTemplate, valueTemplateFragment)
+                    .Add(p => p.Chips, true);
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+
+            items[0].Click();
+            items[1].Click();
+
+            component.Render();
+
+            var selectedItems = component.FindAll(".rz-chip-text");
+
+            Assert.Collection(selectedItems, item => Assert.Contains("value: Item 1", item.Text()), item => Assert.Contains("value: Item 2", item.Text()));
+        }
+
+        [Theory]
+        [InlineData(false, true, false, true, "false")]
+        [InlineData(true, false, true, false, "true")]
+        [InlineData(true, false, false, false, "false")]
+        [InlineData(true, false, false, true, "true")]
+        [InlineData(false, false, false, true, "false")]
+        public void DropDown_AllSelectedFalseIfListIsAllDisabled(bool item1Selected, bool item1Disabled, bool item2Selected, bool item2Disabled, string expectedAriaCheckedValue)
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var data = new[] {
+                new DataItem { Text = "Item 1", Id = 1, Disabled = item1Disabled },
+                new DataItem { Text = "Item 2", Id = 2, Disabled = item2Disabled },
+            };
+
+            List<int> selectedValues = [];
+            if (item1Selected)
+            {
+                selectedValues.Add(data[0].Id);
+            }
+            if (item2Selected)
+            {
+                selectedValues.Add(data[1].Id);
+            }
+
+            var component = ctx.RenderComponent<RadzenDropDown<List<int>>>(parameters => parameters
+               .Add(p => p.Data, data)
+               .Add(p => p.Value, selectedValues)
+               .Add(p => p.Multiple, true)
+               .Add(p => p.AllowSelectAll, true)
+               .Add(p => p.TextProperty, nameof(DataItem.Text))
+               .Add(p => p.DisabledProperty, nameof(DataItem.Disabled))
+               .Add(p => p.ValueProperty, nameof(DataItem.Id)));
+
+            Assert.NotNull(component);
+            var highlightedItems = component.FindAll(".rz-state-highlight");
+            Assert.Equal(selectedValues.Count, highlightedItems.Count);
+
+
+            var selectAllCheckBox = component.Find(".rz-multiselect-header input[type='checkbox']");
+
+            Assert.Equal(expectedAriaCheckedValue, selectAllCheckBox.GetAttribute("aria-checked"));
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_HashSet_ReferencesInstance()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalHashSet = new HashSet<int>();
+            var capturedValue = (HashSet<int>)null;
+
+            var component = DropDownWithReferenceCollection<HashSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalHashSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<HashSet<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item
+            items[0].Click();
+            component.Render();
+
+            // Verify the same HashSet instance is Referenced
+            Assert.Same(originalHashSet, capturedValue);
+            
+            // Verify the item was added correctly
+            Assert.Single(originalHashSet);
+            Assert.Contains(1, originalHashSet);
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_HashSet_MultipleSelections()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalHashSet = new HashSet<int> { 2 }; // Pre-populate with Item 2
+            var capturedValues = new List<HashSet<int>>();
+
+            var component = DropDownWithReferenceCollection<HashSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalHashSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<HashSet<int>>(this, value => capturedValues.Add(value)));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item (should add to existing collection)
+            items[0].Click();
+            component.Render();
+
+            // Verify the same HashSet instance is Referenced
+            Assert.Single(capturedValues);
+            Assert.Same(originalHashSet, capturedValues[0]);
+            
+            // Verify both items are now in the collection
+            Assert.Equal(2, originalHashSet.Count);
+            Assert.Contains(1, originalHashSet);
+            Assert.Contains(2, originalHashSet);
+
+            // Deselect second item (should remove from collection)
+            items = component.FindAll(".rz-multiselect-item"); // Re-find items after render
+            items[1].Click();
+            component.Render();
+
+            // Verify the same HashSet instance is still Referenced
+            Assert.Equal(2, capturedValues.Count);
+            Assert.Same(originalHashSet, capturedValues[1]);
+            
+            // Verify only first item remains
+            Assert.Single(originalHashSet);
+            Assert.Contains(1, originalHashSet);
+            Assert.DoesNotContain(2, originalHashSet);
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_SortedSet_ReferencesInstance()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalSortedSet = new SortedSet<int>();
+            var capturedValue = (SortedSet<int>)null;
+
+            var component = DropDownWithReferenceCollection<SortedSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalSortedSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<SortedSet<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select both items
+            items[0].Click();
+            component.Render();
+            items = component.FindAll(".rz-multiselect-item"); // Re-find items after first click
+            items[1].Click();
+            component.Render();
+
+            // Verify the same SortedSet instance is Referenced
+            Assert.Same(originalSortedSet, capturedValue);
+            
+            // Verify items are sorted correctly
+            Assert.Equal(2, originalSortedSet.Count);
+            var sortedItems = originalSortedSet.ToList();
+            Assert.Equal(1, sortedItems[0]);
+            Assert.Equal(2, sortedItems[1]);
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_CustomCollection_ReferencesInstance()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalCollection = new CustomCollection<int>();
+            var capturedValue = (CustomCollection<int>)null;
+
+            var component = DropDownWithReferenceCollection<CustomCollection<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalCollection);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<CustomCollection<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item
+            items[0].Click();
+            component.Render();
+
+            // Verify the same custom collection instance is Referenced
+            Assert.Same(originalCollection, capturedValue);
+            
+            // Verify the item was added correctly
+            Assert.Single(originalCollection);
+            Assert.Contains(1, originalCollection);
+        }
+
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_List_ReferencesInstance()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalList = new List<int>();
+            var capturedValue = (List<int>)null;
+
+            var component = DropDownWithReferenceCollection<List<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalList);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<List<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item
+            items[0].Click();
+            component.Render();
+
+            // For List<T>, it should now Reference the instance since we removed the IList exclusion
+            // Arrays are now excluded instead
+            Assert.Same(originalList, capturedValue);
+            
+            // And the content should be correct
+            Assert.Single(capturedValue);
+            Assert.Contains(1, capturedValue);
+        }
+
+        [Fact]
+        public void DropDown_ReferenceGenericCollectionAssignment_DisabledByDefault()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalList = new List<int>();
+            var capturedValue = (List<int>)null;
+
+            var component = DropDown<List<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalList);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<List<int>>(this, value => capturedValue = value));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            var items = component.FindAll(".rz-multiselect-item");
+            
+            // Select first item
+            items[0].Click();
+            component.Render();
+
+            // When ReferenceCollectionOnSelection is false (default), a new instance should be created
+            Assert.NotSame(originalList, capturedValue);
+            
+            // But the content should still be correct
+            Assert.Single(capturedValue);
+            Assert.Contains(1, capturedValue);
+        }
+
+        [Fact]
+        public void DropDown_Reset_PreservesCollectionInstanceButClears()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalHashSet = new HashSet<int> { 1, 2 }; // Pre-populate
+            var capturedValues = new List<HashSet<int>>();
+
+            var component = DropDownWithReferenceCollection<HashSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Value, originalHashSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<HashSet<int>>(this, value => capturedValues.Add(value)));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            // Verify initial state - collection should have 2 items
+            Assert.Equal(2, originalHashSet.Count);
+            Assert.Contains(1, originalHashSet);
+            Assert.Contains(2, originalHashSet);
+
+            // Call Reset (public method that calls ClearAll internally)
+            component.InvokeAsync(() => component.Instance.Reset());
+            component.Render();
+
+            // Verify the same HashSet instance is preserved
+            Assert.Single(capturedValues);
+            Assert.Same(originalHashSet, capturedValues[0]);
+            
+            // Verify the collection is now cleared
+            Assert.Empty(originalHashSet);
+        }
+
+        [Fact]
+        public void DropDown_SelectAll_PreservesCollectionInstanceAndPopulates()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var originalHashSet = new HashSet<int>(); // Start empty
+            var capturedValues = new List<HashSet<int>>();
+
+            var component = DropDownWithReferenceCollection<HashSet<int>>(ctx, parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.AllowSelectAll, true);
+                parameters.Add(p => p.Value, originalHashSet);
+                parameters.Add(p => p.ValueChanged, EventCallback.Factory.Create<HashSet<int>>(this, value => capturedValues.Add(value)));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+            });
+
+            // Verify initial state - collection should be empty
+            Assert.Empty(originalHashSet);
+
+            // Find and click the "Select All" checkbox
+            var selectAllCheckBox = component.Find(".rz-multiselect-header input[type='checkbox']");
+            selectAllCheckBox.Click();
+            component.Render();
+
+            // Verify the same HashSet instance is preserved
+            Assert.Single(capturedValues);
+            Assert.Same(originalHashSet, capturedValues[0]);
+            
+            // Verify the collection now contains both items
+            Assert.Equal(2, originalHashSet.Count);
+            Assert.Contains(1, originalHashSet);
+            Assert.Contains(2, originalHashSet);
+        }
+
+        class ReferenceCollectionDropDown<T> : Radzen.Blazor.RadzenDropDown<T>
+        {
+            protected override void OnInitialized()
+            {
+                PreserveCollectionOnSelection = true;
+                base.OnInitialized();
+            }
+        }
+
+        private static IRenderedComponent<ReferenceCollectionDropDown<T>> DropDownWithReferenceCollection<T>(TestContext ctx, Action<ComponentParameterCollectionBuilder<ReferenceCollectionDropDown<T>>> configure = null)
+        {
+            var data = new[] {
+                new DataItem { Text = "Item 1", Id = 1 },
+                new DataItem { Text = "Item 2", Id = 2 },
+            };
+
+            var component = ctx.RenderComponent<ReferenceCollectionDropDown<T>>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, nameof(DataItem.Text));
+
+                if (configure != null)
+                {
+                    configure.Invoke(parameters);
+                }
+                else
+                {
+                    parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+                }
+            });
+
+            return component;
+        }
+
+        class DataItemComparer : IEqualityComparer<DataItem>, IEqualityComparer<object>
+        {
+            public bool Equals(DataItem x, DataItem y)
+            {
+                if (ReferenceEquals(x, y)) return true;
+                if (x is null) return false;
+                if (y is null) return false;
+                if (x.GetType() != y.GetType()) return false;
+                return x.Text == y.Text;
+            }
+
+            public int GetHashCode(DataItem obj)
+            {
+                return obj.Text.GetHashCode();
+            }
+
+            public new bool Equals(object x, object y)
+            {
+                return Equals((DataItem)x, (DataItem)y);
+            }
+
+            public int GetHashCode(object obj)
+            {
+                return GetHashCode((DataItem)obj);
+
+            }
+        }
+
+        class CustomCollection<T> : ICollection<T>
+        {
+            private readonly List<T> _items = new();
+
+            public int Count => _items.Count;
+            public bool IsReadOnly => false;
+
+            public void Add(T item) => _items.Add(item);
+            public void Clear() => _items.Clear();
+            public bool Contains(T item) => _items.Contains(item);
+            public void CopyTo(T[] array, int arrayIndex) => _items.CopyTo(array, arrayIndex);
+            public bool Remove(T item) => _items.Remove(item);
+            public IEnumerator<T> GetEnumerator() => _items.GetEnumerator();
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
+        [Fact]
+        public void DropDown_Renders_Placeholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenDropDown<int>>(parameters =>
+            {
+                parameters.Add(p => p.Placeholder, "Select an option");
+            });
+
+            Assert.Contains("Select an option", component.Markup);
+            Assert.Contains("rz-placeholder", component.Markup);
+        }
+
+        [Fact]
+        public void DropDown_Renders_AllowClear_WithValue()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new[] { new DataItem { Text = "Item 1", Id = 1 } };
+
+            var component = ctx.RenderComponent<RadzenDropDown<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowClear, true);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, nameof(DataItem.Text));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+                parameters.Add(p => p.Value, 1);
+            });
+
+            Assert.Contains("rz-dropdown-clear-icon", component.Markup);
+        }
+
+        [Fact]
+        public void DropDown_DoesNotRender_AllowClear_WhenNotAllowed()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new[] { new DataItem { Text = "Item 1", Id = 1 } };
+
+            var component = ctx.RenderComponent<RadzenDropDown<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowClear, false);
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, nameof(DataItem.Text));
+                parameters.Add(p => p.ValueProperty, nameof(DataItem.Id));
+                parameters.Add(p => p.Value, 1);
+            });
+
+            Assert.DoesNotContain("rz-dropdown-clear-icon", component.Markup);
+        }
+    }
+}

Radzen.Blazor.Tests/ExpressionSerializerTests.cs

@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Linq.Expressions;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    class TestEntity
+    {
+        public string Name { get; set; }
+        public int Age { get; set; }
+        public double Salary { get; set; }
+        public float Score { get; set; }
+        public decimal Balance { get; set; }
+        public short Level { get; set; }
+        public long Population { get; set; }
+        public Status AccountStatus { get; set; }
+        public DateTime CreatedAt { get; set; }
+        public DateTimeOffset LastUpdated { get; set; }
+        public Guid Id { get; set; }
+        public TimeOnly StartTime { get; set; }
+        public DateOnly BirthDate { get; set; }
+        public int[] Scores { get; set; }
+        public List<string> Tags { get; set; }
+        public List<TestEntity> Children { get; set; }
+        public Address Address { get; set; }
+        public double[] Salaries { get; set; }
+        public float[] Heights { get; set; }
+        public decimal[] Balances { get; set; }
+        public short[] Levels { get; set; }
+        public long[] Populations { get; set; }
+        public string[] Names { get; set; }
+        public Guid[] Ids { get; set; }
+        public DateTime[] CreatedDates { get; set; }
+        public DateTimeOffset[] UpdatedDates { get; set; }
+        public TimeOnly[] StartTimes { get; set; }
+        public DateOnly[] BirthDates { get; set; }
+        public Status[] Statuses { get; set; }
+    }
+
+    enum Status
+    {
+        Active,
+        Inactive,
+        Suspended
+    }
+
+    class Address
+    {
+        public string City { get; set; }
+        public string Country { get; set; }
+    }
+
+    public class ExpressionSerializerTests
+    {
+        private readonly ExpressionSerializer _serializer = new ExpressionSerializer();
+
+        [Fact]
+        public void Serializes_SimpleBinaryExpression()
+        {
+            Expression<Func<int, bool>> expr = e => e > 10;
+            Assert.Equal("e => (e > 10)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_StringEquality()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Name == "John";
+            Assert.Equal("e => (e.Name == \"John\")", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_IntComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Age > 18;
+            Assert.Equal("e => (e.Age > 18)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DoubleComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Salary < 50000.50;
+            Assert.Equal("e => (e.Salary < 50000.5)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_FloatComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Score >= 85.3f;
+            Assert.Equal("e => (e.Score >= 85.3)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DecimalComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Balance <= 1000.75m;
+            Assert.Equal("e => (e.Balance <= 1000.75)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ShortComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Level == 3;
+            Assert.Equal("e => (e.Level == 3)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_LongComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Population > 1000000L;
+            Assert.Equal("e => (e.Population > 1000000)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_EnumComparison()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.AccountStatus == Status.Inactive;
+            Assert.Equal("e => (e.AccountStatus == 1)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayContainsValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Scores.Contains(100);
+            Assert.Equal("e => e.Scores.Contains(100)", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayNotContainsValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !e.Scores.Contains(100);
+            Assert.Equal("e => (!(e.Scores.Contains(100)))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayInValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Scores.Intersect(new [] { 100 }).Any();
+            Assert.Equal("e => e.Scores.Intersect(new [] { 100 }).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayNotInValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Scores.Except(new[] { 100 }).Any();
+            Assert.Equal("e => e.Scores.Except(new [] { 100 }).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 100 }.Intersect(e.Scores).Any();
+            Assert.Equal("e => new [] { 100 }.Intersect(e.Scores).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ArrayNotInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 100 }.Except(e.Scores).Any();
+            Assert.Equal("e => new [] { 100 }.Except(e.Scores).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_IntArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 100 }.Intersect(e.Scores).Any();
+            Assert.Equal("e => new [] { 100 }.Intersect(e.Scores).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_IntArrayNotInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !new[] { 100 }.Intersect(e.Scores).Any();
+            Assert.Equal("e => (!(new [] { 100 }.Intersect(e.Scores).Any()))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DoubleArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 99.99 }.Intersect(e.Salaries).Any();
+            Assert.Equal("e => new [] { 99.99 }.Intersect(e.Salaries).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_FloatArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 5.5f }.Intersect(e.Heights).Any();
+            Assert.Equal("e => new [] { 5.5 }.Intersect(e.Heights).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DecimalArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { 1000.75m }.Intersect(e.Balances).Any();
+            Assert.Equal("e => new [] { 1000.75 }.Intersect(e.Balances).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ShortArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new [] { (short)3 }.Intersect(e.Levels).Any();
+            Assert.Equal("e => new [] { 3 }.Intersect(e.Levels).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_LongArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new [] { 1000000L }.Intersect(e.Populations).Any();
+            Assert.Equal("e => new [] { 1000000 }.Intersect(e.Populations).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_StringArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { "Alice", "Bob" }.Intersect(e.Names).Any();
+            Assert.Equal("e => (new [] { \"Alice\", \"Bob\" }).Intersect(e.Names).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_GuidArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { Guid.Parse("12345678-1234-1234-1234-123456789abc") }.Intersect(e.Ids).Any();
+            Assert.Equal("e => (new [] { Guid.Parse(\"12345678-1234-1234-1234-123456789abc\") }).Intersect(e.Ids).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DateTimeArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { DateTime.Parse("2023-01-01T00:00:00.000Z") }.Intersect(e.CreatedDates).Any();
+            Assert.Equal("e => (new [] { DateTime.Parse(\"2023-01-01T00:00:00.000Z\") }).Intersect(e.CreatedDates).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DateTimeOffsetArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { DateTimeOffset.Parse("2023-01-01T10:30:00.000+00:00") }.Intersect(e.UpdatedDates).Any();
+            Assert.Equal("e => (new [] { DateTimeOffset.Parse(\"2023-01-01T10:30:00.000+00:00\") }).Intersect(e.UpdatedDates).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DateTimeWithRoundtripKind()
+        {
+            Expression<Func<TestEntity, bool>> expr = e =>
+                DateTime.Parse("2023-01-01T00:00:00.000Z", null, DateTimeStyles.RoundtripKind) > e.CreatedAt;
+
+            Assert.Equal(
+                "e => (DateTime.Parse(\"2023-01-01T00:00:00.000Z\", null, (System.Globalization.DateTimeStyles)128) > e.CreatedAt)",
+                _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_TimeOnlyArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { TimeOnly.Parse("12:00:00") }.Intersect(e.StartTimes).Any();
+            Assert.Equal("e => (new [] { TimeOnly.Parse(\"12:00:00\") }).Intersect(e.StartTimes).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_DateOnlyArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { DateOnly.Parse("2000-01-01") }.Intersect(e.BirthDates).Any();
+            Assert.Equal("e => (new [] { DateOnly.Parse(\"2000-01-01\") }).Intersect(e.BirthDates).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_EnumArrayInValueOposite()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => new[] { Status.Active, Status.Inactive }.Intersect(e.Statuses).Any();
+            Assert.Equal("e => (new [] { (Radzen.Blazor.Tests.Status)0, (Radzen.Blazor.Tests.Status)1 }).Intersect(e.Statuses).Any()", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ListContainsValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Tags.Contains("VIP");
+            Assert.Equal("e => e.Tags.Contains(\"VIP\")", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ListNotContainsValue()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !e.Tags.Contains("VIP");
+            Assert.Equal("e => (!(e.Tags.Contains(\"VIP\")))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ListAnyCheck()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Children.Any(c => c.Age > 18);
+            Assert.Equal("e => e.Children.Any(c => (c.Age > 18))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ListNotAnyCheck()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !e.Children.Any(c => c.Age > 18);
+            Assert.Equal("e => (!(e.Children.Any(c => (c.Age > 18))))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_EntitySubPropertyCheck()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Address.City == "New York";
+            Assert.Equal("e => (e.Address.City == \"New York\")", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_ComplexExpressionWithProperties()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => e.Age > 18 && e.Tags.Contains("Member") || e.Address.City == "London";
+            Assert.Equal("e => (((e.Age > 18) && e.Tags.Contains(\"Member\")) || (e.Address.City == \"London\"))", _serializer.Serialize(expr));
+        }
+
+        [Fact]
+        public void Serializes_NotContains()
+        {
+            Expression<Func<TestEntity, bool>> expr = e => !e.Tags.Contains("Member");
+            Assert.Equal("e => (!(e.Tags.Contains(\"Member\")))", _serializer.Serialize(expr));
+        }
+    }
+}

Radzen.Blazor.Tests/FieldsetTests.cs

@@ -17,7 +17,6 @@ namespace Radzen.Blazor.Tests
             component.Render();
 
             Assert.Contains(@$"rz-fieldset", component.Markup);
-            Assert.Contains(@$"rz-fieldset-legend", component.Markup);
             Assert.Contains(@$"rz-fieldset-content-wrapper", component.Markup);
             Assert.Contains(@$"rz-fieldset-content", component.Markup);
         }
@@ -47,7 +46,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, value));
 
-            Assert.Contains(@$"<i class=""rzi"">{value}</i>", component.Markup);
+            Assert.Contains(@$"<i class=""notranslate rzi"">{value}</i>", component.Markup);
         }
 
         [Fact]
@@ -105,11 +104,11 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AllowCollapse, true));
 
-            Assert.Contains(@"<span class=""rz-fieldset-toggler rzi rzi-w rzi-minus""></span>", component.Markup);
+            Assert.Contains(@"<span class=""notranslate rz-fieldset-toggler rzi rzi-w rzi-minus""></span>", component.Markup);
 
             component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.Collapsed, true));
 
-            Assert.Contains(@"<span class=""rz-fieldset-toggler rzi rzi-w rzi-plus""></span>", component.Markup);
+            Assert.Contains(@"<span class=""notranslate rz-fieldset-toggler rzi rzi-w rzi-plus""></span>", component.Markup);
         }
 
         [Fact]
@@ -185,13 +184,13 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains("SummaryContent", component.Markup);
             Assert.Equal(
-                "",
-                component.Find(".rz-fieldset-content-summary").ParentElement.Attributes.First(attr => attr.Name == "style").Value
+                "false",
+                component.Find(".rz-fieldset-content-summary").ParentElement.ParentElement.Attributes.First(attr => attr.Name == "aria-hidden").Value
             );
         }
 
         [Fact]
-        public void Fieldset_DontRenders_SummaryWhenOpen()
+        public void Fieldset_DoesNotRender_SummaryWhenOpen()
         {
             using var ctx = new TestContext();
             var component = ctx.RenderComponent<RadzenFieldset>();
@@ -211,8 +210,8 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains("SummaryContent", component.Markup);
             Assert.Equal(
-                "display: none",
-                component.Find(".rz-fieldset-content-summary").ParentElement.Attributes.First(attr => attr.Name == "style").Value
+                "true",
+                component.Find(".rz-fieldset-content-summary").ParentElement.ParentElement.Attributes.First(attr => attr.Name == "aria-hidden").Value
             );
         }
     }

Radzen.Blazor.Tests/FileInputTests.cs

@@ -0,0 +1,182 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class FileInputTests
+    {
+        [Fact]
+        public void FileInput_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains(@"rz-fileupload", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_ChooseButton()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains("rz-fileupload-choose", component.Markup);
+            Assert.Contains("rz-button", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_ChooseText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.ChooseText, "Select File");
+            });
+
+            Assert.Contains("Select File", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_DefaultChooseText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains("Choose", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+            Assert.Contains("disabled", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_Accept()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Accept, "application/pdf");
+            });
+
+            Assert.Contains("accept=\"application/pdf\"", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_DefaultAccept()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains("accept=\"image/*\"", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_FileInputElement()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>();
+
+            Assert.Contains("type=\"file\"", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_Title_WhenSet()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Title, "MyDocument.pdf");
+                parameters.Add(p => p.Value, "data:application/pdf;base64,test");
+            });
+
+            Assert.Contains("MyDocument.pdf", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_FileName_WhenTitleNotSet()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.FileName, "document.pdf");
+                parameters.Add(p => p.Value, "data:application/pdf;base64,test");
+            });
+
+            Assert.Contains("document.pdf", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_DeleteButton_WhenValueSet()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Value, "data:text/plain;base64,test");
+            });
+
+            Assert.Contains("rz-icon-trash", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_CustomDeleteText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.DeleteText, "Remove File");
+                parameters.Add(p => p.Value, "data:text/plain;base64,test");
+            });
+
+            Assert.Contains("title=\"Remove File\"", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_ImagePreview_ForImageFile()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.Value, "data:image/png;base64,test");
+            });
+
+            Assert.Contains("<img", component.Markup);
+        }
+
+        [Fact]
+        public void FileInput_Renders_ImageAlternateText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenFileInput<string>>(parameters =>
+            {
+                parameters.Add(p => p.ImageAlternateText, "User Photo");
+                parameters.Add(p => p.Value, "data:image/png;base64,test");
+            });
+
+            Assert.Contains("alt=\"User Photo\"", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/FormFieldTests.cs

@@ -0,0 +1,163 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class FormFieldTests
+    {
+        [Fact]
+        public void FormField_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>();
+
+            Assert.Contains(@"rz-form-field", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Text()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Text, "Email Address");
+            });
+
+            Assert.Contains("Email Address", component.Markup);
+            Assert.Contains("rz-form-field-label", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Variant_Outlined()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Variant, Variant.Outlined);
+            });
+
+            Assert.Contains("rz-variant-outlined", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Variant_Filled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Variant, Variant.Filled);
+            });
+
+            Assert.Contains("rz-variant-filled", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Variant_Flat()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Variant, Variant.Flat);
+            });
+
+            Assert.Contains("rz-variant-flat", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Variant_Text()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Variant, Variant.Text);
+            });
+
+            Assert.Contains("rz-variant-text", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_AllowFloatingLabel_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.AllowFloatingLabel, true);
+            });
+
+            Assert.Contains("rz-floating-label", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_AllowFloatingLabel_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.AllowFloatingLabel, false);
+            });
+
+            Assert.DoesNotContain("rz-floating-label", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Component_Attribute()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Component, "email-input");
+            });
+
+            Assert.Contains("for=\"email-input\"", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Helper()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Helper, builder => builder.AddContent(0, "Enter your email address"));
+            });
+
+            Assert.Contains("rz-form-field-helper", component.Markup);
+            Assert.Contains("Enter your email address", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_Start()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.Start, builder => builder.AddMarkupContent(0, "<span>Start</span>"));
+            });
+
+            Assert.Contains("rz-form-field-start", component.Markup);
+            Assert.Contains("Start", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_End()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>(parameters =>
+            {
+                parameters.Add(p => p.End, builder => builder.AddMarkupContent(0, "<span>End</span>"));
+            });
+
+            Assert.Contains("rz-form-field-end", component.Markup);
+            Assert.Contains("End", component.Markup);
+        }
+
+        [Fact]
+        public void FormField_Renders_FormFieldContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFormField>();
+
+            Assert.Contains("rz-form-field-content", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/HeadingTests.cs

@@ -0,0 +1,103 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class HeadingTests
+    {
+        [Fact]
+        public void Heading_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            Assert.Contains(@"rz-heading", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_TextParameter()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            var text = "Test Heading";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H1_ByDefault()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            var text = "Heading Text";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains("<h1", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H2_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            var text = "Heading 2";
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Text, text);
+                parameters.Add(p => p.Size, "H2");
+            });
+
+            Assert.Contains("<h2", component.Markup);
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H3_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, "H3"));
+
+            Assert.Contains("<h3", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H4_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, "H4"));
+
+            Assert.Contains("<h4", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H5_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, "H5"));
+
+            Assert.Contains("<h5", component.Markup);
+        }
+
+        [Fact]
+        public void Heading_Renders_H6_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenHeading>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, "H6"));
+
+            Assert.Contains("<h6", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/HtmlEditorTests.cs

@@ -0,0 +1,104 @@
+using Bunit;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class HtmlEditorTests
+    {
+        [Fact]
+        public void HtmlEditor_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>();
+
+            Assert.Contains(@"rz-html-editor", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_ShowToolbar_True()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.ShowToolbar, true);
+            });
+
+            Assert.Contains("rz-html-editor-toolbar", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_ShowToolbar_False()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.ShowToolbar, false);
+            });
+
+            Assert.DoesNotContain("rz-html-editor-toolbar", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_Mode_Design()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.Mode, HtmlEditorMode.Design);
+            });
+
+            // Design mode shows the content editable div
+            Assert.Contains("contenteditable", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_Mode_Source()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.Mode, HtmlEditorMode.Source);
+            });
+
+            // Source mode shows the textarea for HTML editing
+            Assert.Contains("rz-html-editor-source", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_Disabled_Attribute()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+        }
+
+        [Fact]
+        public void HtmlEditor_Renders_ContentArea()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.Services.AddScoped<DialogService>();
+            var component = ctx.RenderComponent<RadzenHtmlEditor>();
+
+            Assert.Contains("rz-html-editor-content", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/IconTests.cs

@@ -17,7 +17,7 @@ namespace Radzen.Blazor.Tests
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, icon));
 
             Assert.Contains(@$">{icon}</i>", component.Markup);
-            Assert.Contains(@$"<i class=""rzi d-inline-flex justify-content-center align-items-center""", component.Markup);
+            Assert.Contains(@$"class=""notranslate rzi""", component.Markup);
         }
 
         [Fact]
@@ -58,6 +58,18 @@ namespace Radzen.Blazor.Tests
             Assert.Contains(@$"rzi-primary", component.Markup);
         }
 
+        [Fact]
+        public void Icon_Renders_IconColor()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenIcon>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(icon => icon.IconColor, Colors.Primary));
+
+            Assert.Contains(@$"color:", component.Markup);
+        }
+
         [Fact]
         public void Icon_NotRenders_IconStyleClass_WhenNull()
         {
@@ -69,5 +81,17 @@ namespace Radzen.Blazor.Tests
 
             Assert.DoesNotContain(@$"rzi-primary", component.Markup);
         }
+
+        [Fact]
+        public void Icon_NotRenders_IconColor_WhenNull()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenIcon>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(icon => icon.IconColor, null));
+
+            Assert.DoesNotContain(@$"color:", component.Markup);
+        }
     }
 }

Radzen.Blazor.Tests/LinkTests.cs

@@ -30,8 +30,10 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
 
-            Assert.Contains(@$">{text}</span>", component.Markup);
-            Assert.Contains(@$"class=""rz-link-text""", component.Markup);
+            var textElement = component.Find(".rz-link-text");
+
+            Assert.NotNull(textElement);
+            Assert.Equal(text, textElement.TextContent.Trim());
         }
 
         [Fact]
@@ -45,7 +47,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, icon));
 
-            Assert.Contains(@$"<i class=""rzi"">{icon}</i>", component.Markup);
+            Assert.Contains(@$"<i class=""notranslate rzi"">{icon}</i>", component.Markup);
         }
 
         [Fact]
@@ -76,6 +78,20 @@ namespace Radzen.Blazor.Tests
             Assert.Contains(@$"target=""{target}""", component.Markup);
         }
 
+        [Fact]
+        public void Link_Renders_DisabledParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenLink>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Disabled, true));
+
+            Assert.Contains("class=\"rz-link rz-link-disabled active\"", component.Markup);
+
+            Assert.DoesNotContain("href=", component.Markup);
+        }
+
         [Fact]
         public void Icon_Renders_UnmatchedParameter()
         {

Radzen.Blazor.Tests/ListBoxTests.cs

@@ -0,0 +1,197 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ListBoxTests
+    {
+        class Item
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+        }
+
+        [Fact]
+        public void ListBox_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>();
+
+            Assert.Contains(@"rz-listbox", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_WithData_SimpleList()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Apple", "Banana", "Cherry" };
+            
+            var component = ctx.RenderComponent<RadzenListBox<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("Apple", component.Markup);
+            Assert.Contains("Banana", component.Markup);
+            Assert.Contains("Cherry", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_WithData_CustomTextValueProperties()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "First Item" },
+                new Item { Id = 2, Name = "Second Item" }
+            };
+            
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+                parameters.Add(p => p.TextProperty, "Name");
+                parameters.Add(p => p.ValueProperty, "Id");
+            });
+
+            Assert.Contains("First Item", component.Markup);
+            Assert.Contains("Second Item", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_AllowFiltering()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.Data, new List<string> { "Item1", "Item2" });
+            });
+
+            Assert.Contains("rz-listbox-filter", component.Markup);
+            Assert.Contains("rz-listbox-header", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_Disabled_Attribute()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_Multiple_WithSelectAll()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<IEnumerable<int>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.SelectAllText, "Select All Items");
+                parameters.Add(p => p.Data, new List<string> { "Item1", "Item2" });
+            });
+
+            Assert.Contains("Select All Items", component.Markup);
+            Assert.Contains("rz-chkbox", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_FilterPlaceholder()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.Placeholder, "Select an item");
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.Data, new List<string> { "Item1", "Item2" });
+            });
+
+            Assert.Contains("Select an item", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_Multiple_WithCheckboxes()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1", "Item2" };
+
+            var component = ctx.RenderComponent<RadzenListBox<IEnumerable<string>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Data, data);
+            });
+
+            // Multiple selection shows checkboxes in header
+            Assert.Contains("rz-listbox-header-w-checkbox", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_ReadOnly()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.ReadOnly, true);
+            });
+
+            Assert.Contains("readonly", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_TabIndex()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>();
+
+            Assert.Contains("tabindex=", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_ListWrapper()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<string> { "Item1" };
+
+            var component = ctx.RenderComponent<RadzenListBox<string>>(parameters =>
+            {
+                parameters.Add(p => p.Data, data);
+            });
+
+            Assert.Contains("rz-listbox-list-wrapper", component.Markup);
+            Assert.Contains("rz-listbox-list", component.Markup);
+        }
+
+        [Fact]
+        public void ListBox_Renders_SearchAriaLabel()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenListBox<int>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.SearchAriaLabel, "Search items");
+                parameters.Add(p => p.Data, new List<string> { "Item1" });
+            });
+
+            Assert.Contains("aria-label=\"Search items\"", component.Markup);
+        }
+    }
+}
+
+
+

Radzen.Blazor.Tests/LoginTests.cs

@@ -26,7 +26,12 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenLogin>();
 
-            Assert.Contains(@$"<label class=""col-sm-3 col-form-label"" for=""username"">Username</label>", component.Markup);
+            component.SetParametersAndRender(p => {
+                p.AddUnmatched("id", "login");
+            });
+
+            var label = component.Find($@"label[for=""login-username""]");
+            Assert.NotNull(label);
         }
 
         [Fact]
@@ -63,7 +68,7 @@ namespace Radzen.Blazor.Tests
             component.SetParametersAndRender(parameters => {
                 parameters.Add(p => p.Username, "user");
                 parameters.Add(p => p.Password, "pwd");
-                parameters.Add(p => p.Login, args => { clicked = true; }); 
+                parameters.Add(p => p.Login, args => { clicked = true; });
             });
 
             component.Find("button").Click();
@@ -114,7 +119,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add(p => p.AllowResetPassword, true);
             });
 
-            Assert.Contains(@$"Forgot password</a>", component.Markup);
+            Assert.Contains(@$"Forgot password?</a>", component.Markup);
         }
 
         [Fact]
@@ -190,7 +195,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add(p => p.Register, args => { clicked = true; });
             });
 
-            component.Find(".register > button").Click();
+            component.Find(".rz-secondary").Click();
 
             Assert.True(clicked);
         }

Radzen.Blazor.Tests/Markdown/BlockQuoteTests.cs

@@ -0,0 +1,314 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class BlockQuoteTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Fact]
+    public void Parse_BasicBlockQuote()
+    {
+
+        Assert.Equal(@"<document>
+    <block_quote>
+        <paragraph>
+            <text>foo</text>
+        </paragraph>
+    </block_quote>
+</document>", ToXml(@"> foo"));
+    }
+
+    [Theory]
+    [InlineData(@"> # Foo
+> bar
+> baz", @"<document>
+    <block_quote>
+        <heading level=""1"">
+            <text>Foo</text>
+        </heading>
+        <paragraph>
+            <text>bar</text>
+            <softbreak />
+            <text>baz</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"># Foo
+>bar
+> baz", @"<document>
+    <block_quote>
+        <heading level=""1"">
+            <text>Foo</text>
+        </heading>
+        <paragraph>
+            <text>bar</text>
+            <softbreak />
+            <text>baz</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"   > # Foo
+   > bar
+ > baz", @"<document>
+    <block_quote>
+        <heading level=""1"">
+            <text>Foo</text>
+        </heading>
+        <paragraph>
+            <text>bar</text>
+            <softbreak />
+            <text>baz</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"    > # Foo
+    > bar
+    > baz", @"<document>
+    <code_block>&gt; # Foo
+&gt; bar
+&gt; baz
+</code_block>
+</document>")]
+    [InlineData(@"> # Foo
+> bar
+baz", @"<document>
+    <block_quote>
+        <heading level=""1"">
+            <text>Foo</text>
+        </heading>
+        <paragraph>
+            <text>bar</text>
+            <softbreak />
+            <text>baz</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"> bar
+baz
+> foo", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>bar</text>
+            <softbreak />
+            <text>baz</text>
+            <softbreak />
+            <text>foo</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"> foo
+---", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>foo</text>
+        </paragraph>
+    </block_quote>
+    <thematic_break />
+</document>")]
+    [InlineData(@"> - foo
+- bar", @"<document>
+    <block_quote>
+        <list type=""bullet"" tight=""true"">
+            <item>
+                <paragraph>
+                    <text>foo</text>
+                </paragraph>
+            </item>
+        </list>
+    </block_quote>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@">     foo
+    bar", @"<document>
+    <block_quote>
+        <code_block>foo
+</code_block>
+    </block_quote>
+    <code_block>bar
+</code_block>
+</document>")]
+    [InlineData(@"> ```
+foo
+```", @"<document>
+    <block_quote>
+        <code_block></code_block>
+    </block_quote>
+    <paragraph>
+        <text>foo</text>
+    </paragraph>
+    <code_block></code_block>
+</document>")]
+    [InlineData(@"> foo
+    - bar", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>foo</text>
+            <softbreak />
+            <text>- bar</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@">", @"<document>
+    <block_quote />
+</document>")]
+    [InlineData(@">
+>  
+> ", @"<document>
+    <block_quote />
+</document>")]
+    [InlineData(@">
+> foo
+>  ", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>foo</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"> foo
+
+> bar", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>foo</text>
+        </paragraph>
+    </block_quote>
+    <block_quote>
+        <paragraph>
+            <text>bar</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"> foo
+>
+> bar", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>foo</text>
+        </paragraph>
+        <paragraph>
+            <text>bar</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"foo
+> bar", @"<document>
+    <paragraph>
+        <text>foo</text>
+    </paragraph>
+    <block_quote>
+        <paragraph>
+            <text>bar</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"> aaa
+***
+> bbb", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>aaa</text>
+        </paragraph>
+    </block_quote>
+    <thematic_break />
+    <block_quote>
+        <paragraph>
+            <text>bbb</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"> bar
+baz", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>bar</text>
+            <softbreak />
+            <text>baz</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"> bar
+
+baz", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>bar</text>
+        </paragraph>
+    </block_quote>
+    <paragraph>
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"> bar
+>
+baz", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>bar</text>
+        </paragraph>
+    </block_quote>
+    <paragraph>
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"> > > foo
+bar", @"<document>
+    <block_quote>
+        <block_quote>
+            <block_quote>
+                <paragraph>
+                    <text>foo</text>
+                    <softbreak />
+                    <text>bar</text>
+                </paragraph>
+            </block_quote>
+        </block_quote>
+    </block_quote>
+</document>")]
+    [InlineData(@">>> foo
+> bar
+>>baz", @"<document>
+    <block_quote>
+        <block_quote>
+            <block_quote>
+                <paragraph>
+                    <text>foo</text>
+                    <softbreak />
+                    <text>bar</text>
+                    <softbreak />
+                    <text>baz</text>
+                </paragraph>
+            </block_quote>
+        </block_quote>
+    </block_quote>
+</document>")]
+    [InlineData(@">     code
+
+>    not code", @"<document>
+    <block_quote>
+        <code_block>code
+</code_block>
+    </block_quote>
+    <block_quote>
+        <paragraph>
+            <text>not code</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    public void Parse_BlockQuote(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/CodeTests.cs

@@ -0,0 +1,175 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class CodeTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData("`foo`",
+@"<document>
+    <paragraph>
+        <code>foo</code>
+    </paragraph>
+</document>")]
+    [InlineData("`` foo ` bar ``",
+@"<document>
+    <paragraph>
+        <code>foo ` bar</code>
+    </paragraph>
+</document>")]
+    [InlineData("` `` `",
+@"<document>
+    <paragraph>
+        <code>``</code>
+    </paragraph>
+</document>")]
+    public void Parse_BasicCode_ReturnsCodeNode(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData("`  ``  `",
+@"<document>
+    <paragraph>
+        <code> `` </code>
+    </paragraph>
+</document>")]
+    [InlineData("` a`",
+@"<document>
+    <paragraph>
+        <code> a</code>
+    </paragraph>
+</document>")]
+    [InlineData(@"` `
+`  `",
+@"<document>
+    <paragraph>
+        <code> </code>
+        <softbreak />
+        <code>  </code>
+    </paragraph>
+</document>")]
+    public void Parse_CodeWithSpaces_PreservesSpaces(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+
+    [Theory]
+    [InlineData(@"``
+foo
+bar
+baz
+``",
+@"<document>
+    <paragraph>
+        <code>foo bar baz</code>
+    </paragraph>
+</document>")]
+    [InlineData(@"``
+foo 
+``",
+@"<document>
+    <paragraph>
+        <code>foo </code>
+    </paragraph>
+</document>")]
+    [InlineData(@"`foo   bar 
+baz`", 
+    @"<document>
+    <paragraph>
+        <code>foo   bar  baz</code>
+    </paragraph>
+</document>")]
+
+    public void Parse_CodeWithLineBreaks_ConvertsToSpace(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData("`foo\\`bar`", @"<document>
+    <paragraph>
+        <code>foo\</code>
+        <text>bar</text>
+        <text>`</text>
+    </paragraph>
+</document>")]
+    [InlineData("``foo`bar``", @"<document>
+    <paragraph>
+        <code>foo`bar</code>
+    </paragraph>
+</document>")]
+    [InlineData("` foo `` bar `", @"<document>
+    <paragraph>
+        <code>foo `` bar</code>
+    </paragraph>
+</document>")]
+    public void Parse_CodeWithBacktics(string mardown, string expected)
+    {
+        Assert.Equal(expected, ToXml(mardown));
+    }
+
+    [Theory]
+    [InlineData("*foo`*`", @"<document>
+    <paragraph>
+        <text>*</text>
+        <text>foo</text>
+        <code>*</code>
+    </paragraph>
+</document>")]
+    [InlineData("[not a `link](/foo`)", 
+    @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>not a </text>
+        <code>link](/foo</code>
+        <text>)</text>
+    </paragraph>
+</document>")]
+    [InlineData("`<https://foo.bar.`baz>`",@"<document>
+    <paragraph>
+        <code>&lt;https://foo.bar.</code>
+        <text>baz&gt;</text>
+        <text>`</text>
+    </paragraph>
+</document>")]
+    public void Parse_CodePrecedence(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData("```foo``", @"<document>
+    <paragraph>
+        <text>```</text>
+        <text>foo</text>
+        <text>``</text>
+    </paragraph>
+</document>")]
+    [InlineData("`foo", @"<document>
+    <paragraph>
+        <text>`</text>
+        <text>foo</text>
+    </paragraph>
+</document>")]
+    [InlineData("`foo``bar``", @"<document>
+    <paragraph>
+        <text>`</text>
+        <text>foo</text>
+        <code>bar</code>
+    </paragraph>
+</document>")]
+    public void Parse_UnmatchingBacktics(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+} 

Radzen.Blazor.Tests/Markdown/EmphasisTests.cs

@@ -0,0 +1,272 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class EmphasisTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"**foo** bar
+baz",@"<document>
+    <paragraph>
+        <strong>
+            <text>foo</text>
+        </strong>
+        <text> bar</text>
+        <softbreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData("*foo bar*",
+@"<document>
+    <paragraph>
+        <emph>
+            <text>foo bar</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("a * foo bar*",
+@"<document>
+    <paragraph>
+        <text>a </text>
+        <text>*</text>
+        <text> foo bar</text>
+        <text>*</text>
+    </paragraph>
+</document>")]
+    [InlineData("a*\"foo\"*",
+@"<document>
+    <paragraph>
+        <text>a</text>
+        <text>*</text>
+        <text>""foo""</text>
+        <text>*</text>
+    </paragraph>
+</document>")]
+    [InlineData("* a *",
+@"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a </text>
+                <text>*</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData("foo*bar*",
+@"<document>
+    <paragraph>
+        <text>foo</text>
+        <emph>
+            <text>bar</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("5*6*78",
+@"<document>
+    <paragraph>
+        <text>5</text>
+        <emph>
+            <text>6</text>
+        </emph>
+        <text>78</text>
+    </paragraph>
+</document>")]
+    [InlineData("_foo bar_",
+@"<document>
+    <paragraph>
+        <emph>
+            <text>foo bar</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("_ foo bar_",
+@"<document>
+    <paragraph>
+        <text>_</text>
+        <text> foo bar</text>
+        <text>_</text>
+    </paragraph>
+</document>")]
+    [InlineData("a_\"foo\"_",
+@"<document>
+    <paragraph>
+        <text>a</text>
+        <text>_</text>
+        <text>""foo""</text>
+        <text>_</text>
+    </paragraph>
+</document>")]
+    [InlineData("foo_bar_",
+@"<document>
+    <paragraph>
+        <text>foo</text>
+        <text>_</text>
+        <text>bar</text>
+        <text>_</text>
+    </paragraph>
+</document>")]
+    [InlineData("5_6_78",
+@"<document>
+    <paragraph>
+        <text>5</text>
+        <text>_</text>
+        <text>6</text>
+        <text>_</text>
+        <text>78</text>
+    </paragraph>
+</document>")]
+    [InlineData("пристаням_стремятся_",
+@"<document>
+    <paragraph>
+        <text>пристаням</text>
+        <text>_</text>
+        <text>стремятся</text>
+        <text>_</text>
+    </paragraph>
+</document>")]
+    [InlineData("aa_\"bb\"_cc",
+@"<document>
+    <paragraph>
+        <text>aa</text>
+        <text>_</text>
+        <text>""bb""</text>
+        <text>_</text>
+        <text>cc</text>
+    </paragraph>
+</document>")]
+    [InlineData("foo-_(bar)_",
+@"<document>
+    <paragraph>
+        <text>foo-</text>
+        <emph>
+            <text>(bar)</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("_foo*",
+@"<document>
+    <paragraph>
+        <text>_</text>
+        <text>foo</text>
+        <text>*</text>
+    </paragraph>
+</document>")]
+    [InlineData("*foo bar *",
+@"<document>
+    <paragraph>
+        <text>*</text>
+        <text>foo bar </text>
+        <text>*</text>
+    </paragraph>
+</document>")]
+    [InlineData("*foo bar\nbaz*",
+@"<document>
+    <paragraph>
+        <emph>
+            <text>foo bar</text>
+            <softbreak />
+            <text>baz</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("*(*foo)",
+@"<document>
+    <paragraph>
+        <text>*</text>
+        <text>(</text>
+        <text>*</text>
+        <text>foo)</text>
+    </paragraph>
+</document>")]
+    [InlineData("*(*foo*)*",
+@"<document>
+    <paragraph>
+        <emph>
+            <text>(</text>
+            <emph>
+                <text>foo</text>
+            </emph>
+            <text>)</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("*foo*bar",
+@"<document>
+    <paragraph>
+        <emph>
+            <text>foo</text>
+        </emph>
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData("_foo bar _",
+@"<document>
+    <paragraph>
+        <text>_</text>
+        <text>foo bar </text>
+        <text>_</text>
+    </paragraph>
+</document>")]
+    [InlineData("_(_foo_)_",
+@"<document>
+    <paragraph>
+        <emph>
+            <text>(</text>
+            <emph>
+                <text>foo</text>
+            </emph>
+            <text>)</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("_foo_bar",
+@"<document>
+    <paragraph>
+        <text>_</text>
+        <text>foo</text>
+        <text>_</text>
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData("_пристаням_стремятся",
+@"<document>
+    <paragraph>
+        <text>_</text>
+        <text>пристаням</text>
+        <text>_</text>
+        <text>стремятся</text>
+    </paragraph>
+</document>")]
+    [InlineData("_foo_bar_baz_",
+@"<document>
+    <paragraph>
+        <emph>
+            <text>foo</text>
+            <text>_</text>
+            <text>bar</text>
+            <text>_</text>
+            <text>baz</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("_(bar)_.",
+@"<document>
+    <paragraph>
+        <emph>
+            <text>(bar)</text>
+        </emph>
+        <text>.</text>
+    </paragraph>
+</document>")]
+    public void Parse_EmphasisRules_AdheresToCommonMarkSpec(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+} 

Radzen.Blazor.Tests/Markdown/FencedCodeBlockTests.cs

@@ -0,0 +1,264 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class FencedCodeBlockTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Fact]
+    public void Parse_BasicFencedCodeBlock()
+    {
+        Assert.Equal(@"<document>
+    <code_block>foo
+</code_block>
+</document>", ToXml(@"```
+foo
+```"));
+    }
+
+    [Theory]
+    [InlineData(@"```
+<
+ >
+```", @"<document>
+    <code_block>&lt;
+ &gt;
+</code_block>
+</document>")]
+    [InlineData(@"~~~
+<
+ >
+~~~", @"<document>
+    <code_block>&lt;
+ &gt;
+</code_block>
+</document>")]
+    [InlineData(@"``
+foo
+``", @"<document>
+    <paragraph>
+        <code>foo</code>
+    </paragraph>
+</document>")]
+    [InlineData(@"```
+aaa
+~~~
+```", @"<document>
+    <code_block>aaa
+~~~
+</code_block>
+</document>")]
+    [InlineData(@"~~~
+aaa
+```
+~~~", @"<document>
+    <code_block>aaa
+```
+</code_block>
+</document>")]
+    [InlineData(@"````
+aaa
+```
+``````", @"<document>
+    <code_block>aaa
+```
+</code_block>
+</document>")]
+    [InlineData(@"~~~~
+aaa
+~~~
+~~~~", @"<document>
+    <code_block>aaa
+~~~
+</code_block>
+</document>")]
+    [InlineData(@"```", @"<document>
+    <code_block></code_block>
+</document>")]
+    [InlineData(@"`````
+
+```
+aaa", @"<document>
+    <code_block>
+```
+aaa
+</code_block>
+</document>")]
+    [InlineData(@"> ```
+> aaa
+
+bbb", @"<document>
+    <block_quote>
+        <code_block>aaa
+</code_block>
+    </block_quote>
+    <paragraph>
+        <text>bbb</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"```
+
+  
+```", @"<document>
+    <code_block>
+  
+</code_block>
+</document>")]
+    [InlineData(@"```
+```", @"<document>
+    <code_block></code_block>
+</document>")]
+    [InlineData(@" ```
+ aaa
+aaa
+```", @"<document>
+    <code_block>aaa
+aaa
+</code_block>
+</document>")]
+    [InlineData(@"  ```
+aaa
+  aaa
+aaa
+  ```", @"<document>
+    <code_block>aaa
+aaa
+aaa
+</code_block>
+</document>")]
+    [InlineData(@"   ```
+   aaa
+    aaa
+  aaa
+   ```", @"<document>
+    <code_block>aaa
+ aaa
+aaa
+</code_block>
+</document>")]
+    [InlineData(@"    ```
+    aaa
+    ```", @"<document>
+    <code_block>```
+aaa
+```
+</code_block>
+</document>")]
+    [InlineData(@"```
+aaa
+  ```", @"<document>
+    <code_block>aaa
+</code_block>
+</document>")]
+    [InlineData(@"   ```
+aaa
+  ````", @"<document>
+    <code_block>aaa
+</code_block>
+</document>")]
+    [InlineData(@"```
+aaa
+    ```", @"<document>
+    <code_block>aaa
+    ```
+</code_block>
+</document>")]
+    [InlineData(@"``` ```
+aaa", @"<document>
+    <paragraph>
+        <code> </code>
+        <softbreak />
+        <text>aaa</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"~~~~~~
+aaa
+~~~ ~~", @"<document>
+    <code_block>aaa
+~~~ ~~
+</code_block>
+</document>")]
+    [InlineData(@"foo
+```
+bar
+```
+baz", @"<document>
+    <paragraph>
+        <text>foo</text>
+    </paragraph>
+    <code_block>bar
+</code_block>
+    <paragraph>
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo
+---
+~~~
+bar
+~~~
+# baz", @"<document>
+    <heading level=""2"">
+        <text>foo</text>
+    </heading>
+    <code_block>bar
+</code_block>
+    <heading level=""1"">
+        <text>baz</text>
+    </heading>
+</document>")]
+    [InlineData(@"```ruby
+def foo(x)
+  return 3
+end
+```", @"<document>
+    <code_block info=""ruby"">def foo(x)
+  return 3
+end
+</code_block>
+</document>")]
+    [InlineData(@"~~~~    ruby startline=3 $%@#$
+def foo(x)
+  return 3
+end
+~~~~~~~", @"<document>
+    <code_block info=""ruby startline=3 $%@#$"">def foo(x)
+  return 3
+end
+</code_block>
+</document>")]
+    [InlineData(@"````;
+````", @"<document>
+    <code_block info="";""></code_block>
+</document>")]
+    [InlineData(@"``` aa ```
+foo", @"<document>
+    <paragraph>
+        <code>aa</code>
+        <softbreak />
+        <text>foo</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"~~~ aa ``` ~~~
+foo
+~~~", @"<document>
+    <code_block info=""aa ``` ~~~"">foo
+</code_block>
+</document>")]
+    [InlineData(@"```
+``` aaa
+```", @"<document>
+    <code_block>``` aaa
+</code_block>
+</document>")]
+    public void Parse_FencedCodeBlock(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/HardLineBreakTests.cs

@@ -0,0 +1,132 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class HardLineBreakTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"foo  
+baz", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <linebreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData("foo  \r\nbaz", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <linebreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo\
+baz", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <linebreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo       
+baz", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <linebreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo  
+     bar", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <linebreak />
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo\
+     bar", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <linebreak />
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"*foo  
+bar*", @"<document>
+    <paragraph>
+        <emph>
+            <text>foo</text>
+            <linebreak />
+            <text>bar</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData(@"*foo\
+bar*", @"<document>
+    <paragraph>
+        <emph>
+            <text>foo</text>
+            <linebreak />
+            <text>bar</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData(@"`code\
+span`", @"<document>
+    <paragraph>
+        <code>code\ span</code>
+    </paragraph>
+</document>")]
+    [InlineData(@"`code  
+span`", @"<document>
+    <paragraph>
+        <code>code   span</code>
+    </paragraph>
+</document>")]
+    [InlineData(@"<a href=""foo  
+bar"">", @"<document>
+    <paragraph>
+        <html_inline>&lt;a href=""foo  
+bar""&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"<a href=""foo\
+bar"">", @"<document>
+    <paragraph>
+        <html_inline>&lt;a href=""foo\
+bar""&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo\", @"<document>
+    <paragraph>
+        <text>foo\</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo  ", @"<document>
+    <paragraph>
+        <text>foo</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"### foo\", @"<document>
+    <heading level=""3"">
+        <text>foo\</text>
+    </heading>
+</document>")]
+    [InlineData(@"### foo  ", @"<document>
+    <heading level=""3"">
+        <text>foo</text>
+    </heading>
+</document>")]
+    public void Parse_HardLineBreak(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/HeadingTests.cs

@@ -0,0 +1,511 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class HeadingTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Fact]
+    public void Parse_BasicAtxHeading()
+    {
+        Assert.Equal(@"<document>
+    <heading level=""1"">
+        <text>foo</text>
+    </heading>
+</document>", ToXml("# foo"));
+    }
+
+    [Theory]
+    [InlineData(@"# foo
+## foo
+### foo
+#### foo
+##### foo
+###### foo", @"<document>
+    <heading level=""1"">
+        <text>foo</text>
+    </heading>
+    <heading level=""2"">
+        <text>foo</text>
+    </heading>
+    <heading level=""3"">
+        <text>foo</text>
+    </heading>
+    <heading level=""4"">
+        <text>foo</text>
+    </heading>
+    <heading level=""5"">
+        <text>foo</text>
+    </heading>
+    <heading level=""6"">
+        <text>foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"####### foo", @"<document>
+    <paragraph>
+        <text>####### foo</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"#5 bolt
+
+#hashtag", @"<document>
+    <paragraph>
+        <text>#5 bolt</text>
+    </paragraph>
+    <paragraph>
+        <text>#hashtag</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"\## foo", @"<document>
+    <paragraph>
+        <text>#</text>
+        <text># foo</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"# foo *bar* \*baz\*", @"<document>
+    <heading level=""1"">
+        <text>foo </text>
+        <emph>
+            <text>bar</text>
+        </emph>
+        <text> </text>
+        <text>*</text>
+        <text>baz</text>
+        <text>*</text>
+    </heading>
+</document>")]
+    [InlineData(@"#                  foo                     ", @"<document>
+    <heading level=""1"">
+        <text>foo</text>
+    </heading>
+</document>")]
+    [InlineData(@" ### foo
+  ## foo
+   # foo", @"<document>
+    <heading level=""3"">
+        <text>foo</text>
+    </heading>
+    <heading level=""2"">
+        <text>foo</text>
+    </heading>
+    <heading level=""1"">
+        <text>foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"    # foo", @"<document>
+    <code_block># foo
+</code_block>
+</document>")]
+    [InlineData(@"foo
+    # bar", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <softbreak />
+        <text># bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"## foo ##
+  ###   bar    ###", @"<document>
+    <heading level=""2"">
+        <text>foo</text>
+    </heading>
+    <heading level=""3"">
+        <text>bar</text>
+    </heading>
+</document>")]
+    [InlineData(@"# foo ##################################
+##### foo ##", @"<document>
+    <heading level=""1"">
+        <text>foo</text>
+    </heading>
+    <heading level=""5"">
+        <text>foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"### foo ###     ", @"<document>
+    <heading level=""3"">
+        <text>foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"### foo ### b", @"<document>
+    <heading level=""3"">
+        <text>foo ### b</text>
+    </heading>
+</document>")]
+    [InlineData(@"# foo#", @"<document>
+    <heading level=""1"">
+        <text>foo#</text>
+    </heading>
+</document>")]
+    [InlineData(@"### foo \###
+## foo #\##
+# foo \#", @"<document>
+    <heading level=""3"">
+        <text>foo </text>
+        <text>#</text>
+        <text>##</text>
+    </heading>
+    <heading level=""2"">
+        <text>foo #</text>
+        <text>#</text>
+        <text>#</text>
+    </heading>
+    <heading level=""1"">
+        <text>foo </text>
+        <text>#</text>
+    </heading>
+</document>")]
+    [InlineData(@"****
+## foo
+****", @"<document>
+    <thematic_break />
+    <heading level=""2"">
+        <text>foo</text>
+    </heading>
+    <thematic_break />
+</document>")]
+    [InlineData(@"Foo bar
+# baz
+Bar foo", @"<document>
+    <paragraph>
+        <text>Foo bar</text>
+    </paragraph>
+    <heading level=""1"">
+        <text>baz</text>
+    </heading>
+    <paragraph>
+        <text>Bar foo</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"## 
+#
+### ###", @"<document>
+    <heading level=""2"" />
+    <heading level=""1"" />
+    <heading level=""3"" />
+</document>")]
+    public void Parse_AtxHeading(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"Foo *bar*
+=========
+
+Foo *baz*
+---------", @"<document>
+    <heading level=""1"">
+        <text>Foo </text>
+        <emph>
+            <text>bar</text>
+        </emph>
+    </heading>
+    <heading level=""2"">
+        <text>Foo </text>
+        <emph>
+            <text>baz</text>
+        </emph>
+    </heading>
+</document>")]
+    [InlineData(@"Foo *bar
+baz*
+====", @"<document>
+    <heading level=""1"">
+        <text>Foo </text>
+        <emph>
+            <text>bar</text>
+            <softbreak />
+            <text>baz</text>
+        </emph>
+    </heading>
+</document>")]
+    [InlineData(@"  Foo *bar
+baz*
+====", @"<document>
+    <heading level=""1"">
+        <text>Foo </text>
+        <emph>
+            <text>bar</text>
+            <softbreak />
+            <text>baz</text>
+        </emph>
+    </heading>
+</document>")]
+    [InlineData(@"Foo
+-------------------------
+
+Foo
+=", @"<document>
+    <heading level=""2"">
+        <text>Foo</text>
+    </heading>
+    <heading level=""1"">
+        <text>Foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"   Foo
+---
+
+  Foo
+-----
+
+  Foo
+  ===", @"<document>
+    <heading level=""2"">
+        <text>Foo</text>
+    </heading>
+    <heading level=""2"">
+        <text>Foo</text>
+    </heading>
+    <heading level=""1"">
+        <text>Foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"    Foo
+    ---
+
+    Foo
+---", @"<document>
+    <code_block>Foo
+---
+
+Foo
+</code_block>
+    <thematic_break />
+</document>")]
+    [InlineData(@"Foo
+   ----      ", @"<document>
+    <heading level=""2"">
+        <text>Foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"Foo
+    ---", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <text>---</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"Foo
+= =
+
+Foo
+--- -", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <text>= =</text>
+    </paragraph>
+    <paragraph>
+        <text>Foo</text>
+    </paragraph>
+    <thematic_break />
+</document>")]
+    [InlineData(@"Foo  
+-----", @"<document>
+    <heading level=""2"">
+        <text>Foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"Foo\
+----", @"<document>
+    <heading level=""2"">
+        <text>Foo\</text>
+    </heading>
+</document>")]
+    [InlineData(@"`Foo
+----
+`
+
+<a title=""a lot
+---
+of dashes""/>", @"<document>
+    <heading level=""2"">
+        <text>`</text>
+        <text>Foo</text>
+    </heading>
+    <paragraph>
+        <text>`</text>
+    </paragraph>
+    <heading level=""2"">
+        <text>&lt;a title=""a lot</text>
+    </heading>
+    <paragraph>
+        <text>of dashes""/&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"> Foo
+---", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>Foo</text>
+        </paragraph>
+    </block_quote>
+    <thematic_break />
+</document>")]
+    [InlineData(@"> foo
+bar
+===", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>foo</text>
+            <softbreak />
+            <text>bar</text>
+            <softbreak />
+            <text>===</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"- Foo
+---", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>Foo</text>
+            </paragraph>
+        </item>
+    </list>
+    <thematic_break />
+</document>")]
+    [InlineData(@"Foo
+Bar
+---", @"<document>
+    <heading level=""2"">
+        <text>Foo</text>
+        <softbreak />
+        <text>Bar</text>
+    </heading>
+</document>")]
+    [InlineData(@"---
+Foo
+---
+Bar
+---
+Baz", @"<document>
+    <thematic_break />
+    <heading level=""2"">
+        <text>Foo</text>
+    </heading>
+    <heading level=""2"">
+        <text>Bar</text>
+    </heading>
+    <paragraph>
+        <text>Baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"
+====", @"<document>
+    <paragraph>
+        <text>====</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"---
+---", @"<document>
+    <thematic_break />
+    <thematic_break />
+</document>")]
+    [InlineData(@"- foo
+-----", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+    </list>
+    <thematic_break />
+</document>")]
+    [InlineData(@"    foo
+---", @"<document>
+    <code_block>foo
+</code_block>
+    <thematic_break />
+</document>")]
+    [InlineData(@"> foo
+-----", @"<document>
+    <block_quote>
+        <paragraph>
+            <text>foo</text>
+        </paragraph>
+    </block_quote>
+    <thematic_break />
+</document>")]
+    [InlineData(@"\> foo
+------", @"<document>
+    <heading level=""2"">
+        <text>&gt; foo</text>
+    </heading>
+</document>")]
+    [InlineData(@"Foo
+
+bar
+---
+baz", @"<document>
+    <paragraph>
+        <text>Foo</text>
+    </paragraph>
+    <heading level=""2"">
+        <text>bar</text>
+    </heading>
+    <paragraph>
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"Foo
+bar
+
+---
+
+baz", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <text>bar</text>
+    </paragraph>
+    <thematic_break />
+    <paragraph>
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"Foo
+bar
+* * *
+baz", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <text>bar</text>
+    </paragraph>
+    <thematic_break />
+    <paragraph>
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"Foo
+bar
+\---
+baz", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <text>bar</text>
+        <softbreak />
+        <text>-</text>
+        <text>--</text>
+        <softbreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    public void Parse_SetExtHeading(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/HtmlBlockTests.cs

@@ -0,0 +1,487 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class HtmlBlockTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"<table><tr><td>
+<pre>
+**Hello**,
+
+_world_.
+</pre>
+</td></tr></table>", @"<document>
+    <html_block>&lt;table&gt;&lt;tr&gt;&lt;td&gt;
+&lt;pre&gt;
+**Hello**,</html_block>
+    <paragraph>
+        <emph>
+            <text>world</text>
+        </emph>
+        <text>.</text>
+        <softbreak />
+        <html_inline>&lt;/pre&gt;</html_inline>
+    </paragraph>
+    <html_block>&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;</html_block>
+</document>")]
+    [InlineData(@"<table>
+  <tr>
+    <td>
+           hi
+    </td>
+  </tr>
+</table>
+
+okay.", @"<document>
+    <html_block>&lt;table&gt;
+  &lt;tr&gt;
+    &lt;td&gt;
+           hi
+    &lt;/td&gt;
+  &lt;/tr&gt;
+&lt;/table&gt;</html_block>
+    <paragraph>
+        <text>okay.</text>
+    </paragraph>
+</document>")]
+    [InlineData(@" <div>
+  *hello*
+         <foo><a>", @"<document>
+    <html_block> &lt;div&gt;
+  *hello*
+         &lt;foo&gt;&lt;a&gt;</html_block>
+</document>")]
+    [InlineData(@"</div>
+*foo*", @"<document>
+    <html_block>&lt;/div&gt;
+*foo*</html_block>
+</document>")]
+    [InlineData(@"<DIV CLASS=""foo"">
+
+*Markdown*
+
+</DIV>", @"<document>
+    <html_block>&lt;DIV CLASS=""foo""&gt;</html_block>
+    <paragraph>
+        <emph>
+            <text>Markdown</text>
+        </emph>
+    </paragraph>
+    <html_block>&lt;/DIV&gt;</html_block>
+</document>")]
+    [InlineData(@"<div id=""foo""
+  class=""bar"">
+</div>", @"<document>
+    <html_block>&lt;div id=""foo""
+  class=""bar""&gt;
+&lt;/div&gt;</html_block>
+</document>")]
+    [InlineData(@"<div id=""foo"" class=""bar
+  baz"">
+</div>", @"<document>
+    <html_block>&lt;div id=""foo"" class=""bar
+  baz""&gt;
+&lt;/div&gt;</html_block>
+</document>")]
+    [InlineData(@"<div>
+*foo*
+
+*bar*", @"<document>
+    <html_block>&lt;div&gt;
+*foo*</html_block>
+    <paragraph>
+        <emph>
+            <text>bar</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData(@"<div id=""foo""
+*hi*", @"<document>
+    <html_block>&lt;div id=""foo""
+*hi*</html_block>
+</document>")]
+    [InlineData(@"<div class
+foo", @"<document>
+    <html_block>&lt;div class
+foo</html_block>
+</document>")]
+    [InlineData(@"<div *???-&&&-<---
+*foo*", @"<document>
+    <html_block>&lt;div *???-&amp;&amp;&amp;-&lt;---
+*foo*</html_block>
+</document>")]
+    [InlineData(@"<div><a href=""bar"">*foo*</a></div>", @"<document>
+    <html_block>&lt;div&gt;&lt;a href=""bar""&gt;*foo*&lt;/a&gt;&lt;/div&gt;</html_block>
+</document>")]
+    [InlineData(@"<table><tr><td>
+foo
+</td></tr></table>", @"<document>
+    <html_block>&lt;table&gt;&lt;tr&gt;&lt;td&gt;
+foo
+&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;</html_block>
+</document>")]
+    [InlineData(@"<div></div>
+``` c
+int x = 33;
+```", @"<document>
+    <html_block>&lt;div&gt;&lt;/div&gt;
+``` c
+int x = 33;
+```</html_block>
+</document>")]
+    [InlineData(@"<a href=""foo"">
+*bar*
+</a>", @"<document>
+    <html_block>&lt;a href=""foo""&gt;
+*bar*
+&lt;/a&gt;</html_block>
+</document>")]
+    [InlineData(@"<Warning>
+*bar*
+</Warning>", @"<document>
+    <html_block>&lt;Warning&gt;
+*bar*
+&lt;/Warning&gt;</html_block>
+</document>")]
+    [InlineData(@"<i class=""foo"">
+*bar*
+</i>", @"<document>
+    <html_block>&lt;i class=""foo""&gt;
+*bar*
+&lt;/i&gt;</html_block>
+</document>")]
+    [InlineData(@"</ins>
+*bar*", @"<document>
+    <html_block>&lt;/ins&gt;
+*bar*</html_block>
+</document>")]
+    [InlineData(@"<del>
+*foo*
+</del>", @"<document>
+    <html_block>&lt;del&gt;
+*foo*
+&lt;/del&gt;</html_block>
+</document>")]
+    [InlineData(@"<del>
+
+*foo*
+
+</del>", @"<document>
+    <html_block>&lt;del&gt;</html_block>
+    <paragraph>
+        <emph>
+            <text>foo</text>
+        </emph>
+    </paragraph>
+    <html_block>&lt;/del&gt;</html_block>
+</document>")]
+    [InlineData(@"<del>*foo*</del>", @"<document>
+    <paragraph>
+        <html_inline>&lt;del&gt;</html_inline>
+        <emph>
+            <text>foo</text>
+        </emph>
+        <html_inline>&lt;/del&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"<pre language=""haskell""><code>
+import Text.HTML.TagSoup
+
+main :: IO ()
+main = print $ parseTags tags
+</code></pre>
+okay", @"<document>
+    <html_block>&lt;pre language=""haskell""&gt;&lt;code&gt;
+import Text.HTML.TagSoup
+
+main :: IO ()
+main = print $ parseTags tags
+&lt;/code&gt;&lt;/pre&gt;</html_block>
+    <paragraph>
+        <text>okay</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<script type=""text/javascript"">
+// JavaScript example
+
+document.getElementById(""demo"").innerHTML = ""Hello JavaScript!"";
+</script>
+okay", @"<document>
+    <html_block>&lt;script type=""text/javascript""&gt;
+// JavaScript example
+
+document.getElementById(""demo"").innerHTML = ""Hello JavaScript!"";
+&lt;/script&gt;</html_block>
+    <paragraph>
+        <text>okay</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<textarea>
+
+*foo*
+
+_bar_
+
+</textarea>", @"<document>
+    <html_block>&lt;textarea&gt;
+
+*foo*
+
+_bar_
+
+&lt;/textarea&gt;</html_block>
+</document>")]
+    [InlineData(@"<style
+  type=""text/css"">
+h1 {color:red;}
+
+p {color:blue;}
+</style>
+okay",@"<document>
+    <html_block>&lt;style
+  type=""text/css""&gt;
+h1 {color:red;}
+
+p {color:blue;}
+&lt;/style&gt;</html_block>
+    <paragraph>
+        <text>okay</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<style
+  type=""text/css"">
+
+foo", @"<document>
+    <html_block>&lt;style
+  type=""text/css""&gt;
+
+foo</html_block>
+</document>")]
+    [InlineData(@"> <div>
+> foo
+
+bar", @"<document>
+    <block_quote>
+        <html_block>&lt;div&gt;
+foo</html_block>
+    </block_quote>
+    <paragraph>
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"- <div>
+- foo", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <html_block>&lt;div&gt;</html_block>
+        </item>
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"<style>p{color:red;}</style>
+*foo*", @"<document>
+    <html_block>&lt;style&gt;p{color:red;}&lt;/style&gt;</html_block>
+    <paragraph>
+        <emph>
+            <text>foo</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData(@"<!-- foo -->*bar*
+*baz*", @"<document>
+    <html_block>&lt;!-- foo --&gt;*bar*</html_block>
+    <paragraph>
+        <emph>
+            <text>baz</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData(@"<script>
+foo
+</script>1. *bar*", @"<document>
+    <html_block>&lt;script&gt;
+foo
+&lt;/script&gt;1. *bar*</html_block>
+</document>")]
+    [InlineData(@"<!-- Foo
+
+bar
+   baz -->
+okay", @"<document>
+    <html_block>&lt;!-- Foo
+
+bar
+   baz --&gt;</html_block>
+    <paragraph>
+        <text>okay</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<?php
+
+  echo '>';
+
+?>
+okay", @"<document>
+    <html_block>&lt;?php
+
+  echo '&gt;';
+
+?&gt;</html_block>
+    <paragraph>
+        <text>okay</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<!DOCTYPE html>", @"<document>
+    <html_block>&lt;!DOCTYPE html&gt;</html_block>
+</document>")]
+    [InlineData(@"<![CDATA[
+function matchwo(a,b)
+{
+  if (a < b && a < 0) then {
+    return 1;
+
+  } else {
+
+    return 0;
+  }
+}
+]]>
+okay", @"<document>
+    <html_block>&lt;![CDATA[
+function matchwo(a,b)
+{
+  if (a &lt; b &amp;&amp; a &lt; 0) then {
+    return 1;
+
+  } else {
+
+    return 0;
+  }
+}
+]]&gt;</html_block>
+    <paragraph>
+        <text>okay</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"  <!-- foo -->
+
+    <!-- foo -->", @"<document>
+    <html_block>  &lt;!-- foo --&gt;</html_block>
+    <code_block>&lt;!-- foo --&gt;
+</code_block>
+</document>")]
+    [InlineData(@"  <div>
+
+    <div>", @"<document>
+    <html_block>  &lt;div&gt;</html_block>
+    <code_block>&lt;div&gt;
+</code_block>
+</document>")]
+    [InlineData(@"Foo
+<div>
+bar
+</div>", @"<document>
+    <paragraph>
+        <text>Foo</text>
+    </paragraph>
+    <html_block>&lt;div&gt;
+bar
+&lt;/div&gt;</html_block>
+</document>")]
+    [InlineData(@"<div>
+bar
+</div>
+*foo*", @"<document>
+    <html_block>&lt;div&gt;
+bar
+&lt;/div&gt;
+*foo*</html_block>
+</document>")]
+    [InlineData(@"Foo
+<a href=""bar"">
+baz", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <html_inline>&lt;a href=""bar""&gt;</html_inline>
+        <softbreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<div>
+
+*Emphasized* text.
+
+</div>", @"<document>
+    <html_block>&lt;div&gt;</html_block>
+    <paragraph>
+        <emph>
+            <text>Emphasized</text>
+        </emph>
+        <text> text.</text>
+    </paragraph>
+    <html_block>&lt;/div&gt;</html_block>
+</document>")]
+    [InlineData(@"<div>
+*Emphasized* text.
+</div>", @"<document>
+    <html_block>&lt;div&gt;
+*Emphasized* text.
+&lt;/div&gt;</html_block>
+</document>")]
+    [InlineData(@"<table>
+
+<tr>
+
+<td>
+Hi
+</td>
+
+</tr>
+
+</table>", @"<document>
+    <html_block>&lt;table&gt;</html_block>
+    <html_block>&lt;tr&gt;</html_block>
+    <html_block>&lt;td&gt;
+Hi
+&lt;/td&gt;</html_block>
+    <html_block>&lt;/tr&gt;</html_block>
+    <html_block>&lt;/table&gt;</html_block>
+</document>")]
+    [InlineData(@"<table>
+
+  <tr>
+
+    <td>
+      Hi
+    </td>
+
+  </tr>
+
+</table>", @"<document>
+    <html_block>&lt;table&gt;</html_block>
+    <html_block>  &lt;tr&gt;</html_block>
+    <code_block>&lt;td&gt;
+  Hi
+&lt;/td&gt;
+</code_block>
+    <html_block>  &lt;/tr&gt;</html_block>
+    <html_block>&lt;/table&gt;</html_block>
+</document>")]
+    public void Parse_HtmlBlock(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/HtmlInlineTests.cs

@@ -0,0 +1,144 @@
+
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class HtmlInlineTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"<a><bab><c2c>", @"<document>
+    <paragraph>
+        <html_inline>&lt;a&gt;</html_inline>
+        <html_inline>&lt;bab&gt;</html_inline>
+        <html_inline>&lt;c2c&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"<a/><b2/>", @"<document>
+    <paragraph>
+        <html_inline>&lt;a/&gt;</html_inline>
+        <html_inline>&lt;b2/&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"<a  /><b2
+data=""foo"" >", @"<document>
+    <paragraph>
+        <html_inline>&lt;a  /&gt;</html_inline>
+        <html_inline>&lt;b2
+data=""foo"" &gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"<a foo=""bar"" bam = 'baz <em>""</em>'
+_boolean zoop:33=zoop:33 />", @"<document>
+    <paragraph>
+        <html_inline>&lt;a foo=""bar"" bam = 'baz &lt;em&gt;""&lt;/em&gt;'
+_boolean zoop:33=zoop:33 /&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"Foo <responsive-image src=""foo.jpg"" />", @"<document>
+    <paragraph>
+        <text>Foo </text>
+        <html_inline>&lt;responsive-image src=""foo.jpg"" /&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData("<33> <__>", @"<document>
+    <paragraph>
+        <text>&lt;33&gt; &lt;</text>
+        <text>__</text>
+        <text>&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<a h*#ref=""hi"">", @"<document>
+    <paragraph>
+        <text>&lt;a h</text>
+        <text>*</text>
+        <text>#ref=""hi""&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<a href='bar'title=title>", @"<document>
+    <paragraph>
+        <text>&lt;a href='bar'title=title&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"</a></foo >", @"<document>
+    <paragraph>
+        <html_inline>&lt;/a&gt;</html_inline>
+        <html_inline>&lt;/foo &gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"</a href=""foo"">", @"<document>
+    <paragraph>
+        <text>&lt;/a href=""foo""&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo <!-- this is a --
+comment - with hyphens -->", @"<document>
+    <paragraph>
+        <text>foo </text>
+        <html_inline>&lt;!-- this is a --
+comment - with hyphens --&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo <!--> foo -->
+
+foo <!---> foo -->
+", @"<document>
+    <paragraph>
+        <text>foo </text>
+        <html_inline>&lt;!--&gt;</html_inline>
+        <text> foo --&gt;</text>
+    </paragraph>
+    <paragraph>
+        <text>foo </text>
+        <html_inline>&lt;!---&gt;</html_inline>
+        <text> foo --&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo <?php echo $a; ?>", @"<document>
+    <paragraph>
+        <text>foo </text>
+        <html_inline>&lt;?php echo $a; ?&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo <!ELEMENT br EMPTY>", @"<document>
+    <paragraph>
+        <text>foo </text>
+        <html_inline>&lt;!ELEMENT br EMPTY&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo <![CDATA[>&<]]>", @"<document>
+    <paragraph>
+        <text>foo </text>
+        <html_inline>&lt;![CDATA[&gt;&amp;&lt;]]&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo <a href=""&ouml;"">", @"<document>
+    <paragraph>
+        <text>foo </text>
+        <html_inline>&lt;a href=""&amp;ouml;""&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo <a href=""\*"">", @"<document>
+    <paragraph>
+        <text>foo </text>
+        <html_inline>&lt;a href=""\*""&gt;</html_inline>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo <a href=""\"""">", @"<document>
+    <paragraph>
+        <text>foo &lt;a href=""</text>
+        <text>""</text>
+        <text>""&gt;</text>
+    </paragraph>
+</document>")]
+    public void Parse_Html(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/ImageTests.cs

@@ -0,0 +1,85 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class ImageTests
+{
+
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"![foo](/url ""title"")", @"<document>
+    <paragraph>
+        <image destination=""/url"" title=""title"">
+            <text>foo</text>
+        </image>
+    </paragraph>
+</document>")]
+    [InlineData(@"![foo ![bar](/url)](/url2)", @"<document>
+    <paragraph>
+        <image destination=""/url2"" title="""">
+            <text>foo </text>
+            <image destination=""/url"" title="""">
+                <text>bar</text>
+            </image>
+        </image>
+    </paragraph>
+</document>")]
+    [InlineData(@"![foo [bar](/url)](/url2)", @"<document>
+    <paragraph>
+        <image destination=""/url2"" title="""">
+            <text>foo </text>
+            <link destination=""/url"" title="""">
+                <text>bar</text>
+            </link>
+        </image>
+    </paragraph>
+</document>")]
+    [InlineData(@"![foo](train.jpg)", @"<document>
+    <paragraph>
+        <image destination=""train.jpg"" title="""">
+            <text>foo</text>
+        </image>
+    </paragraph>
+</document>")]
+    [InlineData(@"My ![foo bar](/path/to/train.jpg  ""title""   )", @"<document>
+    <paragraph>
+        <text>My </text>
+        <image destination=""/path/to/train.jpg"" title=""title"">
+            <text>foo bar</text>
+        </image>
+    </paragraph>
+</document>")]
+    [InlineData(@"![foo](<url>)", @"<document>
+    <paragraph>
+        <image destination=""url"" title="""">
+            <text>foo</text>
+        </image>
+    </paragraph>
+</document>")]
+    [InlineData(@"![](/url)", @"<document>
+    <paragraph>
+        <image destination=""/url"" title="""" />
+    </paragraph>
+</document>")]
+    [InlineData(@"__Applications__ ![macOS DMG](/assets/img/macOS-drag-and-drop.png)", @"<document>
+    <paragraph>
+        <strong>
+            <text>Applications</text>
+        </strong>
+        <text> </text>
+        <image destination=""/assets/img/macOS-drag-and-drop.png"" title="""">
+            <text>macOS DMG</text>
+        </image>
+    </paragraph>
+</document>")]
+    public void Parse_BasicImages_ReturnsImageElement(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/IndentedCodeBlockTests.cs

@@ -0,0 +1,145 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class IndentedCodeBlockTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"    a simple
+      indented code block
+", @"<document>
+    <code_block>a simple
+  indented code block
+</code_block>
+</document>")]
+    [InlineData(@"  - foo
+
+    bar", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(
+@"
+1.  foo
+
+    - bar", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>bar</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"    <a/>
+    *hi*
+
+    - one", @"<document>
+    <code_block>&lt;a/&gt;
+*hi*
+
+- one
+</code_block>
+</document>")]
+    [InlineData(@"    chunk1
+
+    chunk2
+  
+ 
+ 
+    chunk3", @"<document>
+    <code_block>chunk1
+
+chunk2
+
+
+
+chunk3
+</code_block>
+</document>")]
+    [InlineData(@"    chunk1
+      
+      chunk2", @"<document>
+    <code_block>chunk1
+  
+  chunk2
+</code_block>
+</document>")]
+    [InlineData(@"Foo
+    bar", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"    foo
+bar", @"<document>
+    <code_block>foo
+</code_block>
+    <paragraph>
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"# Heading
+    foo
+Heading
+------
+    foo
+----", @"<document>
+    <heading level=""1"">
+        <text>Heading</text>
+    </heading>
+    <code_block>foo
+</code_block>
+    <heading level=""2"">
+        <text>Heading</text>
+    </heading>
+    <code_block>foo
+</code_block>
+    <thematic_break />
+</document>")]
+    [InlineData(@"        foo
+    bar", @"<document>
+    <code_block>    foo
+bar
+</code_block>
+</document>")]
+    [InlineData(@"
+    
+    foo
+", @"<document>
+    <code_block>foo
+</code_block>
+</document>")]
+    [InlineData(@"    foo  ", @"<document>
+    <code_block>foo  
+</code_block>
+</document>")]
+    public void Parse_IndentedCodeBlock(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/LinkTests.cs

@@ -0,0 +1,852 @@
+using System.Runtime.InteropServices;
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class LinkTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData("[link](/uri \"title\")",
+@"<document>
+    <paragraph>
+        <link destination=""/uri"" title=""title"">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData("[link](/uri)", @"<document>
+    <paragraph>
+        <link destination=""/uri"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData("[](./target.md)", @"<document>
+    <paragraph>
+        <link destination=""./target.md"" title="""" />
+    </paragraph>
+</document>")]
+    [InlineData("[link]()", @"<document>
+    <paragraph>
+        <link destination="""" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData("[link](<>)", @"<document>
+    <paragraph>
+        <link destination="""" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData("[]()", @"<document>
+    <paragraph>
+        <link destination="""" title="""" />
+    </paragraph>
+</document>")]
+    public void Parse_BasicLinks_ReturnsLinkNode(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData("[link](/my uri)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>link</text>
+        <text>](/my uri)</text>
+    </paragraph>
+</document>")]
+    [InlineData("[link](</my uri>)", @"<document>
+    <paragraph>
+        <link destination=""/my uri"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    public void Parse_LinkDestinationWithSpaces(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link](foo
+bar)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>link</text>
+        <text>](foo</text>
+        <softbreak />
+        <text>bar)</text>
+    </paragraph>
+</document>")]
+
+    public void Parse_LinkDestinationWithNewLines(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[a](<b)c>)", @"<document>
+    <paragraph>
+        <link destination=""b)c"" title="""">
+            <text>a</text>
+        </link>
+    </paragraph>
+</document>")]
+    public void Parse_LinkDestinationWithCloseParenthesis(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link](<foo\>)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>link</text>
+        <text>](&lt;foo&gt;)</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[a](<b)c
+[a](<b)c>
+[a](<b>c)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>a</text>
+        <text>](&lt;b)c</text>
+        <softbreak />
+        <text>[</text>
+        <text>a</text>
+        <text>](&lt;b)c&gt;</text>
+        <softbreak />
+        <text>[</text>
+        <text>a</text>
+        <text>](</text>
+        <html_inline>&lt;b&gt;</html_inline>
+        <text>c)</text>
+    </paragraph>
+</document>")]
+    public void Parse_LinkDestinationUnclosedPointyBracket(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link](\(foo\))", @"<document>
+    <paragraph>
+        <link destination=""(foo)"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link](foo\)\:)", @"<document>
+    <paragraph>
+        <link destination=""foo):"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link](foo\bar)", @"<document>
+    <paragraph>
+        <link destination=""foo\bar"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    public void Parse_Escapes(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link](foo(and(bar)))", @"<document>
+    <paragraph>
+        <link destination=""foo(and(bar))"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link](foo(and(bar))", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>link</text>
+        <text>](foo(and(bar))</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link](foo\(and\(bar\))", @"<document>
+    <paragraph>
+        <link destination=""foo(and(bar)"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link](<foo(and(bar)>)", @"<document>
+    <paragraph>
+        <link destination=""foo(and(bar)"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    public void Parse_BallancedParenthesisInLinkDestination(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link](#fragment)
+[link](https://example.com#fragment)
+[link](https://example.com?foo=3#frag)", @"<document>
+    <paragraph>
+        <link destination=""#fragment"" title="""">
+            <text>link</text>
+        </link>
+        <softbreak />
+        <link destination=""https://example.com#fragment"" title="""">
+            <text>link</text>
+        </link>
+        <softbreak />
+        <link destination=""https://example.com?foo=3#frag"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    public void Parse_FragmentAndQueryStringInLinkDestination(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link](""title"")", @"<document>
+    <paragraph>
+        <link destination=""&quot;title&quot;"" title="""">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    public void Parse_QuotesInDestination(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link](/url ""title"")
+[link](/url 'title')
+[link](/url (title))", @"<document>
+    <paragraph>
+        <link destination=""/url"" title=""title"">
+            <text>link</text>
+        </link>
+        <softbreak />
+        <link destination=""/url"" title=""title"">
+            <text>link</text>
+        </link>
+        <softbreak />
+        <link destination=""/url"" title=""title"">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link](/url ""title ""and"" title"")", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>link</text>
+        <text>](/url ""title ""and"" title"")</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link](/url 'title ""and"" title')", @"<document>
+    <paragraph>
+        <link destination=""/url"" title=""title &quot;and&quot; title"">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")] 
+    public void Parse_Title(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link](   /url
+  ""title""  )", @"<document>
+    <paragraph>
+        <link destination=""/url"" title=""title"">
+            <text>link</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link] (/uri)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>link</text>
+        <text>] (/uri)</text>
+    </paragraph>
+</document>")]
+    public void Parse_SpacesInLink(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link [foo [bar]]](/uri)", @"<document>
+    <paragraph>
+        <link destination=""/uri"" title="""">
+            <text>link </text>
+            <text>[</text>
+            <text>foo </text>
+            <text>[</text>
+            <text>bar</text>
+            <text>]</text>
+            <text>]</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link] bar](/uri)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>link</text>
+        <text>] bar](/uri)</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link [bar](/uri)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>link </text>
+        <link destination=""/uri"" title="""">
+            <text>bar</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[link \[bar](/uri)", @"<document>
+    <paragraph>
+        <link destination=""/uri"" title="""">
+            <text>link </text>
+            <text>[</text>
+            <text>bar</text>
+        </link>
+    </paragraph>
+</document>")]
+    public void Parse_BracketsInText(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[link *foo **bar** `#`*](/uri)", @"<document>
+    <paragraph>
+        <link destination=""/uri"" title="""">
+            <text>link </text>
+            <emph>
+                <text>foo </text>
+                <strong>
+                    <text>bar</text>
+                </strong>
+                <text> </text>
+                <code>#</code>
+            </emph>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[![alt](img)](url)", @"<document>
+    <paragraph>
+        <link destination=""url"" title="""">
+            <image destination=""img"" title="""">
+                <text>alt</text>
+            </image>
+        </link>
+    </paragraph>
+</document>")]
+
+    public void Parse_LinkTextIsInlineContent(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[foo [bar](/uri)](/uri)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>foo </text>
+        <link destination=""/uri"" title="""">
+            <text>bar</text>
+        </link>
+        <text>](/uri)</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo *[bar [baz](/uri)](/uri)*](/uri)", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>foo </text>
+        <emph>
+            <text>[</text>
+            <text>bar </text>
+            <link destination=""/uri"" title="""">
+                <text>baz</text>
+            </link>
+            <text>](/uri)</text>
+        </emph>
+        <text>](/uri)</text>
+    </paragraph>
+</document>")]
+    public void Parse_NestedLinks(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"*[foo*](/uri)", @"<document>
+    <paragraph>
+        <text>*</text>
+        <link destination=""/uri"" title="""">
+            <text>foo</text>
+            <text>*</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo *bar](baz*)", @"<document>
+    <paragraph>
+        <link destination=""baz*"" title="""">
+            <text>foo </text>
+            <text>*</text>
+            <text>bar</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"*foo [bar* baz]", @"<document>
+    <paragraph>
+        <emph>
+            <text>foo </text>
+            <text>[</text>
+            <text>bar</text>
+        </emph>
+        <text> baz</text>
+        <text>]</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo`](/uri)`", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <code>](/uri)</code>
+    </paragraph>
+</document>")]
+    public void Parse_Precedence(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"<http://foo.bar.baz>", @"<document>
+    <paragraph>
+        <link destination=""http://foo.bar.baz"" title="""">
+            <text>http://foo.bar.baz</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"<https://foo.bar.baz/test?q=hello&id=22&boolean>", @"<document>
+    <paragraph>
+        <link destination=""https://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean"" title="""">
+            <text>https://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"<irc://foo.bar:2233/baz>", @"<document>
+    <paragraph>
+        <link destination=""irc://foo.bar:2233/baz"" title="""">
+            <text>irc://foo.bar:2233/baz</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"<MAILTO:FOO@BAR.BAZ>", @"<document>
+    <paragraph>
+        <link destination=""MAILTO:FOO@BAR.BAZ"" title="""">
+            <text>MAILTO:FOO@BAR.BAZ</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"<https://foo.bar/baz bim>", @"<document>
+    <paragraph>
+        <text>&lt;https://foo.bar/baz bim&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<https://example.com/\[\>", @"<document>
+    <paragraph>
+        <link destination=""https://example.com/\[\"" title="""">
+            <text>https://example.com/\[\</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"<foo@bar.example.com>", @"<document>
+    <paragraph>
+        <link destination=""mailto:foo@bar.example.com"" title="""">
+            <text>foo@bar.example.com</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"<foo+special@Bar.baz-bar0.com>", @"<document>
+    <paragraph>
+        <link destination=""mailto:foo+special@Bar.baz-bar0.com"" title="""">
+            <text>foo+special@Bar.baz-bar0.com</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"<foo\+@bar.example.com>", @"<document>
+    <paragraph>
+        <text>&lt;foo+@bar.example.com&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<>", @"<document>
+    <paragraph>
+        <text>&lt;&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"< https://foo.bar >", @"<document>
+    <paragraph>
+        <text>&lt; https://foo.bar &gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<m:abc>", @"<document>
+    <paragraph>
+        <text>&lt;m:abc&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"<foo.bar.baz>", @"<document>
+    <paragraph>
+        <text>&lt;foo.bar.baz&gt;</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"https://example.com", @"<document>
+    <paragraph>
+        <text>https://example.com</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"foo@bar.example.com", @"<document>
+    <paragraph>
+        <text>foo@bar.example.com</text>
+    </paragraph>
+</document>")]
+    public void Parse_AutoLink(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"[foo]: /url ""title""
+
+[foo]", @"<document>
+    <paragraph>
+        <link destination=""/url"" title=""title"">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"   [foo]: 
+      /url  
+           'the title'  
+
+[foo]", @"<document>
+    <paragraph>
+        <link destination=""/url"" title=""the title"">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[Foo*bar\]]:my_(url) 'title (with parens)'
+
+[Foo*bar\]]", @"<document>
+    <paragraph>
+        <link destination=""my_(url)"" title=""title (with parens)"">
+            <text>Foo</text>
+            <text>*</text>
+            <text>bar</text>
+            <text>]</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[Foo bar]:
+<my url>
+'title'
+
+[Foo bar]", @"<document>
+    <paragraph>
+        <link destination=""my url"" title=""title"">
+            <text>Foo bar</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: /url '
+title
+line1
+line2
+'
+
+[foo]", @"<document>
+    <paragraph>
+        <link destination=""/url"" title=""&#xA;title&#xA;line1&#xA;line2&#xA;"">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: /url 'title
+
+with blank line'
+
+[foo]", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]: /url 'title</text>
+    </paragraph>
+    <paragraph>
+        <text>with blank line'</text>
+    </paragraph>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]:
+/url
+
+[foo]", @"<document>
+    <paragraph>
+        <link destination=""/url"" title="""">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]:
+
+[foo]", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]:</text>
+    </paragraph>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: <>
+
+[foo]", @"<document>
+    <paragraph>
+        <link destination="""" title="""">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: <bar>(baz)
+
+[foo]", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]: </text>
+        <html_inline>&lt;bar&gt;</html_inline>
+        <text>(baz)</text>
+    </paragraph>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: /url\bar\*baz ""foo\""bar\baz""
+
+[foo]
+", @"<document>
+    <paragraph>
+        <link destination=""/url\bar*baz"" title=""foo\&quot;bar\baz"">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]
+
+[foo]: url", @"<document>
+    <paragraph>
+        <link destination=""url"" title="""">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]
+
+[foo]: first
+[foo]: second", @"<document>
+    <paragraph>
+        <link destination=""first"" title="""">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[FOO]: /url
+
+[Foo]", @"<document>
+    <paragraph>
+        <link destination=""/url"" title="""">
+            <text>Foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[ΑΓΩ]: /φου
+
+[αγω]", @"<document>
+    <paragraph>
+        <link destination=""/φου"" title="""">
+            <text>αγω</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: /url", @"<document />")]
+    [InlineData(@"[
+foo
+]: /url
+bar", @"<document>
+    <paragraph>
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: /url ""title"" ok", @"<document>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]: /url ""title"" ok</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: /url
+""title"" ok", @"<document>
+    <paragraph>
+        <text>""title"" ok</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"    [foo]: /url ""title""
+
+[foo]", @"<document>
+    <code_block>[foo]: /url ""title""
+</code_block>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"```
+[foo]: /url
+```
+
+[foo]", @"<document>
+    <code_block>[foo]: /url
+</code_block>
+    <paragraph>
+        <text>[</text>
+        <text>foo</text>
+        <text>]</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"Foo
+[bar]: /baz
+
+[bar]", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <text>[</text>
+        <text>bar</text>
+        <text>]: /baz</text>
+    </paragraph>
+    <paragraph>
+        <text>[</text>
+        <text>bar</text>
+        <text>]</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"# [Foo]
+[foo]: /url
+> bar", @"<document>
+    <heading level=""1"">
+        <link destination=""/url"" title="""">
+            <text>Foo</text>
+        </link>
+    </heading>
+    <block_quote>
+        <paragraph>
+            <text>bar</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"[foo]: /url
+bar
+===
+[foo]", @"<document>
+    <heading level=""1"">
+        <text>bar</text>
+    </heading>
+    <paragraph>
+        <link destination=""/url"" title="""">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: /url
+===
+[foo]", @"<document>
+    <paragraph>
+        <text>===</text>
+        <softbreak />
+        <link destination=""/url"" title="""">
+            <text>foo</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]: /foo-url ""foo""
+[bar]: /bar-url
+  ""bar""
+[baz]: /baz-url
+
+[foo],
+[bar],
+[baz]", @"<document>
+    <paragraph>
+        <link destination=""/foo-url"" title=""foo"">
+            <text>foo</text>
+        </link>
+        <text>,</text>
+        <softbreak />
+        <link destination=""/bar-url"" title=""bar"">
+            <text>bar</text>
+        </link>
+        <text>,</text>
+        <softbreak />
+        <link destination=""/baz-url"" title="""">
+            <text>baz</text>
+        </link>
+    </paragraph>
+</document>")]
+    [InlineData(@"[foo]
+
+> [foo]: /url
+", @"<document>
+    <paragraph>
+        <link destination=""/url"" title="""">
+            <text>foo</text>
+        </link>
+    </paragraph>
+    <block_quote />
+</document>")]
+    public void Parse_LinkReference(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/ListItemTests.cs

@@ -0,0 +1,880 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class ListItemTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"1.  A paragraph
+    with two lines.
+
+        indented code
+
+    > A block quote.", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>A paragraph</text>
+                <softbreak />
+                <text>with two lines.</text>
+            </paragraph>
+            <code_block>indented code
+</code_block>
+            <block_quote>
+                <paragraph>
+                    <text>A block quote.</text>
+                </paragraph>
+            </block_quote>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- one
+
+ two", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>one</text>
+            </paragraph>
+        </item>
+    </list>
+    <paragraph>
+        <text>two</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"- one
+
+  two", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>one</text>
+            </paragraph>
+            <paragraph>
+                <text>two</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@" -    one
+
+     two", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>one</text>
+            </paragraph>
+        </item>
+    </list>
+    <code_block> two
+</code_block>
+</document>")]
+    [InlineData(@" -    one
+
+      two", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>one</text>
+            </paragraph>
+            <paragraph>
+                <text>two</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"   > > 1.  one
+>>
+>>     two
+", @"<document>
+    <block_quote>
+        <block_quote>
+            <list type=""ordered"" start=""1"" tight=""false"">
+                <item>
+                    <paragraph>
+                        <text>one</text>
+                    </paragraph>
+                    <paragraph>
+                        <text>two</text>
+                    </paragraph>
+                </item>
+            </list>
+        </block_quote>
+    </block_quote>
+</document>")]
+    [InlineData(@">>- one
+>>
+  >  > two
+", @"<document>
+    <block_quote>
+        <block_quote>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>one</text>
+                    </paragraph>
+                </item>
+            </list>
+            <paragraph>
+                <text>two</text>
+            </paragraph>
+        </block_quote>
+    </block_quote>
+</document>")]
+    [InlineData(@"-one
+
+2.two
+", @"<document>
+    <paragraph>
+        <text>-one</text>
+    </paragraph>
+    <paragraph>
+        <text>2.two</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"- foo
+
+
+  bar", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1.  foo
+
+    ```
+    bar
+    ```
+
+    baz
+
+    > bam", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <code_block>bar
+</code_block>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+            <block_quote>
+                <paragraph>
+                    <text>bam</text>
+                </paragraph>
+            </block_quote>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- Foo
+
+      bar
+
+
+      baz", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>Foo</text>
+            </paragraph>
+            <code_block>bar
+
+
+baz
+</code_block>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"123456789. ok", @"<document>
+    <list type=""ordered"" start=""123456789"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>ok</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1234567890. not ok", @"<document>
+    <paragraph>
+        <text>1234567890. not ok</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"0. ok", @"<document>
+    <list type=""ordered"" start=""0"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>ok</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"003. ok", @"<document>
+    <list type=""ordered"" start=""3"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>ok</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"-1. not ok", @"<document>
+    <paragraph>
+        <text>-1. not ok</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"- foo
+
+      bar", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <code_block>bar
+</code_block>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"  10.  foo
+
+           bar", @"<document>
+    <list type=""ordered"" start=""10"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <code_block>bar
+</code_block>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1.     indented code
+
+   paragraph
+
+       more code", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <code_block>indented code
+</code_block>
+            <paragraph>
+                <text>paragraph</text>
+            </paragraph>
+            <code_block>more code
+</code_block>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"-     indented code
+
+   paragraph
+
+      more code", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <code_block>indented code
+</code_block>
+            <paragraph>
+                <text>paragraph</text>
+            </paragraph>
+            <code_block>more code
+</code_block>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1.      indented code
+
+   paragraph
+
+       more code", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <code_block> indented code
+</code_block>
+            <paragraph>
+                <text>paragraph</text>
+            </paragraph>
+            <code_block>more code
+</code_block>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"-    foo
+
+  bar", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+    </list>
+    <paragraph>
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"-  foo
+
+   bar", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"-
+  foo
+-
+  ```
+  bar
+  ```
+-
+      baz", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item>
+            <code_block>bar
+</code_block>
+        </item>
+        <item>
+            <code_block>baz
+</code_block>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1.
+   foo", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"-   
+  foo", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"-
+
+  foo", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item />
+    </list>
+    <paragraph>
+        <text>foo</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"- foo
+-
+- bar", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item />
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+[InlineData(@"- foo
+-   
+- bar", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item />
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+[InlineData(@"1. foo
+2.
+3. bar", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item />
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"*", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item />
+    </list>
+</document>")]
+    [InlineData(@"foo
+*
+
+foo
+1.", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <softbreak />
+        <text>*</text>
+    </paragraph>
+    <paragraph>
+        <text>foo</text>
+        <softbreak />
+        <text>1.</text>
+    </paragraph>
+</document>")]
+    [InlineData(@" 1.  A paragraph
+     with two lines.
+
+         indented code
+
+     > A block quote.", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>A paragraph</text>
+                <softbreak />
+                <text>with two lines.</text>
+            </paragraph>
+            <code_block>indented code
+</code_block>
+            <block_quote>
+                <paragraph>
+                    <text>A block quote.</text>
+                </paragraph>
+            </block_quote>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"  1.  A paragraph
+      with two lines.
+
+          indented code
+
+      > A block quote.", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>A paragraph</text>
+                <softbreak />
+                <text>with two lines.</text>
+            </paragraph>
+            <code_block>indented code
+</code_block>
+            <block_quote>
+                <paragraph>
+                    <text>A block quote.</text>
+                </paragraph>
+            </block_quote>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"   1.  A paragraph
+       with two lines.
+
+           indented code
+
+       > A block quote.", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>A paragraph</text>
+                <softbreak />
+                <text>with two lines.</text>
+            </paragraph>
+            <code_block>indented code
+</code_block>
+            <block_quote>
+                <paragraph>
+                    <text>A block quote.</text>
+                </paragraph>
+            </block_quote>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"    1.  A paragraph
+        with two lines.
+
+            indented code
+
+        > A block quote.", @"<document>
+    <code_block>1.  A paragraph
+    with two lines.
+
+        indented code
+
+    &gt; A block quote.
+</code_block>
+</document>")]
+    public void Parse_ListItem(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"   1.  A paragraph
+with two lines.
+
+          indented code
+
+      > A block quote.", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>A paragraph</text>
+                <softbreak />
+                <text>with two lines.</text>
+            </paragraph>
+            <paragraph>
+                <text>indented code</text>
+            </paragraph>
+        </item>
+    </list>
+    <code_block>  &gt; A block quote.
+</code_block>
+</document>")]
+    [InlineData(@"  1.  A paragraph
+    with two lines.", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>A paragraph</text>
+                <softbreak />
+                <text>with two lines.</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"> 1. > Blockquote
+continued here.", @"<document>
+    <block_quote>
+        <list type=""ordered"" start=""1"" tight=""true"">
+            <item>
+                <block_quote>
+                    <paragraph>
+                        <text>Blockquote</text>
+                        <softbreak />
+                        <text>continued here.</text>
+                    </paragraph>
+                </block_quote>
+            </item>
+        </list>
+    </block_quote>
+</document>")]
+    [InlineData(@"> 1. > Blockquote
+> continued here.", @"<document>
+    <block_quote>
+        <list type=""ordered"" start=""1"" tight=""true"">
+            <item>
+                <block_quote>
+                    <paragraph>
+                        <text>Blockquote</text>
+                        <softbreak />
+                        <text>continued here.</text>
+                    </paragraph>
+                </block_quote>
+            </item>
+        </list>
+    </block_quote>
+</document>")]
+    public void Parse_ListItem_WithLazyContinuation(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"- foo
+  - bar
+    - baz
+      - boo", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>bar</text>
+                    </paragraph>
+                    <list type=""bullet"" tight=""true"">
+                        <item>
+                            <paragraph>
+                                <text>baz</text>
+                            </paragraph>
+                            <list type=""bullet"" tight=""true"">
+                                <item>
+                                    <paragraph>
+                                        <text>boo</text>
+                                    </paragraph>
+                                </item>
+                            </list>
+                        </item>
+                    </list>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- foo
+ - bar
+  - baz
+   - boo", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>boo</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+[InlineData(@"1. foo
+ 1. bar
+  1. baz
+   1. boo", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>boo</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+ [InlineData(@"
+1. foo
+   1. bar
+      1. baz
+         1. boo", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <list type=""ordered"" start=""1"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>bar</text>
+                    </paragraph>
+                    <list type=""ordered"" start=""1"" tight=""true"">
+                        <item>
+                            <paragraph>
+                                <text>baz</text>
+                            </paragraph>
+                            <list type=""ordered"" start=""1"" tight=""true"">
+                                <item>
+                                    <paragraph>
+                                        <text>boo</text>
+                                    </paragraph>
+                                </item>
+                            </list>
+                        </item>
+                    </list>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"10) foo
+    - bar", @"<document>
+    <list type=""ordered"" start=""10"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>bar</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"
+10) foo
+   - bar", @"<document>
+    <list type=""ordered"" start=""10"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+    </list>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- - foo", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>foo</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1. - foo", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>foo</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1. 1. foo", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <list type=""ordered"" start=""1"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>foo</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- 1. foo", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <list type=""ordered"" start=""1"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>foo</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1. - 2. foo", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <list type=""ordered"" start=""2"" tight=""true"">
+                        <item>
+                            <paragraph>
+                                <text>foo</text>
+                            </paragraph>
+                        </item>
+                    </list>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- # Foo
+- Bar
+  ---
+  baz", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <heading level=""1"">
+                <text>Foo</text>
+            </heading>
+        </item>
+        <item>
+            <heading level=""2"">
+                <text>Bar</text>
+            </heading>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    public void Parse_ListItem_WithNesting(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/ListTests.cs

@@ -0,0 +1,693 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class ListTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"- foo
+- bar
++ baz", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1. foo
+2. bar
+3) baz", @"<document>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+    <list type=""ordered"" start=""3"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"Foo
+- bar
+- baz", @"<document>
+    <paragraph>
+        <text>Foo</text>
+    </paragraph>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    public void Parse_List(string markdown, string expected)
+    {
+        var actual = ToXml(markdown);
+
+        Assert.Equal(expected, actual);
+    }
+
+    [Theory]
+    [InlineData(@"The number of windows in my house is
+14.  The number of doors is 6.", @"<document>
+    <paragraph>
+        <text>The number of windows in my house is</text>
+        <softbreak />
+        <text>14.  The number of doors is 6.</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"The number of windows in my house is
+1.  The number of doors is 6.", @"<document>
+    <paragraph>
+        <text>The number of windows in my house is</text>
+    </paragraph>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>The number of doors is 6.</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    public void Parse_OnlyNumberedListsThatStartWithOneCanInterruptParagraphs(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"- foo
+
+- bar
+
+
+- baz", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- foo
+  - bar
+    - baz
+
+
+      bim
+", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>bar</text>
+                    </paragraph>
+                    <list type=""bullet"" tight=""false"">
+                        <item>
+                            <paragraph>
+                                <text>baz</text>
+                            </paragraph>
+                            <paragraph>
+                                <text>bim</text>
+                            </paragraph>
+                        </item>
+                    </list>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+- b
+
+- c", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>b</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"* a
+*
+
+* c", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item />
+        <item>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+- b
+
+  c
+- d", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>b</text>
+            </paragraph>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>d</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+- b
+
+  [ref]: /url
+- d", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>b</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>d</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+- ```
+  b
+
+
+  ```
+- c", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <code_block>b
+
+
+</code_block>
+        </item>
+        <item>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+  - b
+
+    c
+- d", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+            <list type=""bullet"" tight=""false"">
+                <item>
+                    <paragraph>
+                        <text>b</text>
+                    </paragraph>
+                    <paragraph>
+                        <text>c</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+        <item>
+            <paragraph>
+                <text>d</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"* a
+  > b
+  >
+* c", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+            <block_quote>
+                <paragraph>
+                    <text>b</text>
+                </paragraph>
+            </block_quote>
+        </item>
+        <item>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+  > b
+  ```
+  c
+  ```
+- d
+", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+            <block_quote>
+                <paragraph>
+                    <text>b</text>
+                </paragraph>
+            </block_quote>
+            <code_block>c
+</code_block>
+        </item>
+        <item>
+            <paragraph>
+                <text>d</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+  - b", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>b</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1. ```
+   foo
+   ```
+
+   bar", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <code_block>foo
+</code_block>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"* foo
+  * bar
+
+  baz", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>bar</text>
+                    </paragraph>
+                </item>
+            </list>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+  - b
+  - c
+
+- d
+  - e
+  - f", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>b</text>
+                    </paragraph>
+                </item>
+                <item>
+                    <paragraph>
+                        <text>c</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+        <item>
+            <paragraph>
+                <text>d</text>
+            </paragraph>
+            <list type=""bullet"" tight=""true"">
+                <item>
+                    <paragraph>
+                        <text>e</text>
+                    </paragraph>
+                </item>
+                <item>
+                    <paragraph>
+                        <text>f</text>
+                    </paragraph>
+                </item>
+            </list>
+        </item>
+    </list>
+</document>")]
+    public void Parse_TightAndLooseLists(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"- foo
+- bar
+
+<!-- -->
+
+- baz
+- bim", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+    <html_block>&lt;!-- --&gt;</html_block>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>baz</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>bim</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"-   foo
+
+    notcode
+
+-   foo
+
+<!-- -->
+
+    code", @"<document>
+    <list type=""bullet"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+            <paragraph>
+                <text>notcode</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+    </list>
+    <html_block>&lt;!-- --&gt;</html_block>
+    <code_block>code
+</code_block>
+</document>")]
+    public void Parse_List_Separators(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"- a
+ - b
+  - c
+   - d
+  - e
+ - f
+- g", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>b</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>d</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>e</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>f</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>g</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1. a
+
+  2. b
+
+   3. c
+", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>b</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- a
+ - b
+  - c
+   - d
+    - e", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>b</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>d</text>
+                <softbreak />
+                <text>- e</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"1. a
+
+  2. b
+
+    3. c", @"<document>
+    <list type=""ordered"" start=""1"" tight=""false"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>b</text>
+            </paragraph>
+        </item>
+    </list>
+    <code_block>3. c
+</code_block>
+</document>")]
+    public void Parse_List_Identation(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Fact]
+    public void Parse_BasicNestedLists()
+    {
+        Assert.Equal(@"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>a</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>b</text>
+            </paragraph>
+        </item>
+        <item>
+            <paragraph>
+                <text>c</text>
+            </paragraph>
+        </item>
+    </list>
+</document>", ToXml(@"
+- a
+ - b
+  - c"));
+    }
+}

Radzen.Blazor.Tests/Markdown/ParagraphTests.cs

@@ -0,0 +1,109 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class ParagraphTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+    [Fact]
+    public void Parse_BasicParagraph()
+    {
+        Assert.Equal(@"<document>
+    <paragraph>
+        <text>foo</text>
+    </paragraph>
+</document>", ToXml(@"foo"));
+    }
+
+    [Theory]
+    [InlineData(@"aaa
+
+bbb", @"<document>
+    <paragraph>
+        <text>aaa</text>
+    </paragraph>
+    <paragraph>
+        <text>bbb</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"aaa
+bbb
+
+ccc
+ddd", @"<document>
+    <paragraph>
+        <text>aaa</text>
+        <softbreak />
+        <text>bbb</text>
+    </paragraph>
+    <paragraph>
+        <text>ccc</text>
+        <softbreak />
+        <text>ddd</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"aaa
+
+
+bbb
+", @"<document>
+    <paragraph>
+        <text>aaa</text>
+    </paragraph>
+    <paragraph>
+        <text>bbb</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"  aaa
+ bbb", @"<document>
+    <paragraph>
+        <text>aaa</text>
+        <softbreak />
+        <text>bbb</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"aaa
+             bbb
+                                       ccc", @"<document>
+    <paragraph>
+        <text>aaa</text>
+        <softbreak />
+        <text>bbb</text>
+        <softbreak />
+        <text>ccc</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"   aaa
+bbb", @"<document>
+    <paragraph>
+        <text>aaa</text>
+        <softbreak />
+        <text>bbb</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"    aaa
+bbb", @"<document>
+    <code_block>aaa
+</code_block>
+    <paragraph>
+        <text>bbb</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"aaa     
+bbb     ", @"<document>
+    <paragraph>
+        <text>aaa</text>
+        <linebreak />
+        <text>bbb</text>
+    </paragraph>
+</document>")]
+    public void Parse_Paragraph(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/SoftLineBreakTests.cs

@@ -0,0 +1,41 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class SoftLineBreakTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"foo
+baz", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <softbreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    public void Parse_SoftLineBreak(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"foo 
+ baz", @"<document>
+    <paragraph>
+        <text>foo</text>
+        <softbreak />
+        <text>baz</text>
+    </paragraph>
+</document>")]
+    public void Parse_SoftLine_RemovesSpacesAtEndAndStartOfLine(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/StrongTests.cs

@@ -0,0 +1,135 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class StrongTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData("**foo bar**",
+@"<document>
+    <paragraph>
+        <strong>
+            <text>foo bar</text>
+        </strong>
+    </paragraph>
+</document>")]
+    [InlineData("** foo bar**",
+@"<document>
+    <paragraph>
+        <text>**</text>
+        <text> foo bar</text>
+        <text>**</text>
+    </paragraph>
+</document>")]
+    [InlineData("a**\"foo\"**",
+@"<document>
+    <paragraph>
+        <text>a</text>
+        <text>**</text>
+        <text>""foo""</text>
+        <text>**</text>
+    </paragraph>
+</document>")]
+    [InlineData("foo**bar**",
+@"<document>
+    <paragraph>
+        <text>foo</text>
+        <strong>
+            <text>bar</text>
+        </strong>
+    </paragraph>
+</document>")]
+    [InlineData("__foo bar__",
+@"<document>
+    <paragraph>
+        <strong>
+            <text>foo bar</text>
+        </strong>
+    </paragraph>
+</document>")]
+    [InlineData("__ foo bar__",
+@"<document>
+    <paragraph>
+        <text>__</text>
+        <text> foo bar</text>
+        <text>__</text>
+    </paragraph>
+</document>")]
+    [InlineData("__\nfoo bar__",
+@"<document>
+    <paragraph>
+        <text>__</text>
+        <softbreak />
+        <text>foo bar</text>
+        <text>__</text>
+    </paragraph>
+</document>")]
+    [InlineData("a__\"foo\"__",
+@"<document>
+    <paragraph>
+        <text>a</text>
+        <text>__</text>
+        <text>""foo""</text>
+        <text>__</text>
+    </paragraph>
+</document>")]
+    [InlineData("foo__bar__",
+@"<document>
+    <paragraph>
+        <text>foo</text>
+        <text>__</text>
+        <text>bar</text>
+        <text>__</text>
+    </paragraph>
+</document>")]
+    [InlineData("5__6__78",
+@"<document>
+    <paragraph>
+        <text>5</text>
+        <text>__</text>
+        <text>6</text>
+        <text>__</text>
+        <text>78</text>
+    </paragraph>
+</document>")]
+    [InlineData("пристаням__стремятся__",
+@"<document>
+    <paragraph>
+        <text>пристаням</text>
+        <text>__</text>
+        <text>стремятся</text>
+        <text>__</text>
+    </paragraph>
+</document>")]
+    [InlineData("__foo, __bar__, baz__",
+@"<document>
+    <paragraph>
+        <strong>
+            <text>foo, </text>
+            <strong>
+                <text>bar</text>
+            </strong>
+            <text>, baz</text>
+        </strong>
+    </paragraph>
+</document>")]
+    [InlineData("foo-__(bar)__",
+@"<document>
+    <paragraph>
+        <text>foo-</text>
+        <strong>
+            <text>(bar)</text>
+        </strong>
+    </paragraph>
+</document>")]
+    public void Parse_StrongEmphasisRules_AdheresToCommonMarkSpec(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/TableTests.cs

@@ -0,0 +1,414 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class TableTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Fact]
+    public void Parse_BasicTable()
+    {
+        Assert.Equal(
+            @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>foo</text>
+            </cell>
+            <cell>
+                <text>bar</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>baz</text>
+            </cell>
+            <cell>
+                <text>bim</text>
+            </cell>
+        </row>
+    </table>
+</document>",
+            ToXml(@"
+foo|bar
+--|--
+baz|bim"));
+    }
+
+    [Theory]
+    [InlineData(@"| foo | bar |
+| --- | --- |
+| baz | bim |", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>foo</text>
+            </cell>
+            <cell>
+                <text>bar</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>baz</text>
+            </cell>
+            <cell>
+                <text>bim</text>
+            </cell>
+        </row>
+    </table>
+</document>")]
+    [InlineData(@"| f\|oo  |
+| ------ |
+| b `\|` az |
+| b **\|** im |", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>f|oo</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>b </text>
+                <code>|</code>
+                <text> az</text>
+            </cell>
+        </row>
+        <row>
+            <cell>
+                <text>b </text>
+                <strong>
+                    <text>|</text>
+                </strong>
+                <text> im</text>
+            </cell>
+        </row>
+    </table>
+</document>")]
+    [InlineData(@"| abc | defghi |
+:-: | -----------:
+bar | baz", @"<document>
+    <table>
+        <header>
+            <cell align=""center"">
+                <text>abc</text>
+            </cell>
+            <cell align=""right"">
+                <text>defghi</text>
+            </cell>
+        </header>
+        <row>
+            <cell align=""center"">
+                <text>bar</text>
+            </cell>
+            <cell align=""right"">
+                <text>baz</text>
+            </cell>
+        </row>
+    </table>
+</document>")]
+
+
+    [InlineData(@"| abc | def |
+| --- | --- |
+  bar", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+            <cell>
+                <text>def</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>bar</text>
+            </cell>
+            <cell />
+        </row>
+    </table>
+</document>")]
+[InlineData(@"| abc | def |
+| --- | --- |
+  c:\\foo", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+            <cell>
+                <text>def</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>c:</text>
+                <text>\</text>
+                <text>foo</text>
+            </cell>
+            <cell />
+        </row>
+    </table>
+</document>")]
+    public void Parse_Table(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"| abc | def |
+| --- | --- |
+| bar | baz |
+
+boo", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+            <cell>
+                <text>def</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>bar</text>
+            </cell>
+            <cell>
+                <text>baz</text>
+            </cell>
+        </row>
+    </table>
+    <paragraph>
+        <text>boo</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"| foo |
+| --- |
+# bar", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>foo</text>
+            </cell>
+        </header>
+    </table>
+    <heading level=""1"">
+        <text>bar</text>
+    </heading>
+</document>")]
+    [InlineData(@"| foo |
+| --- |
+- bar", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>foo</text>
+            </cell>
+        </header>
+    </table>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"| foo |
+| --- |
+1. bar", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>foo</text>
+            </cell>
+        </header>
+    </table>
+    <list type=""ordered"" start=""1"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"| abc | def |
+| --- | --- |
+| bar | baz |
+> bar", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+            <cell>
+                <text>def</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>bar</text>
+            </cell>
+            <cell>
+                <text>baz</text>
+            </cell>
+        </row>
+    </table>
+    <block_quote>
+        <paragraph>
+            <text>bar</text>
+        </paragraph>
+    </block_quote>
+</document>")]
+    [InlineData(@"| abc | def |
+| --- | --- |
+| bar | baz |
+    bar", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+            <cell>
+                <text>def</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>bar</text>
+            </cell>
+            <cell>
+                <text>baz</text>
+            </cell>
+        </row>
+    </table>
+    <code_block>bar
+</code_block>
+</document>")]
+    [InlineData(@"| abc | def |
+| --- | --- |
+| bar | baz |
+```
+bar
+```", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+            <cell>
+                <text>def</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>bar</text>
+            </cell>
+            <cell>
+                <text>baz</text>
+            </cell>
+        </row>
+    </table>
+    <code_block>bar
+</code_block>
+</document>")]
+    [InlineData(@"| abc | def |
+| --- | --- |
+| bar | baz |
+<div>
+</div>", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+            <cell>
+                <text>def</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>bar</text>
+            </cell>
+            <cell>
+                <text>baz</text>
+            </cell>
+        </row>
+    </table>
+    <html_block>&lt;div&gt;
+&lt;/div&gt;</html_block>
+</document>")]
+[InlineData(@"| abc | def |
+| --- | --- |
+| bar | baz |
+---", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+            <cell>
+                <text>def</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>bar</text>
+            </cell>
+            <cell>
+                <text>baz</text>
+            </cell>
+        </row>
+    </table>
+    <thematic_break />
+</document>")]
+    public void Parse_Table_AnyBlockOrEmptyLineBreaksTable(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"| abc | def |
+| --- |", @"<document>
+    <paragraph>
+        <text>| abc | def |</text>
+        <softbreak />
+        <text>| --- |</text>
+    </paragraph>
+</document>")]
+    public void Parse_Table_ChecksHeaderAndDelimiter(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+
+    [Theory]
+    [InlineData(@"| abc |
+| --- |
+| bar | baz |", @"<document>
+    <table>
+        <header>
+            <cell>
+                <text>abc</text>
+            </cell>
+        </header>
+        <row>
+            <cell>
+                <text>bar</text>
+            </cell>
+        </row>
+    </table>
+</document>")]
+    public void Parse_Table_IgnoresExtraCells(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/ThematicBreakTests.cs

@@ -0,0 +1,162 @@
+using Xunit;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class ThematicBreakTests
+{
+    private static string ToXml(string markdown)
+    {
+        var document = MarkdownParser.Parse(markdown);
+
+        return XmlVisitor.ToXml(document);
+    }
+
+    [Theory]
+    [InlineData(@"***
+---
+___", @"<document>
+    <thematic_break />
+    <thematic_break />
+    <thematic_break />
+</document>")]
+    [InlineData(@"--
+**
+__", @"<document>
+    <paragraph>
+        <text>--</text>
+        <softbreak />
+        <text>**</text>
+        <softbreak />
+        <text>__</text>
+    </paragraph>
+</document>")]
+    [InlineData(@" ***
+  ***
+   ***", @"<document>
+    <thematic_break />
+    <thematic_break />
+    <thematic_break />
+</document>")]
+    [InlineData(@"    ***", @"<document>
+    <code_block>***
+</code_block>
+</document>")]
+    [InlineData(@"Foo
+    ***", @"<document>
+    <paragraph>
+        <text>Foo</text>
+        <softbreak />
+        <text>***</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"_____________________________________", @"<document>
+    <thematic_break />
+</document>")]
+    [InlineData(@"- - -", @"<document>
+    <thematic_break />
+</document>")]
+    [InlineData(@" **  * ** * ** * **", @"<document>
+    <thematic_break />
+</document>")]
+    [InlineData(@"-     -      -      -", @"<document>
+    <thematic_break />
+</document>")]
+    [InlineData(@"- - - -    ", @"<document>
+    <thematic_break />
+</document>")]
+    [InlineData(@"_ _ _ _ a
+
+a------
+
+---a---", @"<document>
+    <paragraph>
+        <text>_</text>
+        <text> </text>
+        <text>_</text>
+        <text> </text>
+        <text>_</text>
+        <text> </text>
+        <text>_</text>
+        <text> a</text>
+    </paragraph>
+    <paragraph>
+        <text>a------</text>
+    </paragraph>
+    <paragraph>
+        <text>---a---</text>
+    </paragraph>
+</document>")]
+    [InlineData(@" *-*", @"<document>
+    <paragraph>
+        <emph>
+            <text>-</text>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData(@"- foo
+***
+- bar", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>foo</text>
+            </paragraph>
+        </item>
+    </list>
+    <thematic_break />
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"Foo
+***
+bar", @"<document>
+    <paragraph>
+        <text>Foo</text>
+    </paragraph>
+    <thematic_break />
+    <paragraph>
+        <text>bar</text>
+    </paragraph>
+</document>")]
+    [InlineData(@"* Foo
+* * *
+* Bar", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>Foo</text>
+            </paragraph>
+        </item>
+    </list>
+    <thematic_break />
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>Bar</text>
+            </paragraph>
+        </item>
+    </list>
+</document>")]
+    [InlineData(@"- Foo
+- * * *", @"<document>
+    <list type=""bullet"" tight=""true"">
+        <item>
+            <paragraph>
+                <text>Foo</text>
+            </paragraph>
+        </item>
+        <item>
+            <thematic_break />
+        </item>
+    </list>
+</document>")]
+    public void Parse_ThematicBreak(string markdown, string expected)
+    {
+        Assert.Equal(expected, ToXml(markdown));
+    }
+}

Radzen.Blazor.Tests/Markdown/XmlVisitor.cs

@@ -0,0 +1,210 @@
+using System;
+using System.Text;
+using System.Xml;
+
+namespace Radzen.Blazor.Markdown.Tests;
+
+public class XmlVisitor : NodeVisitorBase, IDisposable
+{
+    private readonly XmlWriter writer;
+
+    private XmlVisitor(StringBuilder xml)
+    {
+        writer = XmlWriter.Create(xml, new XmlWriterSettings { OmitXmlDeclaration = true, Indent = true, IndentChars = "    ", });
+    }
+
+    public void Dispose()
+    {
+        writer.Dispose();
+    }
+
+    public void Close()
+    {
+        writer.Close();
+    }
+
+    public static string ToXml(Document document)
+    {
+        var xml = new StringBuilder();
+
+        using var visitor = new XmlVisitor(xml);
+
+        document.Accept(visitor);
+
+        visitor.Close();
+
+        return xml.ToString()!;
+    }
+
+    public override void VisitBlockQuote(BlockQuote blockQuote)
+    {
+        writer.WriteStartElement("block_quote");
+        base.VisitBlockQuote(blockQuote);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitDocument(Document document)
+    {
+        writer.WriteStartDocument();
+        writer.WriteStartElement("document");
+        base.VisitDocument(document);
+        writer.WriteEndElement();
+        writer.WriteEndDocument();
+    }
+
+    public override void VisitHeading(Heading heading)
+    {
+        writer.WriteStartElement($"heading");
+        writer.WriteAttributeString("level", heading.Level.ToString());
+        base.VisitHeading(heading);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitListItem(ListItem listItem)
+    {
+        writer.WriteStartElement("item");
+        base.VisitListItem(listItem);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitParagraph(Paragraph paragraph)
+    {
+        writer.WriteStartElement("paragraph");
+        base.VisitParagraph(paragraph);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitUnorderedList(UnorderedList unorderedList)
+    {
+        writer.WriteStartElement("list");
+        writer.WriteAttributeString("type", "bullet");
+        writer.WriteAttributeString("tight", unorderedList.Tight.ToString().ToLowerInvariant());
+        base.VisitUnorderedList(unorderedList);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitText(Text text)
+    {
+        writer.WriteElementString("text", text.Value);
+    }
+
+    public override void VisitOrderedList(OrderedList orderedList)
+    {
+        writer.WriteStartElement("list");
+        writer.WriteAttributeString("type", "ordered");
+        writer.WriteAttributeString("start", orderedList.Start.ToString());
+        writer.WriteAttributeString("tight", orderedList.Tight.ToString().ToLowerInvariant());
+        base.VisitOrderedList(orderedList);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitLink(Link link)
+    {
+        writer.WriteStartElement("link");
+        writer.WriteAttributeString("destination", link.Destination);
+        writer.WriteAttributeString("title", link.Title);
+        base.VisitLink(link);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitImage(Image image)
+    {
+        writer.WriteStartElement("image");
+        writer.WriteAttributeString("destination", image.Destination);
+        writer.WriteAttributeString("title", image.Title);
+        base.VisitImage(image);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitEmphasis(Emphasis emphasis)
+    {
+        writer.WriteStartElement("emph");
+        base.VisitEmphasis(emphasis);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitStrong(Strong strong)
+    {
+        writer.WriteStartElement("strong");
+        base.VisitStrong(strong);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitCode(Code code)
+    {
+        writer.WriteElementString("code", code.Value);
+    }
+
+    public override void VisitHtmlInline(HtmlInline html)
+    {
+        writer.WriteElementString("html_inline", html.Value);
+    }
+
+    public override void VisitLineBreak(LineBreak lineBreak)
+    {
+        writer.WriteElementString("linebreak", string.Empty);
+    }
+
+    public override void VisitSoftLineBreak(SoftLineBreak softLineBreak)
+    {
+        writer.WriteElementString("softbreak", string.Empty);
+    }
+
+    public override void VisitThematicBreak(ThematicBreak thematicBreak)
+    {
+        writer.WriteElementString("thematic_break", string.Empty);
+    }
+
+    public override void VisitIndentedCodeBlock(IndentedCodeBlock codeBlock)
+    {
+        writer.WriteElementString("code_block", codeBlock.Value);
+    }
+
+    public override void VisitFencedCodeBlock(FencedCodeBlock fencedCodeBlock)
+    {
+        writer.WriteStartElement("code_block");
+        if (!string.IsNullOrEmpty(fencedCodeBlock.Info))
+        {
+            writer.WriteAttributeString("info", fencedCodeBlock.Info);
+        }
+        writer.WriteString(fencedCodeBlock.Value);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitHtmlBlock(HtmlBlock htmlBlock)
+    {
+        writer.WriteElementString("html_block", htmlBlock.Value);
+    }
+
+    public override void VisitTable(Table table)
+    {
+        writer.WriteStartElement("table");
+        base.VisitTable(table);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitTableHeaderRow(TableHeaderRow header)
+    {
+        writer.WriteStartElement("header");
+        base.VisitTableHeaderRow(header);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitTableRow(TableRow row)
+    {
+        writer.WriteStartElement("row");
+        base.VisitTableRow(row);
+        writer.WriteEndElement();
+    }
+
+    public override void VisitTableCell(TableCell cell)
+    {
+        writer.WriteStartElement("cell");
+        if (cell.Alignment != TableCellAlignment.None)
+        {
+            writer.WriteAttributeString("align", cell.Alignment.ToString().ToLowerInvariant());
+        }
+        base.VisitTableCell(cell);
+        writer.WriteEndElement();
+    }
+}

Radzen.Blazor.Tests/MaskTests.cs

@@ -119,13 +119,54 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenMask>();
 
-            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AutoComplete, false));
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+
+            Assert.Contains(@$"autocomplete=""off""", component.Markup);
+            Assert.Contains(@$"aria-autocomplete=""none""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+
+            Assert.Contains(@$"autocomplete=""on""", component.Markup);
+            Assert.DoesNotContain(@$"aria-autocomplete", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("autocomplete", "custom"));
+
+            Assert.Contains(@$"autocomplete=""custom""", component.Markup);
+            Assert.DoesNotContain(@$"aria-autocomplete", component.Markup);
+
+            component.Instance.DefaultAutoCompleteAttribute = "autocomplete-custom";
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+
+            Assert.Contains(@$"autocomplete=""autocomplete-custom""", component.Markup);
+            Assert.Contains(@$"aria-autocomplete=""none""", component.Markup);
+        }
+
+        [Fact]
+        public void Mask_Renders_TypedAutoCompleteParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenMask>();
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.On));
 
             Assert.Contains(@$"autocomplete=""off""", component.Markup);
 
-            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AutoComplete, true));
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.Off));
 
-            Assert.Contains(@$"autocomplete=""on""", component.Markup);
+            Assert.Contains(@$"autocomplete=""off""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.AdditionalName));
+
+            Assert.Contains(@$"autocomplete=""{AutoCompleteType.AdditionalName.GetAutoCompleteValue()}""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.Email));
+
+            Assert.Contains(@$"autocomplete=""{AutoCompleteType.Email.GetAutoCompleteValue()}""", component.Markup);
         }
 
         [Fact]

Radzen.Blazor.Tests/MediaQueryTests.cs

@@ -0,0 +1,65 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class MediaQueryTests
+    {
+        [Fact]
+        public void MediaQuery_Renders()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenMediaQuery>(parameters =>
+            {
+                parameters.Add(p => p.Query, "(max-width: 768px)");
+            });
+
+            Assert.NotNull(component.Instance);
+        }
+
+        [Fact]
+        public void MediaQuery_HasQueryParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var query = "(max-width: 1024px)";
+            var component = ctx.RenderComponent<RadzenMediaQuery>(parameters =>
+            {
+                parameters.Add(p => p.Query, query);
+            });
+
+            Assert.Equal(query, component.Instance.Query);
+        }
+
+        [Fact]
+        public void MediaQuery_InvokesChangeCallback()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            bool changeInvoked = false;
+            bool matchResult = false;
+
+            var component = ctx.RenderComponent<RadzenMediaQuery>(parameters =>
+            {
+                parameters.Add(p => p.Query, "(max-width: 768px)");
+                parameters.Add(p => p.Change, EventCallback.Factory.Create<bool>(this, (matches) =>
+                {
+                    changeInvoked = true;
+                    matchResult = matches;
+                }));
+            });
+
+            // Invoke the JSInvokable method directly
+            component.Instance.OnChange(true);
+
+            Assert.True(changeInvoked);
+            Assert.True(matchResult);
+        }
+    }
+}
+

Radzen.Blazor.Tests/MenuTests.cs

@@ -0,0 +1,58 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class MenuTests
+    {
+        [Fact]
+        public void Menu_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenMenu>();
+
+            Assert.Contains(@"rz-menu", component.Markup);
+        }
+
+        [Fact]
+        public void Menu_Renders_Responsive_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenMenu>(parameters =>
+            {
+                parameters.Add(p => p.Responsive, true);
+            });
+
+            Assert.Contains("rz-menu-closed", component.Markup);
+            Assert.Contains("rz-menu-toggle", component.Markup);
+        }
+
+        [Fact]
+        public void Menu_Renders_Responsive_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenMenu>(parameters =>
+            {
+                parameters.Add(p => p.Responsive, false);
+            });
+
+            Assert.DoesNotContain("rz-menu-toggle", component.Markup);
+            Assert.DoesNotContain("rz-menu-closed", component.Markup);
+        }
+
+
+        [Fact]
+        public void Menu_Renders_CustomToggleAriaLabel()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenMenu>(parameters =>
+            {
+                parameters.Add(p => p.Responsive, true);
+                parameters.Add(p => p.ToggleAriaLabel, "Open navigation");
+            });
+
+            Assert.Contains("Open navigation", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/NotificationServiceTests.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Linq;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class NotificationServiceTests
+    {
+        [Fact]
+        public void NotificationService_IsMessageIsNull_ExceptionExpected()
+        {
+            NotificationService notificationService = new NotificationService();
+            NotificationMessage notificationMessage = null;
+
+            var exception = Record.Exception(() => notificationService.Notify(notificationMessage));
+
+            Assert.IsType<ArgumentNullException>(exception);
+        }
+        
+        [Fact]
+        public void NotificationService_CheckAreTwoMessages_Equals()
+        {
+            var messageOne = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            var messageTwo = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            Assert.True(messageOne.Equals(messageTwo));
+        }
+
+        [Fact]
+        public void NotificationService_CheckAreTwoMessages_NotEquals()
+        {
+            var messageOne = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            var messageTwo = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary Two",
+                Detail = "Info Detail Two",
+                Duration = 6000
+            };
+
+            Assert.False(messageOne.Equals(messageTwo));
+        }
+
+        [Fact]
+        public void NotificationService_CheckAreTwoMessages_EqualsByReference()
+        {
+            var messageOne = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            var messageTwo = messageOne;
+
+            Assert.True(messageOne.Equals(messageTwo));
+        }
+
+        [Fact]
+        public void NotificationService_CheckAreTwoMessages_EqualsByOperator()
+        {
+            var messageOne = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            var messageTwo = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            Assert.True(messageOne == messageTwo);
+        }
+
+        [Fact]
+        public void NotificationService_CheckAreTwoMessages_NotEqualsByOperator()
+        {
+            var messageOne = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            var messageTwo = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary Two",
+                Detail = "Info Detail Two",
+                Duration = 6000
+            };
+
+            Assert.True(messageOne != messageTwo);
+        }
+
+        [Fact]
+        public void NotificationService_CheckAreTwoMessages_EqualsByHashCode()
+        {
+            var messageOne = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            var messageTwo = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            var messageOneHashCode = messageOne.GetHashCode();
+            var messageTwoHashCode = messageTwo.GetHashCode();
+
+            Assert.Equal(messageOneHashCode, messageTwoHashCode);
+        }
+
+        [Fact]
+        public void NotificationService_CheckAreTwoMessages_NotEqualsByHashCode()
+        {
+            var messageOne = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            };
+
+            var messageTwo = new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary Two",
+                Detail = "Info Detail Tow",
+                Duration = 5000
+            };
+
+            var messageOneHashCode = messageOne.GetHashCode();
+            var messageTwoHashCode = messageTwo.GetHashCode();
+
+            Assert.NotEqual(messageOneHashCode, messageTwoHashCode);
+        }
+
+        [Fact]
+        public void NotificationService_MessagesCount_AfterAddingMessages()
+        {
+            NotificationService notificationService = new NotificationService();
+
+            //Messages are the same so only one should be added
+            notificationService.Notify(NotificationSeverity.Info, "Info Summary", "Info Detail", 4000);
+            notificationService.Notify(new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            });
+
+            int expectedMessagesNumber = 1;
+
+            Assert.Equal(expectedMessagesNumber, notificationService.Messages.Count);
+        }
+
+        [Fact]
+        public void NotificationService_MessagesCount_AfterAddingTwoDifferentMessages()
+        {
+            NotificationService notificationService = new NotificationService();
+
+            //Messages are the same so only one should be added
+            notificationService.Notify(NotificationSeverity.Info, "Info Summary 2", "Info Detail 2", 6000);
+            notificationService.Notify(new NotificationMessage()
+            {
+                Severity = NotificationSeverity.Info,
+                Summary = "Info Summary",
+                Detail = "Info Detail",
+                Duration = 4000
+            });
+
+            int expectedMessagesNumber = 2;
+
+            Assert.Equal(expectedMessagesNumber, notificationService.Messages.Count);
+        }
+    }
+}

Radzen.Blazor.Tests/NumericRangeValidatorTests.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Threading.Tasks;
+using Bunit;
+using Microsoft.AspNetCore.Components.Forms;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class NumericRangeValidatorTests
+    {
+        class FormComponentTestDouble : IRadzenFormComponent
+        {
+            public bool IsBound => false;
+
+            public bool HasValue => true;
+
+            public string Name { get; set; }
+
+            public FieldIdentifier FieldIdentifier { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+            public object GetValue()
+            {
+                return Value;
+            }
+
+            public ValueTask FocusAsync()
+            {
+                throw new NotImplementedException();
+            }
+
+            public bool Disabled { get; set; }
+            public bool Visible { get; set; }
+            public IFormFieldContext FormFieldContext => null;
+
+            public object Value { get; set; }
+        }
+
+        class RadzenNumericRangeValidatorTestDouble : RadzenNumericRangeValidator
+        {
+            public bool Validate(object value)
+            {
+                return base.Validate(new FormComponentTestDouble { Value = value });
+            }
+        }
+
+        [Fact]
+        public void Throws_Exception_If_Min_And_Max_Are_Null()
+        {
+            var validator = new RadzenNumericRangeValidatorTestDouble();
+
+            Assert.Throws<System.ArgumentException>(() => validator.Validate(1));
+        }
+
+        [Fact]
+        public void Returns_False_If_Value_Is_Null()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, 0).Add(p => p.Max, 10));
+            });
+
+            Assert.False(component.Instance.Validate(null));
+        }
+        [Fact]
+        public void Returns_True_If_Value_Is_Null_And_AllowNull_Is_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, 0).Add(p => p.Max, 10).Add(p => p.AllowNull, true));
+            });
+
+            Assert.True(component.Instance.Validate(null));
+        }
+
+        [Fact]
+        public void Returns_False_If_Value_Overflows()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, 0).Add(p => p.Max, 10));
+            });
+
+            Assert.False(component.Instance.Validate(long.MaxValue));
+        }
+
+        [Fact]
+        public void Returns_True_If_Value_Is_Greater_Than_Min()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, 0));
+
+            Assert.True(component.Instance.Validate(1));
+        }
+
+        [Fact]
+        public void Returns_True_If_Value_Is_Equal_To_Min()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, 0));
+
+            Assert.True(component.Instance.Validate(0));
+        }
+
+        [Fact]
+        public void Returns_True_If_Value_Is_Less_Than_Max()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Max, 10));
+
+            Assert.True(component.Instance.Validate(9));
+        }
+
+        [Fact]
+        public void Returns_True_If_Value_Is_Equal_To_Max()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Max, 10));
+
+            Assert.True(component.Instance.Validate(10));
+        }
+
+        [Fact]
+        public void Returns_True_If_Value_Is_Between_Min_And_Max()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, 0).Add(p => p.Max, 10));
+
+            Assert.True(component.Instance.Validate(5));
+        }
+
+        [Fact]
+        public void Returns_True_If_Value_Is_Between_Min_And_Max_And_They_Are_Nullable()
+        {
+            int? min = 0;
+            int? max = 10;
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, min).Add(p => p.Max, max));
+            Assert.True(component.Instance.Validate(5));
+        }
+
+        [Fact]
+        public void Returns_True_When_Value_Is_Of_DifferentType()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, 0m).Add(p => p.Max, 10m));
+
+            Assert.True(component.Instance.Validate(5));
+        }
+
+        [Fact]
+        public void Returns_False_If_Cannot_Conert_Value()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenNumericRangeValidatorTestDouble>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Min, 0m).Add(p => p.Max, 10m));
+
+            Assert.False(component.Instance.Validate(DateTime.Now));
+        }
+    }
+}

Radzen.Blazor.Tests/NumericTests.cs

@@ -1,4 +1,6 @@
+using System;
 using Bunit;
+using Newtonsoft.Json.Linq;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -14,9 +16,9 @@ namespace Radzen.Blazor.Tests
 
             component.Render();
 
-            Assert.Contains(@$"rz-spinner", component.Markup);
-            Assert.Contains(@$"rz-spinner-up", component.Markup);
-            Assert.Contains(@$"rz-spinner-down", component.Markup);
+            Assert.Contains(@$"rz-numeric", component.Markup);
+            Assert.Contains(@$"rz-numeric-up", component.Markup);
+            Assert.Contains(@$"rz-numeric-down", component.Markup);
         }
 
         [Fact]
@@ -52,11 +54,41 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<decimal?>(p => p.Min, minValue);
             });
 
-            component.Find(".rz-spinner-down").Click();
+            component.Find(".rz-numeric-down").Click();
 
             Assert.False(raised, $"Numeric value should Change event if value is less than min value.");
         }
 
+        [Fact]
+        public void Numeric_Respect_Nullable_With_MinParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenNumeric<double?>>();
+
+            var raised = false;
+            var value = 3.5;
+            object newValue = null;
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Change, args => { raised = true; newValue = args; });
+                parameters.Add<decimal?>(p => p.Min, 1);
+            });
+
+            component.Find("input").Change(value);
+
+            Assert.True(raised);
+            Assert.True(object.Equals(value, newValue));
+
+            component.Find("input").Change("");
+
+            Assert.True(raised);
+            Assert.True(object.Equals(null, newValue));
+        }
+
         [Fact]
         public void Numeric_Respect_MaxParameter()
         {
@@ -76,7 +108,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<decimal?>(p => p.Max, maxValue);
             });
 
-            component.Find(".rz-spinner-up").Click();
+            component.Find(".rz-numeric-up").Click();
 
             Assert.False(raised, $"Numeric value should Change event if value is less than min value.");
         }
@@ -184,13 +216,54 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenNumeric<double>>();
 
-            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AutoComplete, false));
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+
+            Assert.Contains(@$"autocomplete=""off""", component.Markup);
+            Assert.Contains(@$"aria-autocomplete=""none""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+
+            Assert.Contains(@$"autocomplete=""on""", component.Markup);
+            Assert.DoesNotContain(@$"aria-autocomplete", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("autocomplete", "custom"));
+
+            Assert.Contains(@$"autocomplete=""custom""", component.Markup);
+            Assert.DoesNotContain(@$"aria-autocomplete", component.Markup);
+
+            component.Instance.DefaultAutoCompleteAttribute = "autocomplete-custom";
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+
+            Assert.Contains(@$"autocomplete=""autocomplete-custom""", component.Markup);
+            Assert.Contains(@$"aria-autocomplete=""none""", component.Markup);
+        }
+
+        [Fact]
+        public void Numeric_Renders_TypedAutoCompleteParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenNumeric<double>>();
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.On));
 
             Assert.Contains(@$"autocomplete=""off""", component.Markup);
 
-            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AutoComplete, true));
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.Off));
 
-            Assert.Contains(@$"autocomplete=""on""", component.Markup);
+            Assert.Contains(@$"autocomplete=""off""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.BdayMonth));
+
+            Assert.Contains(@$"autocomplete=""{AutoCompleteType.BdayMonth.GetAutoCompleteValue()}""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.BdayYear));
+
+            Assert.Contains(@$"autocomplete=""{AutoCompleteType.BdayYear.GetAutoCompleteValue()}""", component.Markup);
         }
 
         [Fact]
@@ -256,7 +329,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add(p => p.Change, args => { raised = true; newValue = args; });
             });
 
-            component.Find(".rz-spinner-up").Click();
+            component.Find(".rz-numeric-up").Click();
 
             Assert.True(raised, "Numeric Change should be raised on step up");
             Assert.True(object.Equals(expectedValue, newValue), $"Numeric value should be incremented on step up. Expected value: {expectedValue}, value: {newValue}");
@@ -265,7 +338,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.ValueChanged, args => { raised = true; }));
 
-            component.Find(".rz-spinner-up").Click();
+            component.Find(".rz-numeric-up").Click();
 
             Assert.True(raised, "Numeric ValueChanged should be raised on step up");
         }
@@ -291,7 +364,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add(p => p.Change, args => { raised = true; newValue = args; });
             });
 
-            component.Find(".rz-spinner-down").Click();
+            component.Find(".rz-numeric-down").Click();
 
             Assert.True(raised, "Numeric Change should be raised on step up");
             Assert.True(object.Equals(expectedValue, newValue), $"Numeric value should be incremented on step up. Expected value: {expectedValue}, value: {newValue}");
@@ -300,7 +373,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.ValueChanged, args => { raised = true; }));
 
-            component.Find(".rz-spinner-down").Click();
+            component.Find(".rz-numeric-down").Click();
 
             Assert.True(raised, "Numeric ValueChanged should be raised on step up");
         }
@@ -314,9 +387,9 @@ namespace Radzen.Blazor.Tests
 
             component.Render();
 
-            Assert.Contains(@$"rz-spinner-button-icon", component.Markup);
-            Assert.Contains(@$"rz-spinner-up", component.Markup);
-            Assert.Contains(@$"rz-spinner-down", component.Markup);
+            Assert.Contains(@$"rz-numeric-button-icon", component.Markup);
+            Assert.Contains(@$"rz-numeric-up", component.Markup);
+            Assert.Contains(@$"rz-numeric-down", component.Markup);
         }
 
         [Fact]
@@ -328,9 +401,9 @@ namespace Radzen.Blazor.Tests
 
             component.Render();
 
-            Assert.DoesNotContain(@$"rz-spinner-button-icon", component.Markup);
-            Assert.DoesNotContain(@$"rz-spinner-up", component.Markup);
-            Assert.DoesNotContain(@$"rz-spinner-down", component.Markup);
+            Assert.DoesNotContain(@$"rz-numeric-button-icon", component.Markup);
+            Assert.DoesNotContain(@$"rz-numeric-up", component.Markup);
+            Assert.DoesNotContain(@$"rz-numeric-down", component.Markup);
         }
 
         [Fact]
@@ -350,5 +423,219 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains($" value=\"{valueToTest.ToString(format)}\"", component.Markup);
         }
+        
+        public static TheoryData<decimal, decimal> NumericFormatterPreservesLeadingZerosData =>
+            new()
+            {
+                { 10.000m, 100.000m },
+                { 100.000m, 10.000m }
+            };
+        
+        [Theory]
+        [MemberData(nameof(NumericFormatterPreservesLeadingZerosData))]
+        public void Numeric_Formatter_PreservesLeadingZeros(decimal oldValue, decimal newValue)
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            string format = "0.000";
+
+            var component = ctx.RenderComponent<RadzenNumeric<decimal>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<decimal>.Format), format),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<decimal>.Value), oldValue)
+            );
+
+            component.Render();
+            
+            Assert.Contains($" value=\"{oldValue.ToString(format)}\"", component.Markup);
+
+            component.Find("input").Change(newValue);
+            
+            Assert.Contains($" value=\"{newValue.ToString(format)}\"", component.Markup);
+        }
+
+        [Fact]
+        public void Numeric_Uses_ConvertValue()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var value = new Dollars(11m);
+            Dollars? ConvertFunc(string s) => decimal.TryParse(s, System.Globalization.CultureInfo.InvariantCulture, out var val) ? new Dollars(val) : null;
+            var component = ctx.RenderComponent<RadzenNumeric<Dollars?>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars?>.ConvertValue), (Func<string, Dollars?>)ConvertFunc),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars?>.Value), value),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Culture), System.Globalization.CultureInfo.InvariantCulture)
+            );
+
+            component.Render();
+            
+            Assert.Contains($" value=\"{value.ToString()}\"", component.Markup);
+
+            var newValue = new Dollars(13.53m);
+            component.Find("input").Change("13.53");
+
+            Assert.Contains($" value=\"{newValue.ToString()}\"", component.Markup);
+        }
+
+        [Fact]
+        public void Numeric_Supports_TypeConverter()
+        {
+            using var ctx = new TestContext();
+
+            var valueToTest = new Dollars(100.234m);
+            string format = "0.00";
+
+            var component = ctx.RenderComponent<RadzenNumeric<Dollars>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Format), format),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Value), valueToTest)
+            );
+
+            component.Render();
+
+            Assert.Contains($" value=\"{valueToTest.ToString(format, System.Globalization.CultureInfo.CurrentCulture)}\"", component.Markup);
+        }
+        [Fact]
+        public void Numeric_Supports_TypeConverterWithCulture()
+        {
+            using var ctx = new TestContext();
+
+            var valueToTest = new Dollars(100.234m);
+            string format = "0.00";
+
+            var component = ctx.RenderComponent<RadzenNumeric<Dollars>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Format), format),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Value), valueToTest),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Culture), System.Globalization.CultureInfo.InvariantCulture)
+            );
+
+            component.Render();
+
+            Assert.Contains($" value=\"{valueToTest.ToString(format, System.Globalization.CultureInfo.InvariantCulture)}\"", component.Markup);
+        }
+
+        [Fact]
+        public void Numeric_Supports_EmptyString()
+        {
+            using var ctx = new TestContext();
+
+            var valueToTest = "";
+            string format = "0.00";
+
+            var component = ctx.RenderComponent<RadzenNumeric<string>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<string>.Format), format),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<string>.Value), valueToTest),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Culture), System.Globalization.CultureInfo.InvariantCulture)
+            );
+
+            component.Render();
+
+            Assert.Contains($" value=\"0.00\"", component.Markup);
+        }
+
+        [Fact]
+        public void Numeric_Supports_ValueString()
+        {
+            using var ctx = new TestContext();
+
+            var valueToTest = "12.50";
+            string format = "0.00";
+
+            var component = ctx.RenderComponent<RadzenNumeric<string>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<string>.Format), format),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<string>.Value), valueToTest),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Culture), System.Globalization.CultureInfo.InvariantCulture)
+            );
+
+            component.Render();
+
+            Assert.Contains($" value=\"{valueToTest}\"", component.Markup);
+        }
+
+        [Fact]
+        public void Numeric_Supports_ValueStringEsCLCulture()
+        {
+            using var ctx = new TestContext();
+
+            var valueToTest = "12,50";
+            string format = "0.00";
+
+            var component = ctx.RenderComponent<RadzenNumeric<string>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<string>.Format), format),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<string>.Value), valueToTest),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Culture), System.Globalization.CultureInfo.GetCultureInfo("es-CL"))
+            );
+
+            component.Render();
+
+            Assert.Contains($" value=\"{valueToTest}\"", component.Markup);
+        }
+
+        [Fact]
+        public void Numeric_Supports_ValueStringEnUSCulture()
+        {
+            using var ctx = new TestContext();
+
+            var valueToTest = "12.50";
+            string format = "0.00";
+
+            var component = ctx.RenderComponent<RadzenNumeric<string>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<string>.Format), format),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<string>.Value), valueToTest),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Dollars>.Culture), System.Globalization.CultureInfo.GetCultureInfo("en-US"))
+            );
+
+            component.Render();
+
+            Assert.Contains($" value=\"{valueToTest}\"", component.Markup);
+        }
+
+        [Fact]
+        public void Numeric_Supports_IComparable()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenNumeric<Dollars>>();
+
+            var maxValue = 2;
+
+            component.SetParametersAndRender(parameters =>
+            {
+                component.SetParametersAndRender(parameters =>
+                {
+                    parameters.Add(p => p.Value, new Dollars(1m));
+                    parameters.Add(p => p.Max, maxValue);
+                });
+            });
+            
+            component.Find("input").Change(13.53);
+
+            var maxDollars = new Dollars(maxValue);
+            Assert.Contains($" value=\"{maxDollars}\"", component.Markup);
+            Assert.Equal(component.Instance.Value, maxDollars);
+        }
+
+        [Fact]
+        public void Numeric_Supports_IFormattable()
+        {
+            using var ctx = new TestContext();
+
+            var valueToTest = new Temperature(60.23m);
+            const string format = "F";
+
+            var component = ctx.RenderComponent<RadzenNumeric<Temperature>>(
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Temperature>.Format), format),
+                ComponentParameter.CreateParameter(nameof(RadzenNumeric<Temperature>.Value), valueToTest)
+            );
+
+            component.Render();
+
+            var input = component.Find("input").GetAttribute("value");
+            input.MarkupMatches(valueToTest.ToString(format));
+        }
     }
 }

Radzen.Blazor.Tests/PagerTests.cs

@@ -23,14 +23,14 @@ namespace Radzen.Blazor.Tests
 
             component.Render();
 
-            Assert.Contains(@$"rz-paginator", component.Markup);
+            Assert.Contains(@$"rz-pager", component.Markup);
 
             component.SetParametersAndRender(parameters =>
             {
                 parameters.Add<int>(p => p.PageSize, 101);
                 parameters.Add<int>(p => p.Count, 100);
             });
-            Assert.DoesNotContain(@$"rz-paginator", component.Markup);
+            Assert.DoesNotContain(@$"rz-pager", component.Markup);
         }
 
         [Fact]
@@ -49,7 +49,7 @@ namespace Radzen.Blazor.Tests
 
             component.Render();
 
-            Assert.Contains(@$"rz-paginator", component.Markup);
+            Assert.Contains(@$"rz-pager", component.Markup);
             Assert.Contains(@$"rz-dropdown-trigger", component.Markup);
         }
 
@@ -67,14 +67,93 @@ namespace Radzen.Blazor.Tests
             await component.Instance.GoToPage(2);
             component.Render();
 
-            Assert.Contains(@$"rz-paginator-summary", component.Markup); 
+            Assert.Contains(@$"rz-pager-summary", component.Markup); 
             Assert.Contains(@$"Page 3 of 10 (100 items)", component.Markup); 
             
             component.SetParametersAndRender(parameters => {
                 parameters.Add<bool>(p => p.ShowPagingSummary, false);
             });
-            Assert.DoesNotContain(@$"rz-paginator-summary", component.Markup);
+            Assert.DoesNotContain(@$"rz-pager-summary", component.Markup);
         }
 
+        [Fact]
+        public void RadzenPager_Renders_PagerDensityDefault()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPager>(parameters =>
+            {
+                parameters.Add<int>(p => p.PageSize, 20);
+                parameters.Add<int>(p => p.Count, 100);
+                parameters.Add<Density>(p => p.Density, Density.Default);
+            });
+
+            Assert.DoesNotContain(@$"rz-density-compact", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenPager_Renders_PagerDensityCompact()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPager>(parameters =>
+            {
+                parameters.Add<int>(p => p.PageSize, 20);
+                parameters.Add<int>(p => p.Count, 100);
+                parameters.Add<Density>(p => p.Density, Density.Compact);
+            });
+
+            Assert.Contains(@$"rz-density-compact", component.Markup);
+        }
+
+        [Fact]
+        public async void RadzenPager_First_And_Prev_Buttons_Are_Disabled_When_On_The_First_Page()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPager>(parameters => {
+                parameters.Add<int>(p => p.PageSize, 10);
+                parameters.Add<int>(p => p.Count, 100);
+                parameters.Add<bool>(p => p.ShowPagingSummary, true);
+            });
+
+            await component.Instance.GoToPage(0);
+            component.Render();
+
+            var firstPageButton = component.Find("a.rz-pager-first");
+            Assert.True(firstPageButton.HasAttribute("disabled"));
+
+            var prevPageButton = component.Find("a.rz-pager-prev");
+            Assert.True(prevPageButton.HasAttribute("disabled"));
+        }
+
+        [Fact]
+        public async void RadzenPager_Last_And_Next_Buttons_Are_Disabled_When_On_The_Last_Page()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPager>(parameters => {
+                parameters.Add<int>(p => p.PageSize, 10);
+                parameters.Add<int>(p => p.Count, 100);
+                parameters.Add<bool>(p => p.ShowPagingSummary, true);
+            });
+
+            await component.Instance.GoToPage(9);
+            component.Render();
+
+            var lastPageButton = component.Find("a.rz-pager-last");
+            Assert.True(lastPageButton.HasAttribute("disabled"));
+
+            var nextPageButton = component.Find("a.rz-pager-next");
+            Assert.True(nextPageButton.HasAttribute("disabled"));
+        }
     }
 }

Radzen.Blazor.Tests/PanelMenuTests.cs

@@ -1,8 +1,9 @@
 using Bunit;
-using Bunit.TestDoubles;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Routing;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using System.Collections.Generic;
+using System.Linq;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -22,6 +23,9 @@ namespace Radzen.Blazor.Tests
         }
 
         private static string CreatePanelMenu(string currentAbsoluteUrl, NavLinkMatch match, params string[] urls)
+            => CreatePanelMenu(currentAbsoluteUrl, match, new Dictionary<string, bool>(urls.Select(url => new KeyValuePair<string, bool>(url, false))));
+
+        private static string CreatePanelMenu(string currentAbsoluteUrl, NavLinkMatch match, Dictionary<string, bool> urls)
         {
             using var ctx = new TestContext();
 
@@ -30,12 +34,13 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenPanelMenu>();
 
-            component.SetParametersAndRender(parameters => parameters.Add(p => p.Match, match).AddChildContent(builder => 
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Match, match).AddChildContent(builder =>
             {
                 foreach (var url in urls)
                 {
                     builder.OpenComponent<RadzenPanelMenuItem>(0);
-                    builder.AddAttribute(1, nameof(RadzenPanelMenuItem.Path), url);
+                    builder.AddAttribute(1, nameof(RadzenPanelMenuItem.Path), url.Key);
+                    builder.AddAttribute(2, nameof(RadzenPanelMenuItem.Disabled), url.Value);
                     builder.CloseComponent();
                 }
             }));
@@ -55,6 +60,19 @@ namespace Radzen.Blazor.Tests
             Assert.Equal(firstIndex, lastIndex);
         }
 
+        [Fact]
+        public void RadzenPanelMenu_CanDisableMenuItem()
+        {
+            var urls = new Dictionary<string, bool>
+            {
+                {"/datagrid", false},
+                {"/disabled-url", true}
+            };
+            var component = CreatePanelMenu("http://www.example.com/", NavLinkMatch.All, urls);
+
+            Assert.Contains("rz-state-disabled", component);
+        }
+
         [Fact]
         public void RadzenPanelMenu_MatchesQueryStringParameters()
         {

Radzen.Blazor.Tests/PanelTests.cs

@@ -47,7 +47,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, value));
 
-            Assert.Contains(@$"<i class=""rzi"">{value}</i>", component.Markup);
+            Assert.Contains(@$"<i class=""notranslate rzi"">{value}</i>", component.Markup);
         }
 
         [Fact]
@@ -119,11 +119,11 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AllowCollapse, true));
 
-            Assert.Contains(@"<span class=""rzi rzi-minus""></span>", component.Markup);
+            Assert.Contains(@"<span class=""notranslate rzi rzi-minus""></span>", component.Markup);
 
             component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.Collapsed, true));
 
-            Assert.Contains(@"<span class=""rzi rzi-plus""></span>", component.Markup);
+            Assert.Contains(@"<span class=""notranslate rzi rzi-plus""></span>", component.Markup);
         }
 
         [Fact]
@@ -198,14 +198,10 @@ namespace Radzen.Blazor.Tests
             });
 
             Assert.Contains("SummaryContent", component.Markup);
-            Assert.Equal(
-                "display: block",
-                component.Find(".rz-panel-content-summary").ParentElement.Attributes.First(attr => attr.Name == "style").Value
-            );
         }
 
         [Fact]
-        public void Panel_DontRenders_SummaryWhenOpen()
+        public void Panel_DoesNotRender_SummaryWhenOpen()
         {
             using var ctx = new TestContext();
             var component = ctx.RenderComponent<RadzenPanel>();
@@ -225,8 +221,8 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains("SummaryContent", component.Markup);
             Assert.Equal(
-                "display: none",
-                component.Find(".rz-panel-content-summary").ParentElement.Attributes.First(attr => attr.Name == "style").Value
+                "true",
+                component.Find(".rz-panel-content-summary").ParentElement.ParentElement.Attributes.First(attr => attr.Name == "aria-hidden").Value
             );
         }
     }

Radzen.Blazor.Tests/PasswordTests.cs

@@ -119,13 +119,45 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenPassword>();
 
-            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AutoComplete, false));
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
 
             Assert.Contains(@$"autocomplete=""new-password""", component.Markup);
 
-            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AutoComplete, true));
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
 
             Assert.Contains(@$"autocomplete=""on""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("autocomplete", "custom"));
+
+            Assert.Contains(@$"autocomplete=""custom""", component.Markup);
+        }
+
+        [Fact]
+        public void Password_Renders_TypedAutoCompleteParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenPassword>();
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.On));
+
+            Assert.Contains(@$"autocomplete=""new-password""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.Off));
+
+            Assert.Contains(@$"autocomplete=""off""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.CurrentPassword));
+
+            Assert.Contains(@$"autocomplete=""{AutoCompleteType.CurrentPassword.GetAutoCompleteValue()}""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.NewPassword));
+
+            Assert.Contains(@$"autocomplete=""{AutoCompleteType.NewPassword.GetAutoCompleteValue()}""", component.Markup);
         }
 
         [Fact]
@@ -139,24 +171,49 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains(@$"autofocus", component.Markup);
         }
-        
+
         [Fact]
         public void Password_Raises_ChangedEvent()
         {
             using var ctx = new TestContext();
-
-            var component = ctx.RenderComponent<RadzenPassword>();
-
-            var raised = false;
+            var hasRaised = false;
             var value = "Test";
             object newValue = null;
 
-            component.SetParametersAndRender(parameters => parameters.Add(p => p.Change, args => { raised = true; newValue = args; }));
+            var component = ctx.RenderComponent<RadzenPassword>(parameters =>
+            {
+                parameters.Add(p => p.Change, args => { hasRaised = true; newValue = args; });
+                parameters.Add(p => p.Immediate, false);
+            });
 
-            component.Find("input").Change(value);
+            var inputElement = component.Find("input");
+            inputElement.Change(value);
 
-            Assert.True(raised);
-            Assert.True(object.Equals(value, newValue));
+            Assert.DoesNotContain("oninput", inputElement.ToMarkup());
+            Assert.True(hasRaised);
+            Assert.Equal(value, newValue);
+        }
+
+        [Fact]
+        public void Password_Raises_InputEvent()
+        {
+            using var ctx = new TestContext();
+            var hasRaised = false;
+            var value = "Test";
+            object newValue = null;
+
+            var component = ctx.RenderComponent<RadzenPassword>(parameters =>
+            {
+                parameters.Add(p => p.Change, args => { hasRaised = true; newValue = args; });
+                parameters.Add(p => p.Immediate, true);
+            });
+
+            var inputElement = component.Find("input");
+            inputElement.Input(value);
+
+            Assert.DoesNotContain("onchange", inputElement.ToMarkup());
+            Assert.True(hasRaised);
+            Assert.Equal(value, newValue);
         }
 
         [Fact]

Radzen.Blazor.Tests/PickListTests.cs

@@ -0,0 +1,161 @@
+using Bunit;
+using Xunit;
+using System.Collections.Generic;
+
+namespace Radzen.Blazor.Tests
+{
+    public class PickListTests
+    {
+        class Item
+        {
+            public int Id { get; set; }
+            public string Name { get; set; }
+        }
+
+        [Fact]
+        public void PickList_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>();
+
+            Assert.Contains(@"rz-picklist", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_SourceAndTargetLists()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>();
+
+            Assert.Contains("rz-picklist-source-wrapper", component.Markup);
+            Assert.Contains("rz-picklist-target-wrapper", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_TransferButtons()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>();
+
+            Assert.Contains("rz-picklist-buttons", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_Orientation_Horizontal()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Horizontal);
+            });
+
+            Assert.Contains("rz-flex-row", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_Orientation_Vertical()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Vertical);
+            });
+
+            Assert.Contains("rz-flex-column", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_AllowFiltering()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "Item 1" }
+            };
+
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+                parameters.Add(p => p.Source, data);
+                parameters.Add(p => p.TextProperty, "Name");
+            });
+
+            Assert.Contains("rz-listbox-filter", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_SourceData()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Item>
+            {
+                new Item { Id = 1, Name = "Source Item 1" },
+                new Item { Id = 2, Name = "Source Item 2" }
+            };
+
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.Source, data);
+                parameters.Add(p => p.TextProperty, "Name");
+            });
+
+            Assert.Contains("Source Item 1", component.Markup);
+            Assert.Contains("Source Item 2", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_ShowHeader()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.ShowHeader, true);
+                parameters.Add(p => p.SourceHeader, builder => builder.AddContent(0, "Available Items"));
+                parameters.Add(p => p.TargetHeader, builder => builder.AddContent(0, "Selected Items"));
+            });
+
+            Assert.Contains("Available Items", component.Markup);
+            Assert.Contains("Selected Items", component.Markup);
+        }
+
+        [Fact]
+        public void PickList_Renders_AllowMoveAll_Buttons()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var data = new List<Item> { new Item { Id = 1, Name = "Item" } };
+
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.AllowMoveAll, true);
+                parameters.Add(p => p.Source, data);
+            });
+
+            // Should have 4 buttons when AllowMoveAll is true
+            var buttonCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rz-button").Count;
+            Assert.True(buttonCount >= 4);
+        }
+
+        [Fact]
+        public void PickList_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenPickList<Item>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/PivotDataGridTests.cs

@@ -0,0 +1,644 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Radzen;
+using Radzen.Blazor;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class PivotDataGridTests
+    {
+        private static readonly List<SalesData> SampleData = new()
+        {
+            new SalesData { Region = "North", Category = "Electronics", Product = "Laptop", Amount = 1000, Year = 2023 },
+            new SalesData { Region = "North", Category = "Electronics", Product = "Laptop", Amount = 1500, Year = 2024 },
+            new SalesData { Region = "South", Category = "Home", Product = "Vacuum", Amount = 500, Year = 2023 }
+        };
+
+        public class SalesData
+        {
+            public string Region { get; set; }
+            public string Category { get; set; }
+            public string Product { get; set; }
+            public double Amount { get; set; }
+            public int Year { get; set; }
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_CssClasses()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx);
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-pivot-data-grid", component.Markup);
+                Assert.Contains("rz-pivot-table", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_RowAndColumnHeaders()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx);
+
+            component.WaitForAssertion(() =>
+            {
+                var table = component.Find(".rz-pivot-content .rz-pivot-table");
+                var headers = table.GetElementsByClassName("rz-pivot-header-text").Select(h => h.TextContent.Trim()).ToList();
+                var aggregateHeaders = table.GetElementsByClassName("rz-pivot-aggregate-header").Select(h => h.TextContent.Trim()).ToList();
+
+                Assert.Contains("Region", headers);
+                Assert.Contains("2023", headers);
+                Assert.Contains("Sales", aggregateHeaders);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowSorting_RendersSortableClass()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowSorting, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var sortableHeaders = component.FindAll(".rz-pivot-header-content.rz-sortable");
+                Assert.NotEmpty(sortableHeaders);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFiltering_RendersFilterIcon()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var filterIcons = component.FindAll(".rz-grid-filter-icon");
+                Assert.NotEmpty(filterIcons);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_AggregateValues()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx);
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("1000", component.Markup);
+                Assert.Contains("1500", component.Markup);
+                Assert.Contains("500", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_DisallowFiltering_HidesFilterIcon()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowFiltering, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var filterIcons = component.FindAll(".rz-grid-filter-icon");
+                Assert.Empty(filterIcons);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_DisallowSorting_HidesSortableClass()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowSorting, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var sortableHeaders = component.FindAll(".rz-pivot-header-content.rz-sortable");
+                Assert.Empty(sortableHeaders);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_ShowColumnsTotals_RendersFooter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.ShowColumnsTotals, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var footer = component.FindAll(".rz-pivot-footer");
+                Assert.NotEmpty(footer);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_HideColumnsTotals_NoFooter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.ShowColumnsTotals, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var footer = component.FindAll(".rz-pivot-footer");
+                Assert.Empty(footer);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_DefaultEmptyText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, new List<SalesData>());
+                parameters.Add(p => p.AllowFieldsPicking, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("No records to display.", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_CustomEmptyText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, new List<SalesData>());
+                parameters.Add(p => p.EmptyText, "No data available");
+                parameters.Add(p => p.AllowFieldsPicking, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("No data available", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowPaging_RendersPager()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.PageSize, 2);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-pager", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_DisallowPaging_HidesPager()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.DoesNotContain("rz-pager", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_PagerPosition_Top()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.PagerPosition, PagerPosition.Top);
+                parameters.Add(p => p.PageSize, 2);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-pager", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_PagerPosition_TopAndBottom()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.PagerPosition, PagerPosition.TopAndBottom);
+                parameters.Add(p => p.PageSize, 2);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var pagers = component.FindAll(".rz-pager");
+                Assert.True(pagers.Count >= 1); // Should have at least one pager
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Density_Compact()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowPaging, true);
+                parameters.Add(p => p.PageSize, 1); // Force pager to show with small page size
+                parameters.Add(p => p.AllowFieldsPicking, false);
+                parameters.Add(p => p.Density, Density.Compact);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-density-compact", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowAlternatingRows_True()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-grid-table-striped", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowAlternatingRows_False()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.DoesNotContain("rz-grid-table-striped", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFieldsPicking_ShowsPanel()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowFieldsPicking, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-panel", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFieldsPicking_False_HidesPanel()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowFieldsPicking, false);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.DoesNotContain("rz-panel", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_AllowDrillDown()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowDrillDown, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                // Should render pivot content
+                Assert.Contains("rz-pivot-content", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_RowValues()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx);
+
+            component.WaitForAssertion(() =>
+            {
+                var cells = component.FindAll(".rz-pivot-row-header");
+                var cellTexts = cells.Select(c => c.TextContent.Trim()).ToList();
+                
+                Assert.Contains("North", cellTexts);
+                Assert.Contains("South", cellTexts);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_MultipleRows()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, SampleData);
+
+                parameters.Add<RenderFragment>(p => p.Rows, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotRow<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotRow<SalesData>.Property), nameof(SalesData.Region));
+                    builder.AddAttribute(2, nameof(RadzenPivotRow<SalesData>.Title), "Region");
+                    builder.CloseComponent();
+
+                    builder.OpenComponent<RadzenPivotRow<SalesData>>(2);
+                    builder.AddAttribute(3, nameof(RadzenPivotRow<SalesData>.Property), nameof(SalesData.Category));
+                    builder.AddAttribute(4, nameof(RadzenPivotRow<SalesData>.Title), "Category");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Columns, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotColumn<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotColumn<SalesData>.Property), nameof(SalesData.Year));
+                    builder.AddAttribute(2, nameof(RadzenPivotColumn<SalesData>.Title), "Year");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Aggregates, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotAggregate<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotAggregate<SalesData>.Property), nameof(SalesData.Amount));
+                    builder.AddAttribute(2, nameof(RadzenPivotAggregate<SalesData>.Title), "Sales");
+                    builder.AddAttribute(3, nameof(RadzenPivotAggregate<SalesData>.Aggregate), AggregateFunction.Sum);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var headers = component.FindAll(".rz-pivot-header-text").Select(h => h.TextContent.Trim()).ToList();
+                Assert.Contains("Region", headers);
+                Assert.Contains("Category", headers);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_MultipleAggregates()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, SampleData);
+
+                parameters.Add<RenderFragment>(p => p.Rows, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotRow<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotRow<SalesData>.Property), nameof(SalesData.Region));
+                    builder.AddAttribute(2, nameof(RadzenPivotRow<SalesData>.Title), "Region");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Columns, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotColumn<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotColumn<SalesData>.Property), nameof(SalesData.Year));
+                    builder.AddAttribute(2, nameof(RadzenPivotColumn<SalesData>.Title), "Year");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Aggregates, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotAggregate<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotAggregate<SalesData>.Property), nameof(SalesData.Amount));
+                    builder.AddAttribute(2, nameof(RadzenPivotAggregate<SalesData>.Title), "Total Sales");
+                    builder.AddAttribute(3, nameof(RadzenPivotAggregate<SalesData>.Aggregate), AggregateFunction.Sum);
+                    builder.CloseComponent();
+
+                    builder.OpenComponent<RadzenPivotAggregate<SalesData>>(4);
+                    builder.AddAttribute(5, nameof(RadzenPivotAggregate<SalesData>.Property), nameof(SalesData.Amount));
+                    builder.AddAttribute(6, nameof(RadzenPivotAggregate<SalesData>.Title), "Count Sales");
+                    builder.AddAttribute(7, nameof(RadzenPivotAggregate<SalesData>.Aggregate), AggregateFunction.Count);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                var aggregateHeaders = component.FindAll(".rz-pivot-aggregate-header").Select(h => h.TextContent.Trim()).ToList();
+                Assert.Contains("Total Sales", aggregateHeaders);
+                Assert.Contains("Count Sales", aggregateHeaders);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_Renders_AlternatingRowClasses()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = RenderPivotDataGrid(ctx, parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, true);
+            });
+
+            component.WaitForAssertion(() =>
+            {
+                Assert.Contains("rz-pivot-row-even", component.Markup);
+                Assert.Contains("rz-pivot-row-odd", component.Markup);
+            });
+        }
+
+        [Fact]
+        public void PivotDataGrid_PageSize_DefaultsTo10()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.Equal(10, grid.PageSize);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowSorting_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowSorting);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFiltering_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowFiltering);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowAlternatingRows_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowAlternatingRows);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowDrillDown_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowDrillDown);
+        }
+
+        [Fact]
+        public void PivotDataGrid_AllowFieldsPicking_DefaultsToTrue()
+        {
+            var grid = new RadzenPivotDataGrid<SalesData>();
+            Assert.True(grid.AllowFieldsPicking);
+        }
+
+        private static IRenderedComponent<RadzenPivotDataGrid<SalesData>> RenderPivotDataGrid(TestContext ctx, Action<ComponentParameterCollectionBuilder<RadzenPivotDataGrid<SalesData>>>? configure = null)
+        {
+            return ctx.RenderComponent<RadzenPivotDataGrid<SalesData>>(parameters =>
+            {
+                parameters.Add(p => p.Data, SampleData);
+
+                parameters.Add<RenderFragment>(p => p.Rows, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotRow<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotRow<SalesData>.Property), nameof(SalesData.Region));
+                    builder.AddAttribute(2, nameof(RadzenPivotRow<SalesData>.Title), "Region");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Columns, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotColumn<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotColumn<SalesData>.Property), nameof(SalesData.Year));
+                    builder.AddAttribute(2, nameof(RadzenPivotColumn<SalesData>.Title), "Year");
+                    builder.CloseComponent();
+                });
+
+                parameters.Add<RenderFragment>(p => p.Aggregates, builder =>
+                {
+                    builder.OpenComponent<RadzenPivotAggregate<SalesData>>(0);
+                    builder.AddAttribute(1, nameof(RadzenPivotAggregate<SalesData>.Property), nameof(SalesData.Amount));
+                    builder.AddAttribute(2, nameof(RadzenPivotAggregate<SalesData>.Title), "Sales");
+                    builder.AddAttribute(3, nameof(RadzenPivotAggregate<SalesData>.Aggregate), AggregateFunction.Sum);
+                    builder.CloseComponent();
+                });
+
+                configure?.Invoke(parameters);
+            });
+        }
+    }
+}
+

Radzen.Blazor.Tests/ProfileMenuItemTests.cs

@@ -0,0 +1,120 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ProfileMenuItemTests
+    {
+        [Fact]
+        public void ProfileMenuItem_Renders_TextParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Text", "Profile");
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("Profile", component.Markup);
+        }
+
+        [Fact]
+        public void ProfileMenuItem_Renders_IconParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Icon", "account_circle");
+                    builder.AddAttribute(2, "Text", "Profile");
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("account_circle", component.Markup);
+        }
+
+        [Fact]
+        public void ProfileMenuItem_Template_OverridesText()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Text", "This should not appear");
+                    builder.AddAttribute(2, "Template", (RenderFragment)((templateBuilder) =>
+                    {
+                        templateBuilder.OpenElement(0, "span");
+                        templateBuilder.AddAttribute(1, "class", "template-content");
+                        templateBuilder.AddContent(2, "Template Content");
+                        templateBuilder.CloseElement();
+                    }));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Template should be rendered
+            Assert.Contains("template-content", component.Markup);
+            // Text should not be rendered in navigation-item-text span when Template is present
+            Assert.DoesNotContain("<span class=\"rz-navigation-item-text\">This should not appear</span>", component.Markup);
+        }
+
+        [Fact]
+        public void ProfileMenuItem_Renders_TemplateWithSwitch()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Icon", "settings");
+                    builder.AddAttribute(2, "Template", (RenderFragment)((templateBuilder) =>
+                    {
+                        templateBuilder.OpenComponent<RadzenSwitch>(0);
+                        templateBuilder.CloseComponent();
+                    }));
+                    builder.CloseComponent();
+                });
+            });
+
+            // Icon should still be rendered
+            Assert.Contains("settings", component.Markup);
+            // Switch should be rendered from template
+            Assert.Contains("rz-switch", component.Markup);
+        }
+
+        [Fact]
+        public void ProfileMenuItem_Renders_PathParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProfileMenu>(parameters =>
+            {
+                parameters.Add(p => p.ChildContent, builder =>
+                {
+                    builder.OpenComponent<RadzenProfileMenuItem>(0);
+                    builder.AddAttribute(1, "Text", "Settings");
+                    builder.AddAttribute(2, "Path", "/settings");
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.Contains("href=\"/settings\"", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/ProgressBarTests.cs

@@ -18,7 +18,9 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add<double>(p => p.Value, value));
 
-            Assert.Contains(@$"<div class=""rz-progressbar-label"">{value}", component.Markup);
+
+            Assert.Contains(@$"<div class=""rz-progressbar-label"">", component.Markup);
+            Assert.Contains(@$"{value}%", component.Markup);
             Assert.Contains(@$"aria-valuenow=""{value}""", component.Markup);
             Assert.Contains(@$"aria-valuemin=""0""", component.Markup);
         }
@@ -50,13 +52,13 @@ namespace Radzen.Blazor.Tests
 
             component.Render();
 
-            Assert.Contains(@$"%</div>", component.Markup);
+            Assert.Contains(@$"0%", component.Markup);
 
-            var value = "mm";
+            var unit = "mm";
 
-            component.SetParametersAndRender(parameters => parameters.Add(p => p.Unit, value));
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Unit, unit));
 
-            Assert.Contains(@$"{value}</div>", component.Markup);
+            Assert.Contains(@$"0{unit}", component.Markup);
         }
 
         [Fact]
@@ -70,7 +72,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Style, value));
 
-            Assert.Contains(@$"style=""{value}""", component.Markup);
+            Assert.Contains(@$"style=""--rz-progressbar-value: 0%;{value}""", component.Markup);
         }
 
         [Fact]
@@ -116,7 +118,69 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<double>(p => p.Max, max);
             });
 
-            Assert.Contains(@$"style=""width: {Math.Min(value / max * 100, 100).ToInvariantString()}%;""", component.Markup);
+            Assert.Contains(@$"style=""--rz-progressbar-value: {Math.Min(value / max * 100, 100).ToInvariantString()}%;""", component.Markup);
+        }
+
+        [Fact]
+        public void ProgressBar_Renders_ProgressBarStyle()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenProgressBar>();
+
+            component.SetParametersAndRender(parameters=>parameters.Add(p=>p.ProgressBarStyle, ProgressBarStyle.Success));
+            Assert.Contains(@$"rz-progressbar-success", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ProgressBarStyle, ProgressBarStyle.Info));
+            Assert.Contains(@$"rz-progressbar-info", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ProgressBarStyle, ProgressBarStyle.Success));
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Mode, ProgressBarMode.Indeterminate));
+            Assert.Contains(@$"rz-progressbar-success", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ProgressBarStyle, ProgressBarStyle.Info));
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Mode, ProgressBarMode.Indeterminate));
+            Assert.Contains(@$"rz-progressbar-info", component.Markup);
+        }
+
+        [Fact]
+        public void ProgressBar_Renders_ShowValue_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenProgressBar>(parameters =>
+            {
+                parameters.Add(p => p.ShowValue, true);
+                parameters.Add(p => p.Value, 50);
+            });
+
+            Assert.Contains("rz-progressbar-label", component.Markup);
+            Assert.Contains("50%", component.Markup);
+        }
+
+        [Fact]
+        public void ProgressBar_Renders_ShowValue_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenProgressBar>(parameters =>
+            {
+                parameters.Add(p => p.ShowValue, false);
+                parameters.Add(p => p.Value, 50);
+            });
+
+            Assert.DoesNotContain("rz-progressbar-label", component.Markup);
+        }
+
+        [Fact]
+        public void ProgressBar_Renders_Template()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenProgressBar>(parameters =>
+            {
+                parameters.Add(p => p.Value, 75);
+                parameters.Add(p => p.Template, builder => builder.AddContent(0, "Custom: 75%"));
+            });
+
+            Assert.Contains("Custom: 75%", component.Markup);
         }
     }
 }

Radzen.Blazor.Tests/PropertyAccessTests.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class PropertyAccessTests
+    {
+        public partial class TestData
+        {
+            public string PROPERTY { get; set; }
+            public string Property { get; set; }
+        }
+
+        [Fact]
+        public void Getter_With_DifferentTargetType()
+        {
+            var o = new TestData { Property = "test" };
+            var getter = PropertyAccess.Getter<object, object>(nameof(TestData.Property), typeof(TestData));
+            var value = getter(o);
+            Assert.Equal(o.Property, value);
+        }
+
+        [Fact]
+        public void Getter_With_Members_That_Differ_Only_In_Casing()
+        {
+            var o = new TestData { PROPERTY = nameof(TestData.PROPERTY), Property = nameof(TestData.Property) };
+            var getter = PropertyAccess.Getter<TestData, string>(nameof(TestData.PROPERTY));
+            var value = getter(o);
+            Assert.Equal(nameof(TestData.PROPERTY), value);
+        }
+
+        [Fact]
+        public void Getter_Resolves_Property_On_Simple_Object()
+        {
+            var o = new SimpleObject() { Prop1 = "TestString" };
+            var getter = PropertyAccess.Getter<SimpleObject, string>("Prop1");
+            var value = getter(o);
+            Assert.Equal("TestString", value);
+        }
+
+        [Fact]
+        public void Getter_Resolves_Property_On_Simple_Object_QueryableType()
+        {
+            var _data = new List<SimpleObject>()
+            {
+                new SimpleObject() { Prop1 = "TestString" },
+            };
+
+            Func<object, object> getter = PropertyAccess.Getter<object, object>("Prop1", typeof(SimpleObject));
+
+            var value = getter(_data[0]);
+            Assert.Equal("TestString", value);
+        }
+
+        [Fact]
+        public void Getter_Resolves_Property_On_Nested_Object()
+        {
+            var o = new NestedObject() { Obj = new SimpleObject { Prop1 = "TestString" } };
+            var getter = PropertyAccess.Getter<NestedObject, string>("Obj.Prop1");
+            var value = getter(o);
+            Assert.Equal("TestString", value);
+        }
+
+        [Fact]
+        public void Getter_Resolves_Property_From_Array()
+        {
+            var o = new ArrayObject() { Values = new string[] { "1", "2", "3" } };
+            var getter = PropertyAccess.Getter<ArrayObject, string>("Values[1]");
+            var value = getter(o);
+            Assert.Equal("2", value);
+        }
+
+        [Fact]
+        public void Getter_Resolves_Property_From_Nested_Array()
+        {
+            var o = new NestedArrayObject() { Obj = new ArrayObject() { Values = new string[] { "1", "2", "3" } } };
+            var getter = PropertyAccess.Getter<NestedArrayObject, string>("Obj.Values[2]");
+            var value = getter(o);
+            Assert.Equal("3", value);
+        }
+
+        [Fact]
+        public void Getter_Resolves_Property_From_List()
+        {
+            var o = new ListObject() { Values = new List<string>() { "1", "2", "3" } };
+            var getter = PropertyAccess.Getter<ListObject, string>("Values[1]");
+            var value = getter(o);
+            Assert.Equal("2", value);
+        }
+
+        public class SimpleObject
+        {
+            public string Prop1 { get; set; }
+        }
+
+        public class NestedObject
+        {
+            public SimpleObject Obj { get; set; }
+        }
+
+        public class ArrayObject
+        {
+            public string[] Values { get; set; }
+        }
+
+        public class NestedArrayObject
+        {
+            public ArrayObject Obj { get; set; }
+        }
+
+        public class ListObject
+        {
+            public List<string> Values { get; set; }
+        }
+
+        [Fact]
+        public void GetProperty_Should_Resolve_DescriptionProperty()
+        {
+            var descriptionProperty = PropertyAccess.GetProperty(typeof(ISimpleInterface), nameof(ISimpleInterface.Description));
+
+            Assert.NotNull(descriptionProperty);
+        }
+
+        [Fact]
+        public void GetProperty_Should_Resolve_NameProperty()
+        {
+            var nameProperty = PropertyAccess.GetProperty(typeof(ISimpleInterface), nameof(ISimpleInterface.Name));
+
+            Assert.NotNull(nameProperty);
+        }
+
+        [Fact]
+        public void GetProperty_Should_Resolve_IdProperty()
+        {
+            var idProperty = PropertyAccess.GetProperty(typeof(ISimpleInterface), nameof(ISimpleBaseInterface.Id));
+            Assert.NotNull(idProperty);
+        }
+
+        interface ISimpleInterface : ISimpleNestedInterface
+        {
+            string Description { get; set; }
+        }
+
+        interface ISimpleNestedInterface : ISimpleBaseInterface
+        {
+            string Name { get; set; }
+        }
+
+        interface ISimpleBaseInterface
+        {
+            int Id { get; set; }
+        }
+    }
+}

Radzen.Blazor.Tests/RadioButtonListTests.cs

@@ -0,0 +1,62 @@
+using Bunit;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class RadioButtonListTests
+    {
+        [Fact]
+        public void RadioButtonList_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRadioButtonList<int>>();
+
+            Assert.Contains(@"rz-radio-button-list", component.Markup);
+        }
+
+        [Fact]
+        public void RadioButtonList_Renders_Orientation()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRadioButtonList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenRadioButtonListItem<int>>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Horizontal));
+            // Orientation is applied via RadzenStack which uses flex-direction
+            Assert.Contains("rz-flex-row", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Vertical));
+            Assert.Contains("rz-flex-column", component.Markup);
+        }
+
+        [Fact]
+        public void RadioButtonList_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRadioButtonList<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenRadioButtonListItem<int>>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            // Disabled class is on the radio button items
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/Radzen.Blazor.Tests.csproj

@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6</TargetFramework>
+    <TargetFramework>net9</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
-    <PackageReference Include="bunit.web" Version="1.2.49" />
+    <PackageReference Include="bunit.web" Version="1.36.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

Radzen.Blazor.Tests/RatingTests.cs

@@ -0,0 +1,82 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class RatingTests
+    {
+        [Fact]
+        public void Rating_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            Assert.Contains(@"rz-rating", component.Markup);
+        }
+
+        [Fact]
+        public void Rating_Renders_Stars()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Stars, 5));
+
+            // Should render 5 star icons (rzi-star or rzi-star-o) + 1 clear button icon = 6 total
+            var starCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rz-rating-icon").Count;
+            Assert.Equal(6, starCount); // 5 stars + 1 clear button
+        }
+
+        [Fact]
+        public void Rating_Renders_CustomStarCount()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Stars, 10));
+
+            var starCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rz-rating-icon").Count;
+            Assert.Equal(11, starCount); // 10 stars + 1 clear button
+        }
+
+        [Fact]
+        public void Rating_Renders_Value()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Value, 3);
+                parameters.Add(p => p.Stars, 5);
+            });
+
+            // Should have 3 filled stars (rzi-star) and 2 outline stars (rzi-star-o)
+            var filledStars = System.Text.RegularExpressions.Regex.Matches(component.Markup, "rzi-star\"").Count;
+            Assert.Equal(3, filledStars);
+        }
+
+        [Fact]
+        public void Rating_Renders_ReadOnly()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ReadOnly, true));
+
+            Assert.Contains("rz-state-readonly", component.Markup);
+        }
+
+        [Fact]
+        public void Rating_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRating>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Disabled, true));
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/Rendering/StepGeneratorTests.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Radzen.Blazor.Rendering;
+using Xunit;
+
+namespace Radzen.Blazor.Tests.Rendering;
+
+public class StepGeneratorTests
+{
+    [Fact]
+    public void Renders_Path_Correctly()
+    {
+        var data = new List<Point>
+        {
+            new() { X = 10, Y = 10 },
+            new() { X = 20, Y = 15 },
+            new() { X = 30, Y = 20 },
+            new() { X = 40, Y = 25 },
+            new() { X = 50, Y = 50 }
+        };
+
+        var path = new StepGenerator().Path(data);
+        
+        Assert.Equal("10 10 H 20 V 15 H 30 V 20 H 40 V 25 H 50 V 50", path);
+    }
+}

Radzen.Blazor.Tests/RowTests.cs

@@ -0,0 +1,63 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class RowTests
+    {
+        [Fact]
+        public void Row_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>();
+
+            Assert.Contains(@"rz-row", component.Markup);
+        }
+
+        [Fact]
+        public void Row_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>(parameters =>
+            {
+                parameters.AddChildContent("<div>Row Content</div>");
+            });
+
+            Assert.Contains("Row Content", component.Markup);
+        }
+
+        [Fact]
+        public void Row_Renders_Gap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Gap, "2rem"));
+
+            Assert.Contains("--rz-gap:2rem", component.Markup);
+        }
+
+        [Fact]
+        public void Row_Renders_RowGap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.RowGap, "1.5rem"));
+
+            Assert.Contains("--rz-row-gap:1.5rem", component.Markup);
+        }
+
+        [Fact]
+        public void Row_Renders_ColumnGap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenRow>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Gap, "1rem"));
+
+            Assert.Contains("--rz-gap:1rem", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SecurityCodeTests.cs

@@ -0,0 +1,45 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SecurityCodeTests
+    {
+        [Fact]
+        public void SecurityCode_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenSecurityCode>();
+
+            Assert.Contains(@"rz-security-code", component.Markup);
+        }
+
+        [Fact]
+        public void SecurityCode_Renders_Count()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenSecurityCode>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Count, 6));
+
+            // Should render 6 input boxes + 1 hidden input for form submission = 7 total
+            var inputCount = System.Text.RegularExpressions.Regex.Matches(component.Markup, "<input").Count;
+            Assert.Equal(7, inputCount);
+        }
+
+        [Fact]
+        public void SecurityCode_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            var component = ctx.RenderComponent<RadzenSecurityCode>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Disabled, true));
+
+            Assert.Contains("disabled", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SelectBarTests.cs

@@ -0,0 +1,83 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SelectBarTests
+    {
+        [Fact]
+        public void SelectBar_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSelectBar<int>>();
+
+            Assert.Contains(@"rz-selectbar", component.Markup);
+        }
+
+        [Fact]
+        public void SelectBar_Renders_Orientation()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSelectBar<int>>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenSelectBarItem>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Horizontal));
+            Assert.Contains("rz-selectbar-horizontal", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Vertical));
+            Assert.Contains("rz-selectbar-vertical", component.Markup);
+        }
+
+        [Fact]
+        public void SelectBar_Renders_Multiple()
+        {
+            using var ctx = new TestContext();
+            // When Multiple is true, TValue should be IEnumerable<T>
+            var component = ctx.RenderComponent<RadzenSelectBar<System.Collections.Generic.IEnumerable<int>>>(parameters =>
+            {
+                parameters.Add(p => p.Multiple, true);
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenSelectBarItem>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            Assert.NotNull(component.Instance);
+            Assert.True(component.Instance.Multiple);
+        }
+
+        [Fact]
+        public void SelectBar_Renders_Size()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSelectBar<int>>(parameters =>
+            {
+                parameters.Add(p => p.Items, builder =>
+                {
+                    builder.OpenComponent<RadzenSelectBarItem>(0);
+                    builder.AddAttribute(1, "Text", "Option 1");
+                    builder.AddAttribute(2, "Value", 1);
+                    builder.CloseComponent();
+                });
+            });
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, ButtonSize.Small));
+            Assert.Contains("rz-button-sm", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Size, ButtonSize.Large));
+            Assert.Contains("rz-button-lg", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SidebarToggleTests.cs

@@ -0,0 +1,65 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SidebarToggleTests
+    {
+        [Fact]
+        public void SidebarToggle_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            Assert.Contains(@"rz-sidebar-toggle", component.Markup);
+        }
+
+        [Fact]
+        public void SidebarToggle_Renders_DefaultIcon()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            Assert.Contains("menu", component.Markup);
+        }
+
+        [Fact]
+        public void SidebarToggle_Renders_CustomIcon()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            var icon = "close";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, icon));
+
+            Assert.Contains(icon, component.Markup);
+        }
+
+        [Fact]
+        public void SidebarToggle_Renders_AriaLabel()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            var ariaLabel = "Toggle Navigation";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ToggleAriaLabel, ariaLabel));
+
+            Assert.Contains($"aria-label=\"{ariaLabel}\"", component.Markup);
+        }
+
+        [Fact]
+        public void SidebarToggle_Raises_ClickEvent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSidebarToggle>();
+
+            var clicked = false;
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Click, args => { clicked = true; }));
+
+            component.Find("button").Click();
+
+            Assert.True(clicked);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SkeletonTests.cs

@@ -0,0 +1,158 @@
+using Bunit;
+using Radzen.Blazor.Rendering;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SkeletonTests
+    {
+        [Fact]
+        public void Skeleton_Renders_CssClass()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains("rz-skeleton-text", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_TypeParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Variant, SkeletonVariant.Circular));
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains("rz-skeleton-circular", component.Markup);
+        }
+
+        [Theory]
+        [InlineData(SkeletonVariant.Text, "rz-skeleton-text")]
+        [InlineData(SkeletonVariant.Circular, "rz-skeleton-circular")]
+        [InlineData(SkeletonVariant.Rectangular, "rz-skeleton-rectangular")]
+        public void Skeleton_Renders_AllTypes(SkeletonVariant type, string expectedClass)
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>(parameters => parameters.Add(p => p.Variant, type));
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains(expectedClass, component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_AnimationParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Animation, SkeletonAnimation.Wave));
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains("rz-skeleton-wave", component.Markup);
+        }
+
+        [Theory]
+        [InlineData(SkeletonAnimation.Wave, "rz-skeleton-wave")]
+        [InlineData(SkeletonAnimation.Pulse, "rz-skeleton-pulse")]
+        public void Skeleton_Renders_AllAnimations(SkeletonAnimation animation, string expectedClass)
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>(parameters => parameters.Add(p => p.Animation, animation));
+
+            Assert.Contains("rz-skeleton", component.Markup);
+            Assert.Contains(expectedClass, component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_StyleParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            var style = "width: 200px; height: 20px;";
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Style, style));
+
+            Assert.Contains($"style=\"{style}\"", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_VisibleParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            // Should be visible by default
+            Assert.Contains("rz-skeleton", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Visible, false));
+
+            // Should not render when not visible
+            Assert.DoesNotContain("rz-skeleton", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_Renders_UnmatchedParameter()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("data-testid", "skeleton-test"));
+
+            Assert.Contains("data-testid=\"skeleton-test\"", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_DefaultType_IsText()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            // Should render with text type by default
+            Assert.Contains("rz-skeleton-text", component.Markup);
+        }
+
+        [Fact]
+        public void Skeleton_DefaultAnimation_IsNone()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSkeleton>();
+
+            // Should not render animation classes by default
+            Assert.DoesNotContain("rz-skeleton-wave", component.Markup);
+            Assert.DoesNotContain("rz-skeleton-pulse", component.Markup);
+        }
+    }
+} 

Radzen.Blazor.Tests/SliderTests.cs

@@ -39,7 +39,7 @@ namespace Radzen.Blazor.Tests
             component.SetParametersAndRender(parameters => parameters.Add<int>(p => p.Value, value));
 
             Assert.Contains(@$"style=""width: {Math.Round((value / max * 100)).ToInvariantString()}%;""", component.Markup);
-            Assert.Contains(@$"style=""left: {Math.Round((value / max * 100)).ToInvariantString()}%;""", component.Markup);
+            Assert.Contains(@$"style=""inset-inline-start: {Math.Round((value / max * 100)).ToInvariantString()}%;""", component.Markup);
         }
 
         [Fact]
@@ -55,9 +55,9 @@ namespace Radzen.Blazor.Tests
                 parameters.Add<IEnumerable<int>>(p => p.Value, new int[] { 4, 30 });
             });
 
-            Assert.Contains(@$"left: 4%", component.Markup);
-            Assert.Contains(@$"left: 30%", component.Markup);
-            Assert.Contains(@$"left: 4%; width: 26%;", component.Markup);
+            Assert.Contains(@$"inset-inline-start: 4%", component.Markup);
+            Assert.Contains(@$"inset-inline-start: 30%", component.Markup);
+            Assert.Contains(@$"inset-inline-start: 4%; width: 26%;", component.Markup);
         }
 
         [Fact]
@@ -89,5 +89,71 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains(@$"autofocus", component.Markup);
         }
+
+        [Fact]
+        public void Slider_Renders_Orientation_Vertical()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Vertical);
+            });
+
+            Assert.Contains("rz-slider-vertical", component.Markup);
+        }
+
+        [Fact]
+        public void Slider_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>(parameters =>
+            {
+                parameters.Add(p => p.Disabled, true);
+            });
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void Slider_Renders_SliderHandle()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>();
+
+            Assert.Contains("rz-slider-handle", component.Markup);
+        }
+
+        [Fact]
+        public void Slider_Renders_SliderRange()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>();
+
+            Assert.Contains("rz-slider-range", component.Markup);
+        }
+
+        [Fact]
+        public void Slider_Renders_TabIndex()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            var component = ctx.RenderComponent<RadzenSlider<int>>();
+
+            Assert.Contains("tabindex=\"0\"", component.Markup);
+        }
     }
 }

Radzen.Blazor.Tests/SpeechToTextButtonTests.cs

@@ -0,0 +1,197 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SpeechToTextButtonTests
+    {
+        [Fact]
+        public void SpeechToTextButton_Renders_Record_Button_When_Visible()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenSpeechToTextButton>();
+
+            component.Render();
+
+            var recordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button");
+
+            Assert.NotNull(recordButton);
+        }
+
+        [Fact]
+        public void SpeechToTextButton_Does_Not_Renders_Record_Button_When_Visible_False()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenSpeechToTextButton>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Visible, false);
+            });
+
+            Assert.Throws<ElementNotFoundException>(() => component.Find("button.rz-button-icon-only.rz-speech-to-text-button"));
+        }
+
+        [Fact]
+        public void SpeechToTextButton_Renders_Additional_Css()
+        {
+            using var ctx = new TestContext();
+
+            var component =
+                ctx.RenderComponent<RadzenSpeechToTextButton>(ComponentParameter.CreateParameter("class", "another-class"));
+
+            var recordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button.another-class");
+
+            Assert.NotNull(recordButton);
+        }
+
+        [Fact]
+        public void SpeechToTextButton_Can_Override_Default_Title_And_Aria_Label()
+        {
+            using var ctx = new TestContext();
+
+            var component =
+                ctx.RenderComponent<RadzenSpeechToTextButton>(
+                    ComponentParameter.CreateParameter("title", "title override"),
+                    ComponentParameter.CreateParameter("aria-label", "aria-label override"));
+
+            var recordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button");
+
+            Assert.NotNull(recordButton);
+            Assert.Equal("title override", recordButton.GetAttribute("title"));
+            Assert.Equal("aria-label override", recordButton.GetAttribute("aria-label"));
+        }
+
+        [Fact]
+        public void SpeechToTextButton_Sets_Record_Button_Css_When_Record_Button_Clicked()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenSpeechToTextButton>();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            component.Render();
+
+            var recordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button");
+
+            Assert.NotNull(recordButton);
+
+            recordButton.Click();
+
+            component.Render();
+
+            var blinkingRecordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button-recording");
+
+            Assert.NotNull(blinkingRecordButton);
+        }
+
+        [Fact]
+        public void SpeechToTextButton_Sets_StopTitle_When_Record_Button_Clicked()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenSpeechToTextButton>();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            component.Render();
+
+            var recordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button");
+
+            Assert.NotNull(recordButton);
+
+            recordButton.Click();
+
+            component.Render();
+
+            var blinkingRecordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button-recording");
+
+            Assert.Equal(component.Instance.StopTitle, blinkingRecordButton.GetAttribute("title"));
+        }
+
+        [Fact]
+        public void SpeechToTextButton_ChangesIconWhen_When_Record_Button_Clicked()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenSpeechToTextButton>();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            component.Render();
+
+            var recordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button");
+
+            Assert.NotNull(recordButton);
+
+            recordButton.Click();
+
+            component.Render();
+
+            var blinkingRecordButton = component.Find("button span");
+
+            Assert.Contains("stop", blinkingRecordButton.TextContent);
+            Assert.DoesNotContain("mic", blinkingRecordButton.TextContent);
+        }
+
+        [Fact]
+        public void SpeechToTextButton_UnSets_Record_Button_Css_When_Record_Button_Clicked_Twice()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenSpeechToTextButton>();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            component.Render();
+
+            var recordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button");
+
+            Assert.NotNull(recordButton);
+
+            recordButton.Click();
+
+            component.Render();
+
+            const string blinkingRecordButtonSelector = "button.rz-button-icon-only.rz-speech-to-text-button-recording";
+            var blinkingRecordButton = component.Find(blinkingRecordButtonSelector);
+
+            Assert.NotNull(blinkingRecordButton);
+
+            blinkingRecordButton.Click();
+
+            component.Render();
+
+            Assert.Throws<ElementNotFoundException>(() => component.Find(blinkingRecordButtonSelector));
+        }
+
+        [Fact]
+        public void SpeechToTextButton_Invokes_OnResult_FromJs()
+        {
+            using var ctx = new TestContext();
+
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+
+            var component = ctx.RenderComponent<RadzenSpeechToTextButton>();
+
+            string resultsFromJs = null;
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Change, r => resultsFromJs = r));
+
+            var recordButton = component.Find("button.rz-button-icon-only.rz-speech-to-text-button");
+
+            Assert.NotNull(recordButton);
+
+            recordButton.Click();
+
+            const string speechResults = "results from js";
+
+            component.InvokeAsync(() => component.Instance.OnResult(speechResults));
+
+            Assert.Equal(speechResults, resultsFromJs);
+        }
+    }
+}

Radzen.Blazor.Tests/SplitButtonTests.cs

@@ -1,4 +1,5 @@
 using Bunit;
+using Microsoft.AspNetCore.Components;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -44,7 +45,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, icon));
 
-            Assert.Contains(@$"<i class=""rz-button-icon-left rzi"">{icon}</i>", component.Markup);
+            Assert.Contains(@$"<i class=""notranslate rz-button-icon-left rzi"">{icon}</i>", component.Markup);
         }
 
         [Fact]
@@ -59,10 +60,10 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => {
                 parameters.Add(p => p.Text, text);
-                parameters.Add(p => p.Icon, icon); 
+                parameters.Add(p => p.Icon, icon);
             });
 
-            Assert.Contains(@$"<i class=""rz-button-icon-left rzi"">{icon}</i>", component.Markup);
+            Assert.Contains(@$"<i class=""notranslate rz-button-icon-left rzi"">{icon}</i>", component.Markup);
             Assert.Contains(@$"<span class=""rz-button-text"">{text}</span>", component.Markup);
         }
 
@@ -77,7 +78,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Image, image));
 
-            Assert.Contains(@$"<img class=""rz-button-icon-left rzi"" src=""{image}"" />", component.Markup);
+            Assert.Contains(@$"<img class=""notranslate rz-button-icon-left rzi"" src=""{image}"" alt=""image"" />", component.Markup);
         }
 
         [Fact]
@@ -93,12 +94,29 @@ namespace Radzen.Blazor.Tests
             component.SetParametersAndRender(parameters => {
                 parameters.Add(p => p.Text, text);
                 parameters.Add(p => p.Image, image);
+                parameters.Add(p => p.ImageAlternateText, text);
             });
 
-            Assert.Contains(@$"<img class=""rz-button-icon-left rzi"" src=""{image}"" />", component.Markup);
+            Assert.Contains(@$"<img class=""notranslate rz-button-icon-left rzi"" src=""{image}"" alt=""{text}"" />", component.Markup);
             Assert.Contains(@$"<span class=""rz-button-text"">{text}</span>", component.Markup);
         }
 
+        [Fact]
+        public void SplitButton_Renders_ButtonContent()
+        {
+            using var ctx = new TestContext();
+
+            RenderFragment buttonContent = (builder) => builder.AddMarkupContent(0, "<strong>Custom button content</strong>");
+
+            var text = "Test";
+            var component = ctx.RenderComponent<RadzenSplitButton>(parameters => parameters
+            .Add(p => p.ButtonContent, buttonContent)
+            .Add(p => p.Text, text));
+
+            Assert.Contains(@$"<strong>Custom button content</strong>", component.Markup);
+            Assert.DoesNotContain(@$"<span class=""rz-button-text"">{text}</span>", component.Markup);
+        }
+
         [Fact]
         public void SplitButton_Renders_DisabledParameter()
         {
@@ -127,6 +145,8 @@ namespace Radzen.Blazor.Tests
         public void SplitButton_Raises_ClickEvent()
         {
             using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
 
             var component = ctx.RenderComponent<RadzenSplitButton>();
 

Radzen.Blazor.Tests/SplitterTests.cs

@@ -0,0 +1,42 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class SplitterTests
+    {
+        [Fact]
+        public void Splitter_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSplitter>();
+
+            Assert.Contains(@"rz-splitter", component.Markup);
+        }
+
+        [Fact]
+        public void Splitter_Renders_Orientation_Horizontal()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSplitter>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Horizontal);
+            });
+
+            Assert.Contains("rz-splitter-horizontal", component.Markup);
+        }
+
+        [Fact]
+        public void Splitter_Renders_Orientation_Vertical()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSplitter>(parameters =>
+            {
+                parameters.Add(p => p.Orientation, Orientation.Vertical);
+            });
+
+            Assert.Contains("rz-splitter-vertical", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/StackTests.cs

@@ -0,0 +1,98 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class StackTests
+    {
+        [Fact]
+        public void Stack_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            Assert.Contains(@"rz-stack", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>(parameters =>
+            {
+                parameters.AddChildContent("<div>Stack Content</div>");
+            });
+
+            Assert.Contains("Stack Content", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_Orientation()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Horizontal));
+            Assert.Contains("rz-flex-row", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Vertical));
+            Assert.Contains("rz-flex-column", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_Gap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Gap, "1.5rem"));
+
+            Assert.Contains("--rz-gap:1.5rem", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_AlignItems()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlignItems, AlignItems.Center));
+
+            Assert.Contains("rz-align-items-center", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_JustifyContent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.JustifyContent, JustifyContent.SpaceBetween));
+
+            Assert.Contains("rz-justify-content-space-between", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_Wrap()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Wrap, FlexWrap.Wrap));
+
+            Assert.Contains("flex-wrap:wrap", component.Markup);
+        }
+
+        [Fact]
+        public void Stack_Renders_Reverse()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenStack>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Reverse, true));
+
+            Assert.Contains("rz-flex-column-reverse", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/StepsTests.cs

@@ -0,0 +1,70 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class StepsTests
+    {
+        [Fact]
+        public void Steps_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>();
+
+            Assert.Contains(@"rz-steps", component.Markup);
+        }
+
+        [Fact]
+        public void Steps_Renders_ShowStepsButtons_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>(parameters =>
+            {
+                parameters.Add(p => p.ShowStepsButtons, true);
+            });
+
+            Assert.Contains("rz-steps-buttons", component.Markup);
+        }
+
+        [Fact]
+        public void Steps_Renders_ShowStepsButtons_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>(parameters =>
+            {
+                parameters.Add(p => p.ShowStepsButtons, false);
+            });
+
+            Assert.DoesNotContain("rz-steps-buttons", component.Markup);
+        }
+
+        [Fact]
+        public void Steps_Renders_StepsButtons()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>(parameters =>
+            {
+                parameters.Add(p => p.ShowStepsButtons, true);
+            });
+
+            Assert.Contains("rz-steps-prev", component.Markup);
+            Assert.Contains("rz-steps-next", component.Markup);
+        }
+
+        [Fact]
+        public void Steps_Renders_CustomButtonText()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenSteps>(parameters =>
+            {
+                parameters.Add(p => p.ShowStepsButtons, true);
+                parameters.Add(p => p.NextText, "Continue");
+                parameters.Add(p => p.PreviousText, "Back");
+            });
+
+            Assert.Contains("Continue", component.Markup);
+            Assert.Contains("Back", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/SwitchTests.cs

@@ -41,7 +41,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Style, value));
 
-            Assert.Contains(@$"style=""outline: 0 none;{value}""", component.Markup);
+            Assert.Contains(@$"style=""{value}""", component.Markup);
         }
 
         [Fact]
@@ -134,5 +134,18 @@ namespace Radzen.Blazor.Tests
             Assert.True(raised);
             Assert.True(object.Equals(value, !(bool)newValue));
         }
+
+        [Fact]
+        public void Switch_Renders_ReadOnlyParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenSwitch>();
+
+            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.ReadOnly, true));
+
+            Assert.Contains(@$"rz-readonly", component.Markup);
+        }
+
     }
 }

Radzen.Blazor.Tests/TableTests.cs

@@ -0,0 +1,100 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class TableTests
+    {
+        [Fact]
+        public void Table_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>();
+
+            Assert.Contains(@"rz-datatable", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_TableElement()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>();
+
+            Assert.Contains("rz-grid-table", component.Markup);
+            Assert.Contains("<table", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_GridLines_None()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.GridLines, DataGridGridLines.None);
+            });
+
+            Assert.Contains("rz-grid-gridlines-none", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_GridLines_Horizontal()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.GridLines, DataGridGridLines.Horizontal);
+            });
+
+            Assert.Contains("rz-grid-gridlines-horizontal", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_GridLines_Vertical()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.GridLines, DataGridGridLines.Vertical);
+            });
+
+            Assert.Contains("rz-grid-gridlines-vertical", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_GridLines_Both()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.GridLines, DataGridGridLines.Both);
+            });
+
+            Assert.Contains("rz-grid-gridlines-both", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_AllowAlternatingRows_True()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, true);
+            });
+
+            Assert.Contains("rz-grid-table-striped", component.Markup);
+        }
+
+        [Fact]
+        public void Table_Renders_AllowAlternatingRows_False()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTable>(parameters =>
+            {
+                parameters.Add(p => p.AllowAlternatingRows, false);
+            });
+
+            Assert.DoesNotContain("rz-grid-table-striped", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/TabsTests.cs

@@ -0,0 +1,108 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class TabsTests
+    {
+        [Fact]
+        public void Tabs_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>();
+
+            Assert.Contains(@"rz-tabview", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_Top()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.Top);
+            });
+
+            Assert.Contains("rz-tabview-top", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_Bottom()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.Bottom);
+            });
+
+            Assert.Contains("rz-tabview-bottom", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_Left()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.Left);
+            });
+
+            Assert.Contains("rz-tabview-left", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_Right()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.Right);
+            });
+
+            Assert.Contains("rz-tabview-right", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_TopRight()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.TopRight);
+            });
+
+            Assert.Contains("rz-tabview-top-right", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPosition_BottomRight()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>(parameters =>
+            {
+                parameters.Add(p => p.TabPosition, TabPosition.BottomRight);
+            });
+
+            Assert.Contains("rz-tabview-bottom-right", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabNav()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>();
+
+            Assert.Contains("rz-tabview-nav", component.Markup);
+        }
+
+        [Fact]
+        public void Tabs_Renders_TabPanels()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTabs>();
+
+            Assert.Contains("rz-tabview-panels", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/Temperature.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Globalization;
+
+namespace Radzen.Blazor.Tests;
+
+public record struct Temperature(decimal DegreesCelsius)
+    : IFormattable
+{
+    public decimal Celsius => DegreesCelsius;
+    public decimal Fahrenheit => DegreesCelsius * 9 / 5 + 32;
+    public decimal Kelvin => DegreesCelsius + 273.15m;
+
+    public override string ToString() => ToString("G");
+    public string ToString(string format) => ToString(format, CultureInfo.CurrentCulture);
+
+    public string ToString(string format, IFormatProvider provider)
+    {
+        provider ??= CultureInfo.CurrentCulture;
+        if (string.IsNullOrEmpty(format))
+            format = "G";
+
+        switch (format.ToUpperInvariant())
+        {
+            case "G":
+            case "C":
+                return $"{Celsius.ToString("F2", provider)} °C";
+            case "F":
+                return $"{Fahrenheit.ToString("F2", provider)} °F";
+            case "K":
+                return $"{Kelvin.ToString("F2", provider)} K";
+            default:
+                throw new FormatException($"The {format} format string is not supported.");
+        }
+    }
+}

Radzen.Blazor.Tests/TextBoxTests.cs

@@ -1,4 +1,6 @@
 using Bunit;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Forms;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -29,6 +31,26 @@ namespace Radzen.Blazor.Tests
             Assert.Contains(@$"value=""{value}""", component.Markup);
         }
 
+        [Fact]
+        public void TextboxCanSetFieldIdentifier()
+        {
+            using var ctx = new TestContext();
+
+            var editContext = new EditContext(ctx);
+            var fieldIdentifier = new FieldIdentifier(ctx, nameof(RadzenTextBox.Value));
+            ctx.RenderTree.TryAdd<CascadingValue<EditContext>>(parameters =>
+            {
+                parameters.Add(e => e.Value, editContext);
+            });
+
+            var component = ctx.RenderComponent<RadzenTextBox>(parameters =>
+            {
+                parameters.Add(p => p.FieldIdentifier, fieldIdentifier);
+            });
+
+            Assert.Equal(component.Instance.FieldIdentifier, fieldIdentifier);
+        }
+
         [Fact]
         public void TextBox_Renders_StyleParameter()
         {
@@ -119,13 +141,54 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenTextBox>();
 
-            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AutoComplete, false));
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+
+            Assert.Contains(@$"autocomplete=""off""", component.Markup);
+            Assert.Contains(@$"aria-autocomplete=""none""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+
+            Assert.Contains(@$"autocomplete=""on""", component.Markup);
+            Assert.DoesNotContain(@$"aria-autocomplete", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("autocomplete", "custom"));
+
+            Assert.Contains(@$"autocomplete=""custom""", component.Markup);
+            Assert.DoesNotContain(@$"aria-autocomplete", component.Markup);
+
+            component.Instance.DefaultAutoCompleteAttribute = "autocomplete-custom";
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+
+            Assert.Contains(@$"autocomplete=""autocomplete-custom""", component.Markup);
+            Assert.Contains(@$"aria-autocomplete=""none""", component.Markup);
+        }
+
+        [Fact]
+        public void TextBox_Renders_TypedAutoCompleteParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenTextBox>();
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", false));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.On));
 
             Assert.Contains(@$"autocomplete=""off""", component.Markup);
 
-            component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.AutoComplete, true));
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.Off));
 
-            Assert.Contains(@$"autocomplete=""on""", component.Markup);
+            Assert.Contains(@$"autocomplete=""off""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.AdditionalName));
+
+            Assert.Contains(@$"autocomplete=""{AutoCompleteType.AdditionalName.GetAutoCompleteValue()}""", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.AddUnmatched("AutoComplete", true));
+            component.SetParametersAndRender(parameters => parameters.Add<AutoCompleteType>(p => p.AutoCompleteType, AutoCompleteType.FamilyName));
+
+            Assert.Contains(@$"autocomplete=""{AutoCompleteType.FamilyName.GetAutoCompleteValue()}""", component.Markup);
         }
 
         [Fact]

Radzen.Blazor.Tests/TimelineTests.cs

@@ -0,0 +1,71 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class TimelineTests
+    {
+        [Fact]
+        public void Timeline_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            Assert.Contains(@"rz-timeline", component.Markup);
+        }
+
+        [Fact]
+        public void Timeline_Renders_Orientation()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Horizontal));
+            Assert.Contains("rz-timeline-row", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Orientation, Orientation.Vertical));
+            Assert.Contains("rz-timeline-column", component.Markup);
+        }
+
+        [Fact]
+        public void Timeline_Renders_LinePosition()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.LinePosition, LinePosition.Start));
+            Assert.Contains("rz-timeline-start", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.LinePosition, LinePosition.End));
+            Assert.Contains("rz-timeline-end", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.LinePosition, LinePosition.Center));
+            Assert.Contains("rz-timeline-center", component.Markup);
+        }
+
+        [Fact]
+        public void Timeline_Renders_AlignItems()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlignItems, AlignItems.Start));
+            Assert.Contains("rz-timeline-align-items-start", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.AlignItems, AlignItems.Center));
+            Assert.Contains("rz-timeline-align-items-center", component.Markup);
+        }
+
+        [Fact]
+        public void Timeline_Renders_Reverse()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenTimeline>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Reverse, true));
+
+            Assert.Contains("rz-timeline-reverse", component.Markup);
+        }
+    }
+}
+

Radzen.Blazor.Tests/ToggleButtonTests.cs

@@ -0,0 +1,98 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class ToggleButtonTests
+    {
+        [Fact]
+        public void ToggleButton_Renders_WithClassName()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            Assert.Contains(@"rz-button", component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_TextParameter()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            var text = "Toggle Me";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_IconParameter()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            var icon = "toggle_on";
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Icon, icon));
+
+            Assert.Contains(icon, component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_Value()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Value, true));
+
+            Assert.Contains("rz-state-active", component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_Disabled()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Disabled, true));
+
+            Assert.Contains("rz-state-disabled", component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Renders_ButtonStyle()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ButtonStyle, ButtonStyle.Primary));
+            Assert.Contains("rz-primary", component.Markup);
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.ButtonStyle, ButtonStyle.Success));
+            Assert.Contains("rz-success", component.Markup);
+        }
+
+        [Fact]
+        public void ToggleButton_Raises_ChangeEvent()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenToggleButton>();
+
+            var changed = false;
+            bool newValue = false;
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Change, args =>
+            {
+                changed = true;
+                newValue = args;
+            }));
+
+            component.Find("button").Click();
+
+            Assert.True(changed);
+            Assert.True(newValue);
+        }
+    }
+}
+