diff --git a/tests/Column/Base/HeaderContextTest.php b/tests/Column/Base/HeaderContextTest.php
new file mode 100644
index 000000000..d5dbaaa06
--- /dev/null
+++ b/tests/Column/Base/HeaderContextTest.php
@@ -0,0 +1,237 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests\Column\Base;
+
+use PHPUnit\Framework\TestCase;
+use Stringable;
+use Yiisoft\Data\Paginator\PageToken;
+use Yiisoft\Data\Reader\Sort;
+use Yiisoft\Html\Tag\A;
+use Yiisoft\Translator\TranslatorInterface;
+use Yiisoft\Yii\DataView\Column\Base\Cell;
+use Yiisoft\Yii\DataView\Column\Base\HeaderContext;
+use Yiisoft\Yii\DataView\Tests\Support\Mock;
+use Yiisoft\Yii\DataView\UrlConfig;
+
+/**
+ * @covers \Yiisoft\Yii\DataView\Column\Base\HeaderContext
+ * @covers \Yiisoft\Yii\DataView\Column\Base\Cell
+ * @covers \Yiisoft\Yii\DataView\UrlConfig
+ * @covers \Yiisoft\Yii\DataView\UrlParametersFactory
+ */
+final class HeaderContextTest extends TestCase
+{
+    public function testTranslate(): void
+    {
+        $translator = Mock::translator('en');
+
+        $headerContext = $this->createHeaderContext(translator: $translator);
+
+        $result = $headerContext->translate('test.message');
+
+        $this->assertSame('test.message', $result);
+    }
+
+    public function testTranslateWithStringable(): void
+    {
+        $translator = Mock::translator('en');
+
+        $headerContext = $this->createHeaderContext(translator: $translator);
+
+        $stringable = new class () {
+            public function __toString(): string
+            {
+                return 'Stringable Message';
+            }
+        };
+
+        $result = $headerContext->translate($stringable);
+
+        $this->assertSame('Stringable Message', $result);
+    }
+
+    public function testPrepareSortableWithEmptyProperty(): void
+    {
+        $cell = new Cell();
+        $headerContext = $this->createHeaderContext();
+
+        $result = $headerContext->prepareSortable($cell, 'nonexistent');
+
+        $this->assertSame($cell, $result[0]);
+        $this->assertNull($result[1]);
+        $this->assertSame('', $result[2]);
+        $this->assertSame('', $result[3]);
+    }
+
+    public function testPrepareSortableWithNullSort(): void
+    {
+        $cell = new Cell();
+        $headerContext = $this->createHeaderContext(
+            sort: null,
+            originalSort: null
+        );
+
+        $result = $headerContext->prepareSortable($cell, 'name');
+
+        $this->assertSame($cell, $result[0]);
+        $this->assertNull($result[1]);
+        $this->assertSame('', $result[2]);
+        $this->assertSame('', $result[3]);
+    }
+
+    public function testPrepareSortableWithPropertyNotInConfig(): void
+    {
+        $sort = Sort::any();
+        $cell = new Cell();
+        $headerContext = $this->createHeaderContext(
+            sort: $sort,
+            originalSort: $sort,
+            orderProperties: ['name' => 'name']
+        );
+
+        $result = $headerContext->prepareSortable($cell, 'age');
+
+        $this->assertSame($cell, $result[0]);
+        $this->assertNull($result[1]);
+        $this->assertSame('', $result[2]);
+        $this->assertSame('', $result[3]);
+    }
+
+    public function testPrepareSortableWithNoOrder(): void
+    {
+        $sort = Sort::any(['name' => []]);
+        $cell = new Cell();
+        $headerContext = $this->createHeaderContext(
+            sort: $sort,
+            originalSort: $sort,
+            orderProperties: ['name' => 'name'],
+            sortableHeaderClass: 'sortable',
+            sortableHeaderPrepend: '↕',
+            sortableHeaderAppend: '!'
+        );
+
+        $result = $headerContext->prepareSortable($cell, 'name');
+
+        $this->assertInstanceOf(Cell::class, $result[0]);
+        $this->assertStringContainsString('sortable', $result[0]->getAttributes()['class']);
+        $this->assertInstanceOf(A::class, $result[1]);
+        $this->assertSame('↕', $result[2]);
+        $this->assertSame('!', $result[3]);
+    }
+
+    public function testPrepareSortableWithAscOrder(): void
+    {
+        $sort = Sort::any(['name' => []])->withOrder(['name' => 'asc']);
+        $cell = new Cell();
+        $headerContext = $this->createHeaderContext(
+            sort: $sort,
+            originalSort: $sort,
+            orderProperties: ['name' => 'name'],
+            sortableHeaderAscClass: 'asc',
+            sortableHeaderAscPrepend: '↑',
+            sortableHeaderAscAppend: '!',
+            sortableLinkAscClass: 'link-asc'
+        );
+
+        $result = $headerContext->prepareSortable($cell, 'name');
+
+        $this->assertInstanceOf(Cell::class, $result[0]);
+        $this->assertStringContainsString('asc', $result[0]->getAttributes()['class']);
+        $this->assertInstanceOf(A::class, $result[1]);
+        $this->assertSame('↑', $result[2]);
+        $this->assertSame('!', $result[3]);
+    }
+
+    public function testPrepareSortableWithDescOrder(): void
+    {
+        $sort = Sort::any(['name' => []])->withOrder(['name' => 'desc']);
+        $cell = new Cell();
+        $headerContext = $this->createHeaderContext(
+            sort: $sort,
+            originalSort: $sort,
+            orderProperties: ['name' => 'name'],
+            sortableHeaderDescClass: 'desc',
+            sortableHeaderDescPrepend: '↓',
+            sortableHeaderDescAppend: '!',
+            sortableLinkDescClass: 'link-desc'
+        );
+
+        $result = $headerContext->prepareSortable($cell, 'name');
+
+        $this->assertInstanceOf(Cell::class, $result[0]);
+        $this->assertStringContainsString('desc', $result[0]->getAttributes()['class']);
+        $this->assertInstanceOf(A::class, $result[1]);
+        $this->assertSame('↓', $result[2]);
+        $this->assertSame('!', $result[3]);
+    }
+
+    private function createHeaderContext(
+        ?Sort $sort = null,
+        ?Sort $originalSort = null,
+        array $orderProperties = ['name' => 'name'],
+        ?string $sortableHeaderClass = null,
+        string|Stringable $sortableHeaderPrepend = '',
+        string|Stringable $sortableHeaderAppend = '',
+        ?string $sortableHeaderAscClass = null,
+        string|Stringable $sortableHeaderAscPrepend = '',
+        string|Stringable $sortableHeaderAscAppend = '',
+        ?string $sortableHeaderDescClass = null,
+        string|Stringable $sortableHeaderDescPrepend = '',
+        string|Stringable $sortableHeaderDescAppend = '',
+        array $sortableLinkAttributes = [],
+        ?string $sortableLinkAscClass = null,
+        ?string $sortableLinkDescClass = null,
+        ?PageToken $pageToken = null,
+        ?int $pageSize = null,
+        bool $multiSort = false,
+        ?TranslatorInterface $translator = null
+    ): HeaderContext {
+        if ($sort === null) {
+            $sort = Sort::any();
+        }
+
+        if ($originalSort === null) {
+            $originalSort = Sort::any();
+        }
+
+        if ($translator === null) {
+            $translator = Mock::translator('en');
+        }
+
+        $urlConfig = new UrlConfig(
+            pageParameterName: 'page',
+            previousPageParameterName: 'prev',
+            pageSizeParameterName: 'per-page',
+            sortParameterName: 'sort'
+        );
+
+        $urlCreator = fn(): string => '#';
+
+        return new HeaderContext(
+            originalSort: $originalSort,
+            sort: $sort,
+            orderProperties: $orderProperties,
+            sortableHeaderClass: $sortableHeaderClass,
+            sortableHeaderPrepend: $sortableHeaderPrepend,
+            sortableHeaderAppend: $sortableHeaderAppend,
+            sortableHeaderAscClass: $sortableHeaderAscClass,
+            sortableHeaderAscPrepend: $sortableHeaderAscPrepend,
+            sortableHeaderAscAppend: $sortableHeaderAscAppend,
+            sortableHeaderDescClass: $sortableHeaderDescClass,
+            sortableHeaderDescPrepend: $sortableHeaderDescPrepend,
+            sortableHeaderDescAppend: $sortableHeaderDescAppend,
+            sortableLinkAttributes: $sortableLinkAttributes,
+            sortableLinkAscClass: $sortableLinkAscClass,
+            sortableLinkDescClass: $sortableLinkDescClass,
+            pageToken: $pageToken,
+            pageSize: $pageSize,
+            multiSort: $multiSort,
+            urlConfig: $urlConfig,
+            urlCreator: $urlCreator,
+            translator: $translator,
+            translationCategory: 'grid'
+        );
+    }
+}
diff --git a/tests/Column/DataColumnRendererTest.php b/tests/Column/DataColumnRendererTest.php
new file mode 100644
index 000000000..47709bcb0
--- /dev/null
+++ b/tests/Column/DataColumnRendererTest.php
@@ -0,0 +1,147 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests\Column;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Container\ContainerInterface;
+use Yiisoft\Data\Reader\Iterable\IterableDataReader;
+use Yiisoft\Data\Reader\Sort;
+use Yiisoft\Di\Container;
+use Yiisoft\Di\ContainerConfig;
+use Yiisoft\Validator\Validator;
+use Yiisoft\Yii\DataView\Column\Base\Cell;
+use Yiisoft\Yii\DataView\Column\Base\DataContext;
+use Yiisoft\Yii\DataView\Column\Base\GlobalContext;
+use Yiisoft\Yii\DataView\Column\Base\HeaderContext;
+use Yiisoft\Yii\DataView\Column\DataColumn;
+use Yiisoft\Yii\DataView\Column\DataColumnRenderer;
+use Yiisoft\Yii\DataView\Tests\Support\Mock;
+use Yiisoft\Yii\DataView\Tests\Support\TestTrait;
+use Yiisoft\Yii\DataView\UrlConfig;
+
+final class DataColumnRendererTest extends TestCase
+{
+    use TestTrait;
+
+    private ContainerInterface $filterFactoryContainer;
+    private IterableDataReader $dataReader;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->filterFactoryContainer = new Container(ContainerConfig::create());
+
+        $this->dataReader = new IterableDataReader([
+            ['id' => 1, 'name' => 'John', 'age' => 20],
+            ['id' => 2, 'name' => 'Mary', 'age' => 21],
+        ]);
+    }
+
+    public function testRenderColumn(): void
+    {
+        $this->expectNotToPerformAssertions();
+
+        $column = new DataColumn('test');
+        $cell = new Cell();
+        $translator = Mock::translator('en');
+
+        $context = new GlobalContext(
+            $this->dataReader,
+            [],
+            [],
+            $translator,
+            'test'
+        );
+
+        $renderer = new DataColumnRenderer(
+            $this->filterFactoryContainer,
+            new Validator()
+        );
+
+        $renderer->renderColumn($column, $cell, $context);
+    }
+
+    public function testRenderHeader(): void
+    {
+        $column = new DataColumn('test', 'Test Header');
+        $cell = new Cell();
+        $translator = Mock::translator('en');
+
+        $sort = Sort::any();
+
+        $context = new HeaderContext(
+            $sort,
+            $sort,
+            ['test' => 'test'],
+            'sortable',
+            '',
+            '',
+            'asc',
+            '',
+            '',
+            'desc',
+            '',
+            '',
+            [],
+            'asc-link',
+            'desc-link',
+            null,
+            10,
+            false,
+            new UrlConfig(),
+            null,
+            $translator,
+            'test'
+        );
+
+        $renderer = new DataColumnRenderer(
+            $this->filterFactoryContainer,
+            new Validator()
+        );
+
+        $result = $renderer->renderHeader($column, $cell, $context);
+
+        $this->assertNotEmpty($result->getContent());
+    }
+
+    public function testRenderBody(): void
+    {
+        $column = new DataColumn('name');
+        $cell = new Cell();
+        $data = ['id' => 1, 'name' => 'John Doe', 'age' => 20];
+
+        $context = new DataContext(
+            $this->dataReader,
+            $column,
+            $data,
+            1,
+            0
+        );
+
+        $renderer = new DataColumnRenderer(
+            $this->filterFactoryContainer,
+            new Validator()
+        );
+
+        $result = $renderer->renderBody($column, $cell, $context);
+
+        $content = $result->getContent();
+        $this->assertNotEmpty($content);
+        $this->assertStringContainsString('John Doe', (string)$content[0]);
+    }
+
+    public function testGetOrderProperties(): void
+    {
+        $column = new DataColumn('test');
+        $renderer = new DataColumnRenderer(
+            $this->filterFactoryContainer,
+            new Validator()
+        );
+
+        $result = $renderer->getOrderProperties($column);
+        $this->assertEquals(['test' => 'test'], $result);
+    }
+}
diff --git a/tests/Filter/Factory/EqualsFilterFactoryTest.php b/tests/Filter/Factory/EqualsFilterFactoryTest.php
new file mode 100644
index 000000000..8f6f3ddc1
--- /dev/null
+++ b/tests/Filter/Factory/EqualsFilterFactoryTest.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests\Filter\Factory;
+
+use PHPUnit\Framework\TestCase;
+use Yiisoft\Data\Reader\Filter\Equals;
+use Yiisoft\Yii\DataView\Filter\Factory\EqualsFilterFactory;
+
+/**
+ * @covers \Yiisoft\Yii\DataView\Filter\Factory\EqualsFilterFactory
+ */
+final class EqualsFilterFactoryTest extends TestCase
+{
+    public function testCreateWithValidValue(): void
+    {
+        $factory = new EqualsFilterFactory();
+
+        /**@var Equals $filter */
+        $filter = $factory->create('name', 'John');
+
+        $this->assertInstanceOf(Equals::class, $filter);
+
+        $this->assertSame('name', $filter->getField());
+        $this->assertSame('John', $filter->getValue());
+    }
+
+    public function testCreateWithEmptyValue(): void
+    {
+        $factory = new EqualsFilterFactory();
+        $filter = $factory->create('name', '');
+
+        $this->assertNull($filter);
+    }
+
+    public function testCreateWithZeroValue(): void
+    {
+        $factory = new EqualsFilterFactory();
+        $filter = $factory->create('age', '0');
+
+        $this->assertNull($filter);
+    }
+
+    public function testCreateWithNonEmptyNumericValue(): void
+    {
+        $factory = new EqualsFilterFactory();
+
+        /** @var Equals $filter */
+        $filter = $factory->create('quantity', '42');
+
+        $this->assertInstanceOf(Equals::class, $filter);
+
+        $this->assertSame('quantity', $filter->getField());
+        $this->assertSame('42', $filter->getValue());
+    }
+}
diff --git a/tests/Filter/Factory/LikeFilterFactoryTest.php b/tests/Filter/Factory/LikeFilterFactoryTest.php
index 3bb936ca7..55e161f83 100644
--- a/tests/Filter/Factory/LikeFilterFactoryTest.php
+++ b/tests/Filter/Factory/LikeFilterFactoryTest.php
@@ -8,6 +8,9 @@
 use PHPUnit\Framework\TestCase;
 use Yiisoft\Yii\DataView\Filter\Factory\LikeFilterFactory;
 
