Version updated

Fix #2405

.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,10 +11,10 @@ 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 Pro or Team subscription you can also 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).
+4. Please adhere to the issue template. Specify all the steps required to reproduce the issue.
 -->
 
 **Describe the bug**
@@ -27,7 +27,12 @@ Steps to reproduce the behavior:
 3. Scroll down to '....'
 4. See error
 
-Alternatively link your repo with a sample project that can be run.
+Alternatively make a new [playground](https://blazor.radzen.com/playground) snippet and paste its URL.
+1. Go to any live demo at https://blazor.radzen.com
+2. Click the **Edit Source** tab.
+3. Then click **Open in Playground**.
+4. Reproduce the problem and save the snippet.
+5. Copy the snippet URL and provide it in the issue description.
 
 **Expected behavior**
 A clear and concise description of what you expected to happen.

.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: 10.0.x
+    
+    - name: Build
+      run: dotnet build Radzen.Blazor/Radzen.Blazor.csproj
+    - name: Test
+      run: dotnet test Radzen.Blazor.Tests/Radzen.Blazor.Tests.csproj

.github/workflows/deploy.yml

@@ -0,0 +1,66 @@
+name: Deploy to blazor.radzen.com
+
+on:
+  workflow_dispatch:
+
+concurrency:
+  group: blazor-radzen-prod
+  cancel-in-progress: true
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      packages: write
+
+    env:
+      REGISTRY: ghcr.io
+      IMAGE_NAME: ${{ github.repository }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Compute image tag (timestamp)
+        id: meta
+        run: |
+          TAG=$(date -u +"%Y%m%d%H%M%S")
+          IMAGE="${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${TAG}"
+          echo "image=$IMAGE" >> "$GITHUB_OUTPUT"
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.image }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Push to dokku
+        uses: dokku/github-action@master
+        with:
+          git_remote_url: ${{ secrets.DOKKU_REPO }}
+          ssh_private_key: ${{ secrets.DOKKU_SSH_PRIVATE_KEY }}
+          deploy_docker_image: ${{ steps.meta.outputs.image }}
+
+      - name: Prune GHCR versions (keep 1)
+        uses: actions/delete-package-versions@v5
+        with:
+          package-name: radzen-blazor
+          package-type: container
+          min-versions-to-keep: 1
+          delete-only-pre-release-versions: false

.gitignore

@@ -8,6 +8,7 @@
 *.user
 *.userosscache
 *.sln.docstates
+global.json
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
@@ -333,3 +334,17 @@ issues.json
 
 Radzen.Blazor/wwwroot/css/
 project.csproj
+RadzenBlazorDemos/wwwroot/docs/
+Radzen.DocFX/obj/
+Radzen.DocFX/_site/
+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

@@ -5,23 +5,21 @@
 This is a set of guidelines for contributing to Radzen.Blazor.
 
 ## Asking questions
-
 Please don't open an issue to ask a question about using Radzen.Blazor components. You can check the following resources instead:
 
-- [Online demos](https://blazor.radzen.com)
-
+### [Online demos](https://blazor.radzen.com)
 A showcase application that demonstrates all Radzen.Blazor components. You will find various use cases that demonstrate the component features and API. The source 
 of the demos is available [here](https://github.com/radzenhq/radzen-blazor/tree/master/RadzenBlazorDemos).
-- [Documentation](https://www.radzen.com/documentation/blazor/accordion/)
 
+### [Documentation](https://blazor.radzen.com/docs/)
 Technical documentation and API reference.
-- [Online forum](https://forum.radzen.com)
 
+### [Community forum](https://forum.radzen.com)
 You can ask your question here. Please use the [Radzen.Blazor Components](https://forum.radzen.com/c/blazor-components/10) category.
 
-- Dedicated technical support
+### 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?
 
@@ -67,7 +65,8 @@ Explain the enhancement and include additional details:
 If you want to contribute a new feature of fix a bug you can open a pull request. 
 
 Make sure you follow this procedure:
-
+* **Important!!!** if you itent to make a lot of changes in a pull request open an issue to discuss this with us first. The Radzen Blazor Components have a lot of
+moving parts and making big changes should be done with extra precautions. 
 * **Be sure that none of the existing tests** breaks after your changes. The test project is available [here](https://github.com/radzenhq/radzen-blazor/tree/master/Radzen.Blazor.Tests).
 * **If possible add new tests that verify your fix or new feature**. 
 * **Follow the existing coding style** (to be described in detail later).

Dockerfile

@@ -0,0 +1,48 @@
+# =============================
+# BUILD STAGE
+# =============================
+FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
+WORKDIR /src
+
+# Copy project files first for better caching
+COPY Radzen.Blazor/*.csproj Radzen.Blazor/
+COPY RadzenBlazorDemos/*.csproj RadzenBlazorDemos/
+COPY RadzenBlazorDemos.Host/*.csproj RadzenBlazorDemos.Host/
+
+# Radzen.DocFX usually has no csproj → copy full folder
+COPY Radzen.DocFX/ Radzen.DocFX/
+
+# Restore dependencies
+RUN dotnet restore RadzenBlazorDemos.Host/RadzenBlazorDemos.Host.csproj
+
+# Copy full source after restore layer
+COPY . .
+
+# Install docfx (build stage only)
+RUN dotnet tool install -g docfx
+ENV PATH="$PATH:/root/.dotnet/tools"
+
+# Build shared project (keep net8.0 if required)
+RUN dotnet build -c Release Radzen.Blazor/Radzen.Blazor.csproj -f net8.0
+
+# Generate documentation
+RUN docfx Radzen.DocFX/docfx.json
+
+# Publish the Blazor host app
+WORKDIR /src/RadzenBlazorDemos.Host
+RUN dotnet publish -c Release -o /app/out
+
+
+# =============================
+# RUNTIME STAGE
+# =============================
+FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS runtime
+WORKDIR /app
+
+# Copy only published output
+COPY --from=build /app/out ./
+
+# Set runtime URL
+ENV ASPNETCORE_URLS=http://+:5000
+
+ENTRYPOINT ["dotnet", "RadzenBlazorDemos.Host.dll"]

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018-2021 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. The demos require the .NET 10 SDK and should preferably be opened in VS2026.

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/BadgeTests.cs

@@ -0,0 +1,47 @@
+using Bunit;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class BadgeTests
+    {
+        [Fact]
+        public void Badge_Renders_TextParameter()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenBadge>();
+
+            var text = "Test";
+
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.Text, text));
+
+            Assert.Contains(text, component.Markup);
+        }
+
+        [Fact]
+        public void Badge_Renders_ChildContent()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenBadge>();
+
+            component.SetParametersAndRender(parameters => parameters.AddChildContent("SomeContent"));
+
+            Assert.Contains(@$"SomeContent", component.Markup);
+        }
+
+        [Fact]
+        public void Badge_Renders_BadgeStyle()
+        {
+            var badgeStyle = BadgeStyle.Danger;
+
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenBadge>();
+            component.SetParametersAndRender(parameters => parameters.Add(p => p.BadgeStyle, badgeStyle));
+
+            Assert.Contains($"badge-{badgeStyle.ToString().ToLower()}", component.Markup);
+        }
+    }
+}

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,29 @@ 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]
+        public void Button_Renders_BusySpinner()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenButton>();
+
+            var icon = "account_circle";
+
+            component.SetParametersAndRender(parameters => parameters
+                .Add(p => p.Icon, icon)
+                .Add(p => p.IsBusy, true)
+            );
+
+            // does not render the actual icon when busy
+            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);
+            Assert.Contains(">refresh</i>", component.Markup);
         }
 
         [Fact]
@@ -43,12 +65,13 @@ namespace Radzen.Blazor.Tests
             var text = "Test";
             var icon = "account_circle";
 
-            component.SetParametersAndRender(parameters => {
+            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);
         }
 
@@ -63,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]
@@ -76,12 +99,14 @@ namespace Radzen.Blazor.Tests
             var text = "Test";
             var image = "test.png";
 
-            component.SetParametersAndRender(parameters => {
+            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);
         }
 
@@ -110,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

@@ -110,7 +110,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Change, args => { raised = true; }));
 
-            component.Find("div").MouseUp();
+            component.Find("div.rz-chkbox-box").Click();
 
             Assert.True(raised);
         }
@@ -126,7 +126,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.ValueChanged, args => { raised = true; }));
 
-            component.Find("div").MouseUp();
+            component.Find("div.rz-chkbox-box").Click();
 
             Assert.True(raised);
         }
@@ -141,24 +141,102 @@ namespace Radzen.Blazor.Tests
             component.SetParametersAndRender(parameters => parameters.Add<bool>(p => p.TriState, true));
 
 
-            component.Find("div").MouseUp();
+            component.Find("div.rz-chkbox-box").Click();
 
             component.Render();
 
             Assert.Contains(@$"rz-state-active", component.Markup);
             Assert.Contains(@$"rzi-check", component.Markup);
 
-            component.Find("div").MouseUp();
+            component.Find("div.rz-chkbox-box").Click();
 
             component.Render();
 
             Assert.DoesNotContain(@$"rz-state-active", component.Markup);
             Assert.DoesNotContain(@$"rzi-check", component.Markup);
 
-            component.Find("div").MouseUp();
+            component.Find("div.rz-chkbox-box").Click();
 
             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,8 +1,8 @@
 using Bunit;
-using Radzen.Blazor.Rendering;
 using System;
-using System.Collections;
 using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -18,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]
@@ -49,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);
             });
@@ -69,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);
             });
@@ -91,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);
@@ -108,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");
             });
@@ -127,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]
@@ -144,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]
@@ -168,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()
         {
@@ -212,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]
@@ -230,7 +264,7 @@ namespace Radzen.Blazor.Tests
         }
 
         [Fact]
-        public void DatePicker_Raises_ChangeEventOnNextMonth()
+        public void DatePicker_NotRaises_ChangeEventOnNextMonth()
         {
             using var ctx = new TestContext();
             ctx.JSInterop.Mode = JSRuntimeMode.Loose;
@@ -241,18 +275,18 @@ 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.True(raised);
-            Assert.True(((DateTime)newValue) > DateTime.Now);
+            Assert.False(raised);
         }
 
         [Fact]
-        public void DatePicker_Raises_ValueChangedEventOnNextMonth()
+        public void DatePicker_NotRaises_ValueChangedEventOnNextMonth()
         {
             using var ctx = new TestContext();
             ctx.JSInterop.Mode = JSRuntimeMode.Loose;
@@ -263,18 +297,18 @@ 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.True(raised);
-            Assert.True(((DateTime)newValue) > DateTime.Now);
+            Assert.False(raised);
         }
 
         [Fact]
-        public void DatePicker_Raises_ChangeEventOnPrevMonth()
+        public void DatePicker_NotRaises_ChangeEventOnPrevMonth()
         {
             using var ctx = new TestContext();
             ctx.JSInterop.Mode = JSRuntimeMode.Loose;
@@ -285,18 +319,18 @@ 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.True(raised);
-            Assert.True(((DateTime)newValue) < DateTime.Now);
+            Assert.False(raised);
         }
 
         [Fact]
-        public void DatePicker_Raises_ValueChangedEventOnPrevMonth()
+        public void DatePicker_NotRaises_ValueChangedEventOnPrevMonth()
         {
             using var ctx = new TestContext();
             ctx.JSInterop.Mode = JSRuntimeMode.Loose;
@@ -307,14 +341,521 @@ 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);
+        }
+
+        [Fact]
+        public void DatePicker_Raises_ValueChangedEvent_Returns_PreviousDateOnInputOnDisabledDates()
+        {
+            IEnumerable<DateTime> dates = new DateTime[] { DateTime.Today };
+            DateTime previousDay = DateTime.Today.AddDays(-1);
+
+            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.ValueChanged, args => { raised = true; newValue = args; })
+                          .Add(p => p.DateRender, args => { args.Disabled = dates.Contains(args.Date); });
+            });
+
+            var inputElement = component.Find(".rz-inputtext");
+
+            // initialize DateTimeValue
+            ctx.JSInterop.Setup<string>("Radzen.getInputValue", invocation => true).SetResult(previousDay.ToShortDateString());
+            inputElement.Change(previousDay.AddDays(-1));
+
+            // try to enter disabled date
+            ctx.JSInterop.Setup<string>("Radzen.getInputValue", invocation => true).SetResult(DateTime.Today.ToShortDateString());
+            inputElement.Change(DateTime.Today);
 
             Assert.True(raised);
-            Assert.True(((DateTime)newValue) < DateTime.Now);
+            Assert.Equal(previousDay, (DateTime)newValue);
+        }
+
+        [Fact]
+        public void DatePicker_Clears_InputOnDisabledDates()
+        {
+            IEnumerable<DateTime> dates = new DateTime[] { DateTime.Today };
+            DateTime previousDay = DateTime.Today.AddDays(-1);
+
+            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.ValueChanged, args => { raised = true; newValue = args; })
+                          .Add(p => p.DateRender, args => { args.Disabled = dates.Contains(args.Date); });
+            });
+
+            var inputElement = component.Find(".rz-inputtext");
+
+            // initialize DateTimeValue
+            ctx.JSInterop.Setup<string>("Radzen.getInputValue", invocation => true).SetResult(previousDay.ToShortDateString());
+            inputElement.Change(previousDay.AddDays(-1));
+
+            // try to enter disabled date
+            ctx.JSInterop.Setup<string>("Radzen.getInputValue", invocation => true).SetResult(DateTime.Today.ToShortDateString());
+            inputElement.Change(DateTime.Today);
+
+            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);
+            });
+
+            Assert.Contains(DateTime.MaxValue.ToString(component.Instance.DateFormat), component.Markup);
+
+            var exception = Record.Exception(() => component.Find(".rz-calendar-next-icon")
+                                                            .Click());
+            Assert.Null(exception);
+        }
+
+        [Theory]
+        [InlineData(DateTimeKind.Local)]
+        [InlineData(DateTimeKind.Unspecified)]
+        [InlineData(DateTimeKind.Utc)]
+        public void DatePicker_Respects_DateTimeKind(DateTimeKind kind)
+        {
+            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(x => x.Kind, kind);
+                parameters.Add(x => x.ShowTime, true);
+            });
+
+            var raised = false;
+            object newValue = null;
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add(p => p.Change, args => { raised = true; newValue = args; });
+            });
+
+            component.Find(".rz-calendar-next-icon").Click();
+            component.FindAll(".rz-button-text").First(x => x.TextContent == "Ok").Click();
+
+            Assert.True(raised);
+            Assert.Equal(kind, ((DateTime)newValue).Kind);
+        }
+
+        [Fact]
+        public void DatePicker_Renders_FooterTemplate()
+        {
+            using var ctx = new TestContext();
+            ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+            ctx.JSInterop.SetupModule("_content/Radzen.Blazor/Radzen.Blazor.js");
+
+            string actionsTemplate = "<input type=\"button\" value=\"Test\" />";
+
+            var component = ctx.RenderComponent<RadzenDatePicker<DateTime>>(parameters =>
+            {
+                parameters.Add(p => p.Value, DateTime.MinValue);
+                parameters.Add(p => p.FooterTemplate, actionsTemplate);
+            });
+
+            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,413 @@
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+	public class DialogServiceTests : ComponentBase
+	{
+		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 OpenSideDialogTests
+        {
+            [Fact(DisplayName = "SideDialogOptions resizable option is retained after OpenSideDialog call")]
+            public void SideDialogOptions_Resizable_AreRetained_AfterOpenSideDialogCall()
+            {
+                // Arrange
+                var options = new SideDialogOptions { Resizable = true };
+                SideDialogOptions resultingOptions = null;
+                var dialogService = new DialogService(null, null);
+                dialogService.OnSideOpen += (_, _, sideOptions) => resultingOptions = sideOptions;
+
+                // Act
+                dialogService.OpenSide<DialogServiceTests>("Test", [], options);
+
+                // Assert
+                Assert.NotNull(resultingOptions);
+                Assert.Same(options, resultingOptions);
+                Assert.True(resultingOptions.Resizable);
+            }
+
+            [Fact(DisplayName = "Side dialog shows resize bar when Resizable is true")]
+            public void SideDialog_Resizable_ShowsResizeBar()
+            {
+                using var ctx = new TestContext();
+                ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+                ctx.Services.AddScoped<DialogService>();
+
+                // Render the dialog host
+                var cut = ctx.RenderComponent<RadzenDialog>();
+
+                // Open a side dialog with Resizable=true
+                var dialogService = ctx.Services.GetRequiredService<DialogService>();
+                cut.InvokeAsync(() => dialogService.OpenSide("Test", typeof(RadzenButton),
+                    new Dictionary<string, object>(), new SideDialogOptions { Resizable = true }));
+
+                // Assert: the resize bar element is present
+                cut.WaitForAssertion(() =>
+                {
+                    var markup = cut.Markup;
+                    Assert.Contains("rz-dialog-resize-bar", markup);
+                    // Optionally ensure the inner handle exists too
+                    Assert.Contains("rz-resize", markup);
+                });
+            }
+
+            [Fact(DisplayName = "Side dialog hides resize bar when Resizable is false")]
+            public void SideDialog_NonResizable_HidesResizeBar()
+            {
+                using var ctx = new TestContext();
+                ctx.JSInterop.Mode = JSRuntimeMode.Loose;
+                ctx.Services.AddScoped<DialogService>();
+
+                // Render the dialog host
+                var cut = ctx.RenderComponent<RadzenDialog>();
+
+                // Open a side dialog with Resizable=false
+                var dialogService = ctx.Services.GetRequiredService<DialogService>();
+                cut.InvokeAsync(() => dialogService.OpenSide("Test", typeof(RadzenButton),
+                    new Dictionary<string, object>(), new SideDialogOptions()));
+
+                // Assert: the resize bar element is not present
+                cut.WaitForAssertion(() =>
+                {
+                    var markup = cut.Markup;
+                    Assert.DoesNotContain("rz-dialog-resize-bar", markup);
+                });
+            }
+        }
+		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 List<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

@@ -1,4 +1,6 @@
 using Bunit;
+using Microsoft.AspNetCore.Components;
+using System.Linq;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -15,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);
         }
@@ -45,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]
@@ -103,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]
@@ -145,7 +146,8 @@ namespace Radzen.Blazor.Tests
 
             var raised = false;
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add<bool>(p => p.AllowCollapse, true);
                 parameters.Add(p => p.Collapse, args => { raised = true; });
             });
@@ -160,5 +162,57 @@ namespace Radzen.Blazor.Tests
 
             component.Find("a").Click();
         }
+
+        [Fact]
+        public void Fieldset_Renders_SummaryWhenCollapsed()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFieldset>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add<bool>(p => p.AllowCollapse, true);
+                parameters.Add<bool>(p => p.Collapsed, true);
+                parameters.Add<RenderFragment>(p => p.SummaryTemplate, builder =>
+                {
+                    builder.OpenElement(0, "p");
+                    builder.AddContent(0, "SummaryContent");
+                    builder.CloseElement();
+                });
+
+            });
+
+            Assert.Contains("SummaryContent", component.Markup);
+            Assert.Equal(
+                "false",
+                component.Find(".rz-fieldset-content-summary").ParentElement.ParentElement.Attributes.First(attr => attr.Name == "aria-hidden").Value
+            );
+        }
+
+        [Fact]
+        public void Fieldset_DoesNotRender_SummaryWhenOpen()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenFieldset>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add<bool>(p => p.AllowCollapse, true);
+                parameters.Add<bool>(p => p.Collapsed, false);
+                parameters.Add<RenderFragment>(p => p.SummaryTemplate, builder =>
+                {
+                    builder.OpenElement(0, "p");
+                    builder.AddContent(0, "SummaryContent");
+                    builder.CloseElement();
+                });
+
+            });
+
+            Assert.Contains("SummaryContent", component.Markup);
+            Assert.Equal(
+                "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]
@@ -45,5 +45,53 @@ namespace Radzen.Blazor.Tests
 
             Assert.Contains(@$"autofocus", component.Markup);
         }
+
+        [Fact]
+        public void Icon_Renders_IconStyleClass()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenIcon>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(icon => icon.IconStyle, IconStyle.Primary));
+
+            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()
+        {
+            using var ctx = new TestContext();
+
+            var component = ctx.RenderComponent<RadzenIcon>();
+
+            component.SetParametersAndRender(parameters => parameters.Add(icon => icon.IconStyle, null));
+
+            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]
@@ -36,7 +41,7 @@ namespace Radzen.Blazor.Tests
 
             var component = ctx.RenderComponent<RadzenLogin>();
 
-            Assert.Contains(@$"<input name=""userName"" class=""rz-textbox""", component.Markup);
+            Assert.Contains(@$"<input name=""Username""", component.Markup);
         }
 
         [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();
@@ -89,30 +94,6 @@ namespace Radzen.Blazor.Tests
             Assert.True(!clicked);
         }
 
-        [Fact]
-        public void Login_Validates_UsernameParameter()
-        {
-            using var ctx = new TestContext();
-
-            var component = ctx.RenderComponent<RadzenLogin>();
-
-            component.Find("button").Click();
-
-            Assert.Contains(@$"Username is required", component.Markup);
-        }
-
-        [Fact]
-        public void Login_Validates_PasswordParameter()
-        {
-            using var ctx = new TestContext();
-
-            var component = ctx.RenderComponent<RadzenLogin>();
-
-            component.Find("button").Click();
-
-            Assert.Contains(@$"Password is required", component.Markup);
-        }
-
         [Fact]
         public void Login_Renders_LoginTextParameter()
         {
@@ -138,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]
@@ -214,7 +195,7 @@ namespace Radzen.Blazor.Tests
                 parameters.Add(p => p.Register, args => { clicked = true; });
             });
 
-            component.Find(".btn-secondary").Click();
+            component.Find(".rz-secondary").Click();
 
             Assert.True(clicked);
         }
@@ -240,7 +221,7 @@ namespace Radzen.Blazor.Tests
         }
 
         [Fact]
-        public void Login_NotRaises_ResetPasswordEvent_WhenEmptyUsername()
+        public void Login_Raises_ResetPasswordEvent_WhenEmptyUsername()
         {
             using var ctx = new TestContext();
 
@@ -255,19 +236,7 @@ namespace Radzen.Blazor.Tests
 
             component.Find("a").Click();
 
-            Assert.True(!clicked);
-        }
-
-        [Fact]
-        public void Login_Validates_UsernameParameter_OnResetPasswordEvent()
-        {
-            using var ctx = new TestContext();
-
-            var component = ctx.RenderComponent<RadzenLogin>();
-
-            component.Find("a").Click();
-
-            Assert.Contains(@$"Username is required", component.Markup);
+            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,168 @@
+
+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));
+    }
+
+    [Theory]
+    [InlineData("***foo bar***", @"<document>
+    <paragraph>
+        <emph>
+            <strong>
+                <text>foo bar</text>
+            </strong>
+        </emph>
+    </paragraph>
+</document>")]
+    [InlineData("___foo bar___", @"<document>
+    <paragraph>
+        <emph>
+            <strong>
+                <text>foo bar</text>
+            </strong>
+        </emph>
+    </paragraph>
+</document>")]
+    public void Parse_BoldAndItalic_ShouldNotThrowException(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]
@@ -48,14 +50,45 @@ namespace Radzen.Blazor.Tests
             component.SetParametersAndRender(parameters =>
             {
                 component.SetParametersAndRender(parameters => parameters.Add(p => p.Change, args => { raised = true; }));
+                parameters.Add<double>(p => p.Value, minValue);
                 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()
         {
@@ -75,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.");
         }
@@ -183,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]
@@ -255,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}");
@@ -264,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");
         }
@@ -290,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}");
@@ -299,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");
         }
@@ -313,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]
@@ -327,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]
@@ -349,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

@@ -0,0 +1,159 @@
+using Bunit;
+using Bunit.JSInterop;
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Radzen.Blazor.Tests
+{
+    public class PagerTests
+    {
+        [Fact]
+        public void RadzenPager_AutoHide_If_Count_Is_Less_Than_PageSize()
+        {
+            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);
+            });
+
+            component.Render();
+
+            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-pager", component.Markup);
+        }
+
+        [Fact]
+        public void RadzenPager_Dont_AutoHide_If_PageSizeOptions_Specified()
+        {
+            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, 101);
+                parameters.Add<int>(p => p.Count, 100);
+                parameters.Add<IEnumerable<int>>(p => p.PageSizeOptions, new int[] { 3, 7, 15 });
+            });
+
+            component.Render();
+
+            Assert.Contains(@$"rz-pager", component.Markup);
+            Assert.Contains(@$"rz-dropdown-trigger", component.Markup);
+        }
+
+        [Fact]
+        public async void RadzenPager_Renders_Summary() {
+            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(2);
+            component.Render();
+
+            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-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

@@ -0,0 +1,116 @@
+using Bunit;
+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
+{
+    public class PanelMenuTests
+    {
+        class TestNavigationManager : NavigationManager
+        {
+            public TestNavigationManager(string uri)
+            {
+                Initialize("http://www.example.com/", uri);
+            }
+
+            protected override void NavigateToCore(string uri, bool forceLoad)
+            {
+            }
+        }
+
+        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();
+
+            ctx.Services.RemoveAll<NavigationManager>();
+            ctx.Services.TryAddSingleton<NavigationManager>(new TestNavigationManager(currentAbsoluteUrl));
+
+            var component = ctx.RenderComponent<RadzenPanelMenu>();
+
+            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.Key);
+                    builder.AddAttribute(2, nameof(RadzenPanelMenuItem.Disabled), url.Value);
+                    builder.CloseComponent();
+                }
+            }));
+
+            return component.Markup;
+        }
+
+        [Fact]
+        public void RadzenPanelMenu_SetsOneActiveMenuItem()
+        {
+            var component = CreatePanelMenu("http://www.example.com/datagrid-dynamic", NavLinkMatch.All, "/datagrid", "/datagrid-dynamic");
+
+            var firstIndex = component.IndexOf("rz-navigation-item-wrapper-active");
+            var lastIndex = component.LastIndexOf("rz-navigation-item-wrapper-active");
+
+            Assert.NotEqual(-1, firstIndex);
+            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()
+        {
+            var component = CreatePanelMenu("http://www.example.com/foo?bar", NavLinkMatch.Prefix, "/foo");
+
+            Assert.Contains("rz-navigation-item-wrapper-active", component);
+        }
+
+        [Fact]
+        public void RadzenPanelMenu_DoesNotMatchQueryStringParametersWhenExactMatchIsSpecified()
+        {
+            var component = CreatePanelMenu("http://www.example.com/foo?bar", NavLinkMatch.All, "/foo");
+
+            Assert.DoesNotContain("rz-navigation-item-wrapper-active", component);
+        }
+
+        [Fact]
+        public void RadzenPanelMenu_DoesNotMatchRootWithEverything()
+        {
+            var component = CreatePanelMenu("http://www.example.com/foo", NavLinkMatch.Prefix, "/");
+
+            Assert.DoesNotContain("rz-navigation-item-wrapper-active", component);
+        }
+
+        [Fact]
+        public void RadzenPanelMenu_MatchesRoot()
+        {
+            var component = CreatePanelMenu("http://www.example.com/", NavLinkMatch.Prefix, "/");
+
+            Assert.Contains("rz-navigation-item-wrapper-active", component);
+        }
+
+        [Fact]
+        public void RadzenPanelMenu_MatchesRootWithoutTrailingSlash()
+        {
+            var component = CreatePanelMenu("http://www.example.com", NavLinkMatch.Prefix, "/");
+
+            Assert.Contains("rz-navigation-item-wrapper-active", component);
+        }
+    }
+}

Radzen.Blazor.Tests/PanelTests.cs

@@ -1,4 +1,6 @@
 using Bunit;
+using Microsoft.AspNetCore.Components;
+using System.Linq;
 using Xunit;
 
 namespace Radzen.Blazor.Tests
@@ -45,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]
@@ -117,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]
@@ -159,7 +161,8 @@ namespace Radzen.Blazor.Tests
 
             var raised = false;
 
-            component.SetParametersAndRender(parameters => {
+            component.SetParametersAndRender(parameters =>
+            {
                 parameters.Add<bool>(p => p.AllowCollapse, true);
                 parameters.Add(p => p.Collapse, args => { raised = true; });
             });
@@ -174,5 +177,53 @@ namespace Radzen.Blazor.Tests
 
             component.Find("a").Click();
         }
+
+        [Fact]
+        public void Panel_Renders_SummaryWhenCollapsed()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenPanel>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add<bool>(p => p.AllowCollapse, true);
+                parameters.Add<bool>(p => p.Collapsed, true);
+                parameters.Add<RenderFragment>(p => p.SummaryTemplate, builder =>
+                {
+                    builder.OpenElement(0, "p");
+                    builder.AddContent(0, "SummaryContent");
+                    builder.CloseElement();
+                });
+
+            });
+
+            Assert.Contains("SummaryContent", component.Markup);
+        }
+
+        [Fact]
+        public void Panel_DoesNotRender_SummaryWhenOpen()
+        {
+            using var ctx = new TestContext();
+            var component = ctx.RenderComponent<RadzenPanel>();
+
+            component.SetParametersAndRender(parameters =>
+            {
+                parameters.Add<bool>(p => p.AllowCollapse, true);
+                parameters.Add<bool>(p => p.Collapsed, false);
+                parameters.Add<RenderFragment>(p => p.SummaryTemplate, builder =>
+                {
+                    builder.OpenElement(0, "p");
+                    builder.AddContent(0, "SummaryContent");
+                    builder.CloseElement();
+                });
+
+            });
+
+            Assert.Contains("SummaryContent", component.Markup);
+            Assert.Equal(
+                "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,15 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
-    <PackageReference Include="bunit.web" Version="1.0.0-preview-01" />
-    <PackageReference Include="bunit.xunit" Version="1.0.0-preview-01" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+    <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

@@ -38,8 +38,8 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add<int>(p => p.Value, value));
 
-            Assert.Contains(@$"style=""width: {(value / max * 100).ToInvariantString()}%;""", component.Markup);
-            Assert.Contains(@$"style=""left: {(value / max * 100).ToInvariantString()}%;""", component.Markup);
+            Assert.Contains(@$"style=""width: {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.00%", component.Markup);
-            Assert.Contains(@$"left: 30.0%", component.Markup);
-            Assert.Contains(@$"left: 4.00%; width: 26.00%;", 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]
@@ -110,7 +110,7 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.Change, args => { raised = true; newValue = args; }));
 
-            component.Find("div").MouseUp();
+            component.Find("div").Click();
 
             Assert.True(raised);
             Assert.True(object.Equals(value, !(bool)newValue));
@@ -129,10 +129,23 @@ namespace Radzen.Blazor.Tests
 
             component.SetParametersAndRender(parameters => parameters.Add(p => p.ValueChanged, args => { raised = true; newValue = args; }));
 
-            component.Find("div").MouseUp();
+            component.Find("div").Click();
 
             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]