+/**
+ * @covers \Yiisoft\Yii\DataView\Filter\Factory\LikeFilterFactory
+ */
 final class LikeFilterFactoryTest extends TestCase
 {
     public function testBase(): void
@@ -21,6 +24,22 @@ public function testBase(): void
         $this->assertNull($filter->isCaseSensitive());
     }
 
+    public function testCreateWithEmptyValue(): void
+    {
+        $factory = new LikeFilterFactory();
+        $filter = $factory->create('name', '');
+
+        $this->assertNull($filter);
+    }
+
+    public function testCreateWithZeroValue(): void
+    {
+        $factory = new LikeFilterFactory();
+        $filter = $factory->create('name', '0');
+
+        $this->assertNull($filter);
+    }
+
     public static function dataCaseSensitive(): iterable
     {
         yield [null];
diff --git a/tests/Filter/Widget/DropdownFilterTest.php b/tests/Filter/Widget/DropdownFilterTest.php
new file mode 100644
index 000000000..be531cdca
--- /dev/null
+++ b/tests/Filter/Widget/DropdownFilterTest.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests\Filter\Widget;
+
+use PHPUnit\Framework\TestCase;
+use Yiisoft\Yii\DataView\Filter\Widget\Context;
+use Yiisoft\Yii\DataView\Filter\Widget\DropdownFilter;
+
+/**
+ * @covers \Yiisoft\Yii\DataView\Filter\Widget\DropdownFilter
+ * @covers \Yiisoft\Yii\DataView\Filter\Widget\Context
+ * @covers \Yiisoft\Yii\DataView\Filter\Widget\FilterWidget
+ */
+final class DropdownFilterTest extends TestCase
+{
+    public function testRenderFilter(): void
+    {
+        $filter = new DropdownFilter();
+        $filter = $filter->optionsData([
+            'active' => 'Active',
+            'inactive' => 'Inactive',
+        ]);
+        $context = new Context('status', 'active', 'filter-form');
+
+        $html = $filter->renderFilter($context);
+
+        $this->assertStringContainsString('name="status"', $html);
+        $this->assertStringContainsString('form="filter-form"', $html);
+        $this->assertStringContainsString('onChange="this.form.submit()"', $html);
+        $this->assertStringContainsString('value="active"', $html);
+        $this->assertStringContainsString('selected', $html);
+    }
+
+    public function testRenderFilterWithoutValue(): void
+    {
+        $filter = new DropdownFilter();
+        $context = new Context('status', null, 'filter-form');
+
+        $html = $filter->renderFilter($context);
+
+        $this->assertStringContainsString('name="status"', $html);
+        $this->assertStringContainsString('form="filter-form"', $html);
+        $this->assertStringContainsString('onChange="this.form.submit()"', $html);
+        $this->assertStringNotContainsString('value="', $html);
+    }
+
+    public function testOptionsData(): void
+    {
+        $filter = new DropdownFilter();
+        $options = [
+            'active' => 'Active',
+            'inactive' => 'Inactive',
+        ];
+
+        $filter = $filter->optionsData($options);
+        $context = new Context('status', null, 'filter-form');
+
+        $html = $filter->renderFilter($context);
+
+        $this->assertStringContainsString('>Active<', $html);
+        $this->assertStringContainsString('>Inactive<', $html);
+        $this->assertStringContainsString('value="active"', $html);
+        $this->assertStringContainsString('value="inactive"', $html);
+    }
+
+    public function testAddAttributes(): void
+    {
+        $filter = new DropdownFilter();
+        $filter = $filter->addAttributes(['class' => 'custom-select', 'data-test' => 'value']);
+
+        $context = new Context('status', null, 'filter-form');
+        $html = $filter->renderFilter($context);
+
+        $this->assertStringContainsString('class="custom-select"', $html);
+        $this->assertStringContainsString('data-test="value"', $html);
+    }
+
+    public function testAttributes(): void
+    {
+        $filter = new DropdownFilter();
+        $filter = $filter->attributes(['class' => 'new-select', 'required' => true]);
+
+        $context = new Context('status', null, 'filter-form');
+        $html = $filter->renderFilter($context);
+
+        $this->assertStringContainsString('class="new-select"', $html);
+        $this->assertStringContainsString('required', $html);
+    }
+}
diff --git a/tests/Filter/Widget/TextInputFilterTest.php b/tests/Filter/Widget/TextInputFilterTest.php
new file mode 100644
index 000000000..ccbbdf40f
--- /dev/null
+++ b/tests/Filter/Widget/TextInputFilterTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests\Filter\Widget;
+
+use PHPUnit\Framework\TestCase;
+use Yiisoft\Yii\DataView\Filter\Widget\Context;
+use Yiisoft\Yii\DataView\Filter\Widget\TextInputFilter;
+
+/**
+ * @covers \Yiisoft\Yii\DataView\Filter\Widget\TextInputFilter
+ * @covers \Yiisoft\Yii\DataView\Filter\Widget\Context
+ * @covers \Yiisoft\Yii\DataView\Filter\Widget\FilterWidget
+ */
+final class TextInputFilterTest extends TestCase
+{
+    public function testRenderFilter(): void
+    {
+        $filter = new TextInputFilter();
+        $context = new Context('username', 'john', 'filter-form');
+
+        $result = $filter->renderFilter($context);
+
+        $this->assertStringContainsString('name="username"', $result);
+        $this->assertStringContainsString('value="john"', $result);
+        $this->assertStringContainsString('form="filter-form"', $result);
+        $this->assertStringContainsString('type="text"', $result);
+    }
+
+    public function testRenderWithNullValue(): void
+    {
+        $filter = new TextInputFilter();
+        $context = new Context('username', null, 'filter-form');
+
+        $result = $filter->renderFilter($context);
+
+        $this->assertStringContainsString('name="username"', $result);
+        $this->assertStringNotContainsString('value=', $result);
+        $this->assertStringContainsString('form="filter-form"', $result);
+    }
+
+    public function testAddAttributes(): void
+    {
+        $filter = new TextInputFilter();
+        $newFilter = $filter->addAttributes(['class' => 'form-control', 'placeholder' => 'Enter username']);
+
+        $this->assertNotSame($filter, $newFilter);
+
+        $context = new Context('username', 'john', 'filter-form');
+        $result = $newFilter->renderFilter($context);
+
+        $this->assertStringContainsString('class="form-control"', $result);
+        $this->assertStringContainsString('placeholder="Enter username"', $result);
+    }
+
+    public function testAttributes(): void
+    {
+        $filter = new TextInputFilter();
+        $filter = $filter->addAttributes(['data-test' => 'original']);
+
+        $newFilter = $filter->attributes(['class' => 'form-control', 'id' => 'username-filter']);
+
+        $this->assertNotSame($filter, $newFilter);
+
+        $context = new Context('username', 'john', 'filter-form');
+        $result = $newFilter->renderFilter($context);
+
+        $this->assertStringContainsString('class="form-control"', $result);
+        $this->assertStringContainsString('id="username-filter"', $result);
+        $this->assertStringNotContainsString('data-test="original"', $result);
+    }
+
+    public function testRender(): void
+    {
+        $context = new Context('username', 'john', 'filter-form');
+        $result = (new TextInputFilter())
+            ->withContext($context)
+            ->render();
+
+        $this->assertStringContainsString('name="username"', $result);
+        $this->assertStringContainsString('value="john"', $result);
+        $this->assertStringContainsString('form="filter-form"', $result);
+    }
+}
diff --git a/tests/PageSize/InputPageSizeTest.php b/tests/PageSize/InputPageSizeTest.php
new file mode 100644
index 000000000..efd4bc8b9
--- /dev/null
+++ b/tests/PageSize/InputPageSizeTest.php
@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests\PageSize;
+
+use LogicException;
+use PHPUnit\Framework\TestCase;
+use Yiisoft\Yii\DataView\PageSize\InputPageSize;
+use Yiisoft\Yii\DataView\PageSize\PageSizeContext;
+
+final class InputPageSizeTest extends TestCase
+{
+    public function testRenderWithContext(): void
+    {
+        $context = new PageSizeContext(
+            currentValue: 10,
+            defaultValue: 20,
+            constraint: false,
+            urlPattern: '/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER',
+            defaultUrl: '/test'
+        );
+
+        $widget = new InputPageSize();
+        $widget = $widget->withContext($context);
+
+        $html = $widget->render();
+
+        $this->assertStringContainsString('value="10"', $html);
+        $this->assertStringContainsString('data-default-page-size="20"', $html);
+        $this->assertStringContainsString('data-url-pattern="/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER"', $html);
+        $this->assertStringContainsString('data-default-url="/test"', $html);
+        $this->assertStringContainsString('onchange=', $html);
+    }
+
+    public function testAddAttributes(): void
+    {
+        $context = new PageSizeContext(
+            currentValue: 10,
+            defaultValue: 20,
+            constraint: false,
+            urlPattern: '/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER',
+            defaultUrl: '/test'
+        );
+
+        $widget = new InputPageSize();
+        $widget = $widget->withContext($context);
+        $widget = $widget->addAttributes(['class' => 'form-control', 'id' => 'page-size-input']);
+
+        $html = $widget->render();
+
+        $this->assertStringContainsString('class="form-control"', $html);
+        $this->assertStringContainsString('id="page-size-input"', $html);
+    }
+
+    public function testAttributes(): void
+    {
+        $context = new PageSizeContext(
+            currentValue: 10,
+            defaultValue: 20,
+            constraint: false,
+            urlPattern: '/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER',
+            defaultUrl: '/test'
+        );
+
+        $widget = new InputPageSize();
+        $widget = $widget->withContext($context);
+        $widget = $widget->attributes(['class' => 'custom-input', 'data-test' => 'value']);
+
+        $html = $widget->render();
+
+        $this->assertStringContainsString('class="custom-input"', $html);
+        $this->assertStringContainsString('data-test="value"', $html);
+    }
+
+    public function testGetContextWithoutSettingContext(): void
+    {
+        $widget = new InputPageSize();
+
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('Context is not set.');
+
+        // This will trigger the getContext() method internally
+        $widget->render();
+    }
+}
diff --git a/tests/PageSize/SelectPageSizeTest.php b/tests/PageSize/SelectPageSizeTest.php
new file mode 100644
index 000000000..7b2e74bfb
--- /dev/null
+++ b/tests/PageSize/SelectPageSizeTest.php
@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests\PageSize;
+
+use PHPUnit\Framework\TestCase;
+use Yiisoft\Yii\DataView\PageSize\PageSizeContext;
+use Yiisoft\Yii\DataView\PageSize\SelectPageSize;
+
+final class SelectPageSizeTest extends TestCase
+{
+    public function testRenderWithArrayConstraint(): void
+    {
+        $context = new PageSizeContext(
+            currentValue: 10,
+            defaultValue: 20,
+            constraint: [10, 20, 50, 100],
+            urlPattern: '/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER',
+            defaultUrl: '/test'
+        );
+
+        $widget = new SelectPageSize();
+        $widget = $widget->withContext($context);
+
+        $html = $widget->render();
+
+        $this->assertStringContainsString('<option value="10" selected>', $html);
+        $this->assertStringContainsString('<option value="20">', $html);
+        $this->assertStringContainsString('<option value="50">', $html);
+        $this->assertStringContainsString('<option value="100">', $html);
+        $this->assertStringContainsString('data-default-page-size="20"', $html);
+        $this->assertStringContainsString('data-url-pattern="/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER"', $html);
+        $this->assertStringContainsString('data-default-url="/test"', $html);
+        $this->assertStringContainsString('onchange=', $html);
+    }
+
+    public function testRenderWithInsufficientOptions(): void
+    {
+        // Test with a single option array (should return empty string)
+        $context = new PageSizeContext(
+            currentValue: 10,
+            defaultValue: 10,
+            constraint: [10],
+            urlPattern: '/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER',
+            defaultUrl: '/test'
+        );
+
+        $widget = new SelectPageSize();
+        $widget = $widget->withContext($context);
+
+        $html = $widget->render();
+        $this->assertSame('', $html);
+
+        // Test with non-array constraint (should return empty string)
+        $context = new PageSizeContext(
+            currentValue: 10,
+            defaultValue: 10,
+            constraint: true,
+            urlPattern: '/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER',
+            defaultUrl: '/test'
+        );
+
+        $widget = $widget->withContext($context);
+        $html = $widget->render();
+        $this->assertSame('', $html);
+    }
+
+    public function testAddAttributes(): void
+    {
+        $context = new PageSizeContext(
+            currentValue: 10,
+            defaultValue: 20,
+            constraint: [10, 20, 50],
+            urlPattern: '/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER',
+            defaultUrl: '/test'
+        );
+
+        $widget = new SelectPageSize();
+        $widget = $widget->withContext($context);
+        $widget = $widget->addAttributes(['class' => 'form-select', 'id' => 'page-size-select']);
+
+        $html = $widget->render();
+
+        $this->assertStringContainsString('class="form-select"', $html);
+        $this->assertStringContainsString('id="page-size-select"', $html);
+    }
+
+    public function testAttributes(): void
+    {
+        $context = new PageSizeContext(
+            currentValue: 10,
+            defaultValue: 20,
+            constraint: [10, 20, 50],
+            urlPattern: '/test?pagesize=YII-DATAVIEW-PAGE-SIZE-PLACEHOLDER',
+            defaultUrl: '/test'
+        );
+
+        $widget = new SelectPageSize();
+        $widget = $widget->withContext($context);
+        $widget = $widget->attributes(['class' => 'custom-select', 'data-test' => 'value']);
+
+        $html = $widget->render();
+
+        $this->assertStringContainsString('class="custom-select"', $html);
+        $this->assertStringContainsString('data-test="value"', $html);
+    }
+}
diff --git a/tests/UrlConfigTest.php b/tests/UrlConfigTest.php
new file mode 100644
index 000000000..50929e822
--- /dev/null
+++ b/tests/UrlConfigTest.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Yiisoft\Yii\DataView\UrlConfig;
+use Yiisoft\Yii\DataView\UrlParameterType;
+
+final class UrlConfigTest extends TestCase
+{
+    public function testDefaultValues(): void
+    {
+        $urlConfig = new UrlConfig();
+
+        $this->assertSame('page', $urlConfig->getPageParameterName());
+        $this->assertSame('prev-page', $urlConfig->getPreviousPageParameterName());
+        $this->assertSame('pagesize', $urlConfig->getPageSizeParameterName());
+        $this->assertSame('sort', $urlConfig->getSortParameterName());
+        $this->assertSame(UrlParameterType::QUERY, $urlConfig->getPageParameterType());
+        $this->assertSame(UrlParameterType::QUERY, $urlConfig->getPreviousPageParameterType());
+        $this->assertSame(UrlParameterType::QUERY, $urlConfig->getPageSizeParameterType());
+        $this->assertSame(UrlParameterType::QUERY, $urlConfig->getSortParameterType());
+        $this->assertSame([], $urlConfig->getArguments());
+        $this->assertSame([], $urlConfig->getQueryParameters());
+    }
+
+    public function testWithMethods(): void
+    {
+        $urlConfig = new UrlConfig();
+
+        $newConfig = $urlConfig->withPageParameterName('p');
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame('p', $newConfig->getPageParameterName());
+
+        $newConfig = $urlConfig->withPreviousPageParameterName('pp');
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame('pp', $newConfig->getPreviousPageParameterName());
+
+        $newConfig = $urlConfig->withPageSizeParameterName('ps');
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame('ps', $newConfig->getPageSizeParameterName());
+
+        $newConfig = $urlConfig->withSortParameterName('s');
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame('s', $newConfig->getSortParameterName());
+
+        $newConfig = $urlConfig->withPageParameterType(UrlParameterType::PATH);
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame(UrlParameterType::PATH, $newConfig->getPageParameterType());
+
+        $newConfig = $urlConfig->withPreviousPageParameterType(UrlParameterType::PATH);
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame(UrlParameterType::PATH, $newConfig->getPreviousPageParameterType());
+
+        $newConfig = $urlConfig->withPageSizeParameterType(UrlParameterType::PATH);
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame(UrlParameterType::PATH, $newConfig->getPageSizeParameterType());
+
+        $newConfig = $urlConfig->withSortParameterType(UrlParameterType::PATH);
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame(UrlParameterType::PATH, $newConfig->getSortParameterType());
+
+        $arguments = ['controller' => 'site', 'action' => 'index'];
+        $newConfig = $urlConfig->withArguments($arguments);
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame($arguments, $newConfig->getArguments());
+
+        $queryParams = ['q' => 'search', 'filter' => 'active'];
+        $newConfig = $urlConfig->withQueryParameters($queryParams);
+        $this->assertNotSame($urlConfig, $newConfig);
+        $this->assertSame($queryParams, $newConfig->getQueryParameters());
+    }
+
+    public function testChaining(): void
+    {
+        $urlConfig = new UrlConfig();
+
+        $newConfig = $urlConfig
+            ->withPageParameterName('p')
+            ->withPageParameterType(UrlParameterType::PATH)
+            ->withArguments(['controller' => 'site'])
+            ->withQueryParameters(['q' => 'search']);
+
+        $this->assertSame('p', $newConfig->getPageParameterName());
+        $this->assertSame(UrlParameterType::PATH, $newConfig->getPageParameterType());
+        $this->assertSame(['controller' => 'site'], $newConfig->getArguments());
+        $this->assertSame(['q' => 'search'], $newConfig->getQueryParameters());
+    }
+}
diff --git a/tests/UrlParametersFactoryTest.php b/tests/UrlParametersFactoryTest.php
new file mode 100644
index 000000000..63166e1ff
--- /dev/null
+++ b/tests/UrlParametersFactoryTest.php
@@ -0,0 +1,317 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Yiisoft\Data\Paginator\PageToken;
+use Yiisoft\Yii\DataView\UrlConfig;
+use Yiisoft\Yii\DataView\UrlParameterType;
+use Yiisoft\Yii\DataView\UrlParametersFactory;
+
+/**
+ * @covers \Yiisoft\Yii\DataView\UrlParametersFactory
+ * @covers \Yiisoft\Yii\DataView\UrlConfig
+ */
+final class UrlParametersFactoryTest extends TestCase
+{
+    public function testCreateWithNullValues(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            null,
+            null,
+            null,
+            $config
+        );
+
+        $this->assertSame([], $arguments);
+        $this->assertSame([
+            'page' => null,
+            'prev-page' => null,
+            'pagesize' => null,
+            'sort' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithNextPageTokenInQueryParameter(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            PageToken::next('token123'),
+            null,
+            null,
+            $config
+        );
+
+        $this->assertSame([], $arguments);
+        $this->assertSame([
+            'page' => 'token123',
+            'prev-page' => null,
+            'pagesize' => null,
+            'sort' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithNextPageTokenInPathParameter(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::PATH,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            PageToken::next('token123'),
+            null,
+            null,
+            $config
+        );
+
+        $this->assertSame(['page' => 'token123'], $arguments);
+        $this->assertSame([
+            'prev-page' => null,
+            'pagesize' => null,
+            'sort' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithPreviousPageTokenInQueryParameter(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            PageToken::previous('token123'),
+            null,
+            null,
+            $config
+        );
+
+        $this->assertSame([], $arguments);
+        $this->assertSame([
+            'page' => null,
+            'prev-page' => 'token123',
+            'pagesize' => null,
+            'sort' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithPreviousPageTokenInPathParameter(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::PATH,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            PageToken::previous('token123'),
+            null,
+            null,
+            $config
+        );
+
+        $this->assertSame(['prev-page' => 'token123'], $arguments);
+        $this->assertSame([
+            'page' => null,
+            'pagesize' => null,
+            'sort' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithPageSizeInQueryParameter(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            null,
+            20,
+            null,
+            $config
+        );
+
+        $this->assertSame([], $arguments);
+        $this->assertSame([
+            'page' => null,
+            'prev-page' => null,
+            'pagesize' => 20,
+            'sort' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithPageSizeInPathParameter(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::PATH,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            null,
+            20,
+            null,
+            $config
+        );
+
+        $this->assertSame(['pagesize' => 20], $arguments);
+        $this->assertSame([
+            'page' => null,
+            'prev-page' => null,
+            'sort' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithSortInQueryParameter(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            null,
+            null,
+            'name,-date',
+            $config
+        );
+
+        $this->assertSame([], $arguments);
+        $this->assertSame([
+            'page' => null,
+            'prev-page' => null,
+            'pagesize' => null,
+            'sort' => 'name,-date',
+        ], $queryParameters);
+    }
+
+    public function testCreateWithSortInPathParameter(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::PATH
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            null,
+            null,
+            'name,-date',
+            $config
+        );
+
+        $this->assertSame(['sort' => 'name,-date'], $arguments);
+        $this->assertSame([
+            'page' => null,
+            'prev-page' => null,
+            'pagesize' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithCustomParameterNames(): void
+    {
+        $config = new UrlConfig(
+            pageParameterName: 'p',
+            previousPageParameterName: 'pp',
+            pageSizeParameterName: 'ps',
+            sortParameterName: 's',
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::PATH,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            PageToken::previous('token123'),
+            null,
+            null,
+            $config
+        );
+
+        $this->assertSame(['pp' => 'token123'], $arguments);
+        $this->assertSame([
+            'p' => null,
+            'ps' => null,
+            's' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithExistingArgumentsAndQueryParameters(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY,
+            arguments: ['id' => 123],
+            queryParameters: ['filter' => 'active']
+        );
+
+        [$arguments, $queryParameters] = UrlParametersFactory::create(
+            null,
+            null,
+            null,
+            $config
+        );
+
+        $this->assertSame(['id' => 123], $arguments);
+        $this->assertSame([
+            'filter' => 'active',
+            'page' => null,
+            'prev-page' => null,
+            'pagesize' => null,
+            'sort' => null,
+        ], $queryParameters);
+    }
+
+    public function testCreateWithInstanceMethod(): void
+    {
+        $config = new UrlConfig(
+            pageParameterType: UrlParameterType::QUERY,
+            previousPageParameterType: UrlParameterType::QUERY,
+            pageSizeParameterType: UrlParameterType::QUERY,
+            sortParameterType: UrlParameterType::QUERY
+        );
+
+        $result = UrlParametersFactory::create(null, null, null, $config);
+
+        [$arguments, $queryParameters] = $result;
+
+        $this->assertSame([], $arguments);
+        $this->assertSame([
+            'page' => null,
+            'prev-page' => null,
+            'pagesize' => null,
+            'sort' => null,
+        ], $queryParameters);
+    }
+}
diff --git a/tests/YiiRouter/ActionColumnUrlCreatorTest.php b/tests/YiiRouter/ActionColumnUrlCreatorTest.php
new file mode 100644
index 000000000..f1075298f
--- /dev/null
+++ b/tests/YiiRouter/ActionColumnUrlCreatorTest.php
@@ -0,0 +1,151 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Yii\DataView\Tests\YiiRouter;
+
+use LogicException;
+use PHPUnit\Framework\TestCase;
+use Yiisoft\Data\Reader\ReadableDataInterface;
+use Yiisoft\Router\CurrentRoute;
+use Yiisoft\Router\Route;
+use Yiisoft\Router\UrlGeneratorInterface;
+use Yiisoft\Yii\DataView\Column\ActionColumn;
+use Yiisoft\Yii\DataView\Column\Base\DataContext;
+use Yiisoft\Yii\DataView\UrlParameterType;
+use Yiisoft\Yii\DataView\YiiRouter\ActionColumnUrlConfig;
+use Yiisoft\Yii\DataView\YiiRouter\ActionColumnUrlCreator;
+
+/**
+ * @covers \Yiisoft\Yii\DataView\YiiRouter\ActionColumnUrlCreator
+ * @uses \Yiisoft\Yii\DataView\Column\ActionColumn
+ * @uses \Yiisoft\Yii\DataView\Column\Base\DataContext
+ * @uses \Yiisoft\Yii\DataView\YiiRouter\ActionColumnUrlConfig
+ */
+final class ActionColumnUrlCreatorTest extends TestCase
+{
+    private UrlGeneratorInterface $urlGenerator;
+    private CurrentRoute $currentRoute;
+
+    protected function setUp(): void
+    {
+        $this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
+        $this->currentRoute = new CurrentRoute();
+        $this->currentRoute->setRouteWithArguments(Route::get('/test')->name('test'), []);
+    }
+
+    public function testInvokeWithDefaultConfig(): void
+    {
+        $this->urlGenerator
+            ->expects($this->once())
+            ->method('generate')
+            ->with(
+                'test/view',
+                [],
+                ['id' => '123']
+            )
+            ->willReturn('/test/view?id=123');
+
+        $creator = new ActionColumnUrlCreator($this->urlGenerator, $this->currentRoute);
+
+        $column = new ActionColumn();
+        $data = ['id' => 123];
+        $dataReader = $this->createStub(ReadableDataInterface::class);
+        $context = new DataContext($dataReader, $column, $data, 123, 0);
+
+        $url = $creator('view', $context);
+
+        $this->assertSame('/test/view?id=123', $url);
+    }
+
+    public function testInvokeWithCustomConfig(): void
+    {
+        $this->urlGenerator
+            ->expects($this->once())
+            ->method('generate')
+            ->with(
+                'custom/edit',
+                ['user_id' => '456'],
+                ['page' => '1']
+            )
+            ->willReturn('/custom/edit/456?page=1');
+
+        $config = new ActionColumnUrlConfig(
+            baseRouteName: 'custom',
+            primaryKey: 'user_id',
+            primaryKeyParameterType: UrlParameterType::PATH,
+            queryParameters: ['page' => '1']
+        );
+
+        $creator = new ActionColumnUrlCreator($this->urlGenerator, $this->currentRoute);
+
+        $column = new ActionColumn(urlConfig: $config);
+        $data = ['user_id' => 456];
+        $dataReader = $this->createStub(ReadableDataInterface::class);
+        $context = new DataContext($dataReader, $column, $data, 456, 0);
+
+        $url = $creator('edit', $context);
+
+        $this->assertSame('/custom/edit/456?page=1', $url);
+    }
+
+    public function testInvokeWithObjectData(): void
+    {
+        $this->urlGenerator
+            ->expects($this->once())
+            ->method('generate')
+            ->with(
+                'test/view',
+                [],
+                ['id' => '789']
+            )
+            ->willReturn('/test/view?id=789');
+
+        $creator = new ActionColumnUrlCreator($this->urlGenerator, $this->currentRoute);
+
+        $column = new ActionColumn();
+        $data = new class () {
+            public int $id = 789;
+        };
+        $dataReader = $this->createStub(ReadableDataInterface::class);
+        $context = new DataContext($dataReader, $column, $data, 789, 0);
+
+        $url = $creator('view', $context);
+
+        $this->assertSame('/test/view?id=789', $url);
+    }
+
+    public function testInvokeWithInvalidConfig(): void
+    {
+        $creator = new ActionColumnUrlCreator($this->urlGenerator, $this->currentRoute);
+
+        $column = new ActionColumn(urlConfig: 'invalid');
+        $data = ['id' => 123];
+        $dataReader = $this->createStub(ReadableDataInterface::class);
+        $context = new DataContext($dataReader, $column, $data, 123, 0);
+
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage(ActionColumnUrlCreator::class . ' supports ' . ActionColumnUrlConfig::class . ' only.');
+
+        $creator('view', $context);
+    }
+
+    public function testConstructor(): void
+    {
+        $urlGenerator = $this->createMock(UrlGeneratorInterface::class);
+        $currentRoute = new CurrentRoute();
+
+        // Test with default values
+        $creator = new ActionColumnUrlCreator($urlGenerator, $currentRoute);
+        $this->assertInstanceOf(ActionColumnUrlCreator::class, $creator);
+
+        // Test with custom values
+        $creator = new ActionColumnUrlCreator(
+            $urlGenerator,
+            $currentRoute,
+            'custom_id',
+            UrlParameterType::PATH
+        );
+        $this->assertInstanceOf(ActionColumnUrlCreator::class, $creator);
+    }
+}