@afixt/test-utils 1.1.7 → 1.2.0

package/test/stringUtils.test.js

@@ -2,381 +2,425 @@ import { describe, it, expect } from 'vitest';
 import stringUtils from '../src/stringUtils.js';
 
 describe('stringUtils', () => {
-  describe('isEmpty', () => {
-    it('should return true for empty strings', () => {
-      expect(stringUtils.isEmpty('')).toBe(true);
-      expect(stringUtils.isEmpty('   ')).toBe(true);
-      expect(stringUtils.isEmpty('\n\t')).toBe(true);
-    });
+    describe('isEmpty', () => {
+        it('should return true for empty strings', () => {
+            expect(stringUtils.isEmpty('')).toBe(true);
+            expect(stringUtils.isEmpty('   ')).toBe(true);
+            expect(stringUtils.isEmpty('\n\t')).toBe(true);
+        });
+
+        it('should return true for null or undefined', () => {
+            expect(stringUtils.isEmpty(null)).toBe(true);
+            expect(stringUtils.isEmpty(undefined)).toBe(true);
+        });
+
+        it('should return false for non-empty strings', () => {
+            expect(stringUtils.isEmpty('hello')).toBe(false);
+            expect(stringUtils.isEmpty('   hello   ')).toBe(false);
+            expect(stringUtils.isEmpty('0')).toBe(false);
+        });
+    });
+
+    describe('isString', () => {
+        it('should return true for string literals', () => {
+            expect(stringUtils.isString('')).toBe(true);
+            expect(stringUtils.isString('hello')).toBe(true);
+        });
+
+        it('should return true for String objects', () => {
+            expect(stringUtils.isString(new String('hello'))).toBe(true);
+        });
+
+        it('should return false for non-strings', () => {
+            expect(stringUtils.isString(123)).toBe(false);
+            expect(stringUtils.isString({})).toBe(false);
+            expect(stringUtils.isString([])).toBe(false);
+            expect(stringUtils.isString(null)).toBe(false);
+            expect(stringUtils.isString(undefined)).toBe(false);
+        });
+    });
+
+    describe('strlen', () => {
+        it('should return correct length for trimmed strings', () => {
+            expect(stringUtils.strlen('hello')).toBe(5);
+            expect(stringUtils.strlen('  hello  ')).toBe(5);
+        });
+
+        it('should return 0 for empty strings', () => {
+            expect(stringUtils.strlen('')).toBe(0);
+            expect(stringUtils.strlen('   ')).toBe(0);
+        });
+
+        it('should return 0 for non-strings', () => {
+            expect(stringUtils.strlen(null)).toBe(0);
+            expect(stringUtils.strlen(undefined)).toBe(0);
+            expect(stringUtils.strlen(123)).toBe(0);
+        });
+    });
+
+    describe('isNormalInteger', () => {
+        it('should return true for valid integer strings', () => {
+            expect(stringUtils.isNormalInteger('0')).toBe(true);
+            expect(stringUtils.isNormalInteger('1')).toBe(true);
+            expect(stringUtils.isNormalInteger('123')).toBe(true);
+        });
+
+        it('should return false for non-integer strings', () => {
+            expect(stringUtils.isNormalInteger('1.5')).toBe(false);
+            expect(stringUtils.isNormalInteger('-1')).toBe(false);
+            expect(stringUtils.isNormalInteger('abc')).toBe(false);
+            expect(stringUtils.isNormalInteger('')).toBe(false);
+        });
+    });
+
+    describe('isUpperCase', () => {
+        it('should return true for uppercase strings', () => {
+            expect(stringUtils.isUpperCase('HELLO')).toBe(true);
+            expect(stringUtils.isUpperCase('HELLO WORLD')).toBe(true);
+            expect(stringUtils.isUpperCase('HELLO123')).toBe(true);
+            expect(stringUtils.isUpperCase('HELLO!')).toBe(true);
+        });
+
+        it('should return false for strings with lowercase characters', () => {
+            expect(stringUtils.isUpperCase('Hello')).toBe(false);
+            expect(stringUtils.isUpperCase('HELLO world')).toBe(false);
+        });
+
+        it('should handle edge cases', () => {
+            expect(stringUtils.isUpperCase('')).toBe(true); // Empty string has no lowercase letters
+            expect(stringUtils.isUpperCase('123')).toBe(true); // Numbers only
+            expect(stringUtils.isUpperCase('!@#')).toBe(true); // Symbols only
+            expect(stringUtils.isUpperCase(undefined)).toBe(false);
+        });
+    });
+
+    describe('isAlphaNumeric', () => {
+        it('should return true for strings containing only alphanumeric characters', () => {
+            expect(stringUtils.isAlphaNumeric('abc123')).toBe(true);
+            expect(stringUtils.isAlphaNumeric('ABC')).toBe(true);
+            expect(stringUtils.isAlphaNumeric('123')).toBe(true);
+            expect(stringUtils.isAlphaNumeric('Test123')).toBe(true);
+            expect(stringUtils.isAlphaNumeric('a')).toBe(true);
+            expect(stringUtils.isAlphaNumeric('1')).toBe(true);
+        });
+
+        it('should return false for strings containing non-alphanumeric characters', () => {
+            expect(stringUtils.isAlphaNumeric('abc 123')).toBe(false); // space
+            expect(stringUtils.isAlphaNumeric('abc-123')).toBe(false); // hyphen
+            expect(stringUtils.isAlphaNumeric('abc_123')).toBe(false); // underscore
+            expect(stringUtils.isAlphaNumeric('abc@123')).toBe(false); // special character
+            expect(stringUtils.isAlphaNumeric('abc.123')).toBe(false); // period
+            expect(stringUtils.isAlphaNumeric('abc!123')).toBe(false); // exclamation
+            expect(stringUtils.isAlphaNumeric('')).toBe(false); // empty string
+        });
+
+        it('should return false for special edge cases', () => {
+            expect(stringUtils.isAlphaNumeric('\n')).toBe(false); // newline
+            expect(stringUtils.isAlphaNumeric('\t')).toBe(false); // tab
+            expect(stringUtils.isAlphaNumeric('   ')).toBe(false); // whitespace
+        });
+    });
+
+    describe('getPathFromUrl', () => {
+        it('should extract the pathname correctly', () => {
+            expect(stringUtils.getPathFromUrl('https://example.com/path/to/resource')).toBe(
+                '/path/to/resource'
+            );
+            expect(stringUtils.getPathFromUrl('https://example.com/')).toBe('/');
+            expect(stringUtils.getPathFromUrl('https://example.com/path?query=string')).toBe(
+                '/path'
+            );
+        });
+
+        it('should handle complex URLs', () => {
+            expect(
+                stringUtils.getPathFromUrl('https://subdomain.example.com/path/to/resource')
+            ).toBe('/path/to/resource');
+            expect(stringUtils.getPathFromUrl('http://example.com/path/to/resource#hash')).toBe(
+                '/path/to/resource'
+            );
+            expect(stringUtils.getPathFromUrl('https://example.com:8080/path')).toBe('/path');
+        });
+
+        it('should handle URLs with encoded characters', () => {
+            expect(stringUtils.getPathFromUrl('https://example.com/path%20with%20spaces')).toBe(
+                '/path%20with%20spaces'
+            );
+            expect(
+                stringUtils.getPathFromUrl('https://example.com/path/with/special%20chars')
+            ).toBe('/path/with/special%20chars');
+        });
+    });
+
+    describe('getAllText', () => {
+        it('should extract text from simple text nodes', () => {
+            const div = document.createElement('div');
+            div.textContent = 'Hello World';
+
+            expect(stringUtils.getAllText(div)).toBe('Hello World');
+        });
+
+        it('should extract text from nested elements', () => {
+            const div = document.createElement('div');
+            const span = document.createElement('span');
+            span.textContent = 'Hello';
+            const text = document.createTextNode(' World');
+
+            div.appendChild(span);
+            div.appendChild(text);
+
+            expect(stringUtils.getAllText(div)).toBe('Hello World');
+        });
+
+        it('should extract aria-label attributes', () => {
+            const div = document.createElement('div');
+            const button = document.createElement('button');
+            button.setAttribute('aria-label', 'Close dialog');
+            button.textContent = 'X';
+
+            div.appendChild(button);
+
+            const result = stringUtils.getAllText(div);
+            expect(result).toContain('Close dialog');
+            expect(result).toContain('X');
+        });
+
+        it('should extract alt attributes from images', () => {
+            const div = document.createElement('div');
+            const img = document.createElement('img');
+            img.setAttribute('alt', 'Profile picture');
+            img.setAttribute('src', 'profile.jpg');
+
+            div.appendChild(img);
+
+            expect(stringUtils.getAllText(div)).toBe('Profile picture');
+        });
+
+        it('should handle mixed content with text, aria-labels, and alt text', () => {
+            const div = document.createElement('div');
+
+            // Add some text
+            const textNode = document.createTextNode('Welcome ');
+            div.appendChild(textNode);
+
+            // Add element with aria-label
+            const button = document.createElement('button');
+            button.setAttribute('aria-label', 'Help');
+            button.textContent = '?';
+            div.appendChild(button);
+
+            // Add some more text
+            const moreText = document.createTextNode(' to our site ');
+            div.appendChild(moreText);
+
+            // Add image with alt text
+            const img = document.createElement('img');
+            img.setAttribute('alt', 'Company logo');
+            div.appendChild(img);
+
+            const result = stringUtils.getAllText(div);
+            expect(result).toContain('Welcome');
+            expect(result).toContain('Help');
+            expect(result).toContain('?');
+            expect(result).toContain('to our site');
+            expect(result).toContain('Company logo');
+        });
+
+        it('should handle empty elements', () => {
+            const div = document.createElement('div');
+            expect(stringUtils.getAllText(div)).toBe('');
+        });
+
+        it('should trim whitespace from text nodes', () => {
+            const div = document.createElement('div');
+            const textNode = document.createTextNode('   Hello World   ');
+            div.appendChild(textNode);
+
+            expect(stringUtils.getAllText(div)).toBe('Hello World');
+        });
 
-    it('should return true for null or undefined', () => {
-      expect(stringUtils.isEmpty(null)).toBe(true);
-      expect(stringUtils.isEmpty(undefined)).toBe(true);
-    });
+        it('should handle elements with only whitespace', () => {
+            const div = document.createElement('div');
+            const textNode = document.createTextNode('   ');
+            div.appendChild(textNode);
 
-    it('should return false for non-empty strings', () => {
-      expect(stringUtils.isEmpty('hello')).toBe(false);
-      expect(stringUtils.isEmpty('   hello   ')).toBe(false);
-      expect(stringUtils.isEmpty('0')).toBe(false);
-    });
-  });
+            // Should use textContent.trim() as fallback for empty text
+            expect(stringUtils.getAllText(div)).toBe('');
+        });
 
-  describe('isString', () => {
-    it('should return true for string literals', () => {
-      expect(stringUtils.isString('')).toBe(true);
-      expect(stringUtils.isString('hello')).toBe(true);
-    });
+        it('should handle deeply nested structures', () => {
+            const div = document.createElement('div');
+            const section = document.createElement('section');
+            const article = document.createElement('article');
+            const p = document.createElement('p');
 
-    it('should return true for String objects', () => {
-      expect(stringUtils.isString(new String('hello'))).toBe(true);
-    });
+            p.textContent = 'Deep content';
+            article.appendChild(p);
+            section.appendChild(article);
+            div.appendChild(section);
 
-    it('should return false for non-strings', () => {
-      expect(stringUtils.isString(123)).toBe(false);
-      expect(stringUtils.isString({})).toBe(false);
-      expect(stringUtils.isString([])).toBe(false);
-      expect(stringUtils.isString(null)).toBe(false);
-      expect(stringUtils.isString(undefined)).toBe(false);
-    });
-  });
+            expect(stringUtils.getAllText(div)).toBe('Deep content');
+        });
 
-  describe('strlen', () => {
-    it('should return correct length for trimmed strings', () => {
-      expect(stringUtils.strlen('hello')).toBe(5);
-      expect(stringUtils.strlen('  hello  ')).toBe(5);
-    });
+        it('should handle images without alt attributes', () => {
+            const div = document.createElement('div');
+            const img = document.createElement('img');
+            img.setAttribute('src', 'image.jpg');
+            // No alt attribute
 
-    it('should return 0 for empty strings', () => {
-      expect(stringUtils.strlen('')).toBe(0);
-      expect(stringUtils.strlen('   ')).toBe(0);
-    });
+            const text = document.createTextNode('Some text');
+            div.appendChild(text);
+            div.appendChild(img);
 
-    it('should return 0 for non-strings', () => {
-      expect(stringUtils.strlen(null)).toBe(0);
-      expect(stringUtils.strlen(undefined)).toBe(0);
-      expect(stringUtils.strlen(123)).toBe(0);
-    });
-  });
+            expect(stringUtils.getAllText(div)).toBe('Some text');
+        });
 
-  describe('isNormalInteger', () => {
-    it('should return true for valid integer strings', () => {
-      expect(stringUtils.isNormalInteger('0')).toBe(true);
-      expect(stringUtils.isNormalInteger('1')).toBe(true);
-      expect(stringUtils.isNormalInteger('123')).toBe(true);
-    });
+        it('should handle elements without aria-label', () => {
+            const div = document.createElement('div');
+            const button = document.createElement('button');
+            button.textContent = 'Click me';
+            // No aria-label attribute
 
-    it('should return false for non-integer strings', () => {
-      expect(stringUtils.isNormalInteger('1.5')).toBe(false);
-      expect(stringUtils.isNormalInteger('-1')).toBe(false);
-      expect(stringUtils.isNormalInteger('abc')).toBe(false);
-      expect(stringUtils.isNormalInteger('')).toBe(false);
-    });
-  });
-
-  describe('isUpperCase', () => {
-    it('should return true for uppercase strings', () => {
-      expect(stringUtils.isUpperCase('HELLO')).toBe(true);
-      expect(stringUtils.isUpperCase('HELLO WORLD')).toBe(true);
-      expect(stringUtils.isUpperCase('HELLO123')).toBe(true);
-      expect(stringUtils.isUpperCase('HELLO!')).toBe(true);
-    });
+            div.appendChild(button);
 
-    it('should return false for strings with lowercase characters', () => {
-      expect(stringUtils.isUpperCase('Hello')).toBe(false);
-      expect(stringUtils.isUpperCase('HELLO world')).toBe(false);
+            expect(stringUtils.getAllText(div)).toBe('Click me');
+        });
     });
 
-    it('should handle edge cases', () => {
-      expect(stringUtils.isUpperCase('')).toBe(true); // Empty string has no lowercase letters
-      expect(stringUtils.isUpperCase('123')).toBe(true); // Numbers only
-      expect(stringUtils.isUpperCase('!@#')).toBe(true); // Symbols only
-      expect(stringUtils.isUpperCase(undefined)).toBe(false);
-    });
-  });
-
-  describe('isAlphaNumeric', () => {
-    it('should return true for strings containing only alphanumeric characters', () => {
-      expect(stringUtils.isAlphaNumeric('abc123')).toBe(true);
-      expect(stringUtils.isAlphaNumeric('ABC')).toBe(true);
-      expect(stringUtils.isAlphaNumeric('123')).toBe(true);
-      expect(stringUtils.isAlphaNumeric('Test123')).toBe(true);
-      expect(stringUtils.isAlphaNumeric('a')).toBe(true);
-      expect(stringUtils.isAlphaNumeric('1')).toBe(true);
-    });
+    describe('hasText', () => {
+        it('should return true for elements with text content', () => {
+            const div = document.createElement('div');
+            div.textContent = 'Hello World';
 
-    it('should return false for strings containing non-alphanumeric characters', () => {
-      expect(stringUtils.isAlphaNumeric('abc 123')).toBe(false); // space
-      expect(stringUtils.isAlphaNumeric('abc-123')).toBe(false); // hyphen
-      expect(stringUtils.isAlphaNumeric('abc_123')).toBe(false); // underscore
-      expect(stringUtils.isAlphaNumeric('abc@123')).toBe(false); // special character
-      expect(stringUtils.isAlphaNumeric('abc.123')).toBe(false); // period
-      expect(stringUtils.isAlphaNumeric('abc!123')).toBe(false); // exclamation
-      expect(stringUtils.isAlphaNumeric('')).toBe(false); // empty string
-    });
+            expect(stringUtils.hasText(div)).toBe(true);
+        });
 
-    it('should return false for special edge cases', () => {
-      expect(stringUtils.isAlphaNumeric('\n')).toBe(false); // newline
-      expect(stringUtils.isAlphaNumeric('\t')).toBe(false); // tab
-      expect(stringUtils.isAlphaNumeric('   ')).toBe(false); // whitespace
-    });
-  });
+        it('should return false for empty elements', () => {
+            const div = document.createElement('div');
 
-  describe('getPathFromUrl', () => {
-    it('should extract the pathname correctly', () => {
-      expect(stringUtils.getPathFromUrl('https://example.com/path/to/resource')).toBe('/path/to/resource');
-      expect(stringUtils.getPathFromUrl('https://example.com/')).toBe('/');
-      expect(stringUtils.getPathFromUrl('https://example.com/path?query=string')).toBe('/path');
-    });
+            expect(stringUtils.hasText(div)).toBe(false);
+        });
 
-    it('should handle complex URLs', () => {
-      expect(stringUtils.getPathFromUrl('https://subdomain.example.com/path/to/resource')).toBe('/path/to/resource');
-      expect(stringUtils.getPathFromUrl('http://example.com/path/to/resource#hash')).toBe('/path/to/resource');
-      expect(stringUtils.getPathFromUrl('https://example.com:8080/path')).toBe('/path');
-    });
+        it('should return false for elements with only whitespace', () => {
+            const div = document.createElement('div');
+            div.textContent = '   \n\t   ';
 
-    it('should handle URLs with encoded characters', () => {
-      expect(stringUtils.getPathFromUrl('https://example.com/path%20with%20spaces')).toBe('/path%20with%20spaces');
-      expect(stringUtils.getPathFromUrl('https://example.com/path/with/special%20chars')).toBe('/path/with/special%20chars');
-    });
-  });
-
-  describe('getAllText', () => {
-    it('should extract text from simple text nodes', () => {
-      const div = document.createElement('div');
-      div.textContent = 'Hello World';
-      
-      expect(stringUtils.getAllText(div)).toBe('Hello World');
-    });
+            expect(stringUtils.hasText(div)).toBe(false);
+        });
 
-    it('should extract text from nested elements', () => {
-      const div = document.createElement('div');
-      const span = document.createElement('span');
-      span.textContent = 'Hello';
-      const text = document.createTextNode(' World');
-      
-      div.appendChild(span);
-      div.appendChild(text);
-      
-      expect(stringUtils.getAllText(div)).toBe('Hello World');
-    });
+        it('should return true for elements with aria-label', () => {
+            const div = document.createElement('div');
+            const button = document.createElement('button');
+            button.setAttribute('aria-label', 'Close');
 
-    it('should extract aria-label attributes', () => {
-      const div = document.createElement('div');
-      const button = document.createElement('button');
-      button.setAttribute('aria-label', 'Close dialog');
-      button.textContent = 'X';
-      
-      div.appendChild(button);
-      
-      const result = stringUtils.getAllText(div);
-      expect(result).toContain('Close dialog');
-      expect(result).toContain('X');
-    });
+            div.appendChild(button);
 
-    it('should extract alt attributes from images', () => {
-      const div = document.createElement('div');
-      const img = document.createElement('img');
-      img.setAttribute('alt', 'Profile picture');
-      img.setAttribute('src', 'profile.jpg');
-      
-      div.appendChild(img);
-      
-      expect(stringUtils.getAllText(div)).toBe('Profile picture');
-    });
+            expect(stringUtils.hasText(div)).toBe(true);
+        });
 
-    it('should handle mixed content with text, aria-labels, and alt text', () => {
-      const div = document.createElement('div');
-      
-      // Add some text
-      const textNode = document.createTextNode('Welcome ');
-      div.appendChild(textNode);
-      
-      // Add element with aria-label
-      const button = document.createElement('button');
-      button.setAttribute('aria-label', 'Help');
-      button.textContent = '?';
-      div.appendChild(button);
-      
-      // Add some more text
-      const moreText = document.createTextNode(' to our site ');
-      div.appendChild(moreText);
-      
-      // Add image with alt text
-      const img = document.createElement('img');
-      img.setAttribute('alt', 'Company logo');
-      div.appendChild(img);
-      
-      const result = stringUtils.getAllText(div);
-      expect(result).toContain('Welcome');
-      expect(result).toContain('Help');
-      expect(result).toContain('?');
-      expect(result).toContain('to our site');
-      expect(result).toContain('Company logo');
-    });
+        it('should return true for elements with image alt text', () => {
+            const div = document.createElement('div');
+            const img = document.createElement('img');
+            img.setAttribute('alt', 'Profile picture');
 
-    it('should handle empty elements', () => {
-      const div = document.createElement('div');
-      expect(stringUtils.getAllText(div)).toBe('');
-    });
+            div.appendChild(img);
 
-    it('should trim whitespace from text nodes', () => {
-      const div = document.createElement('div');
-      const textNode = document.createTextNode('   Hello World   ');
-      div.appendChild(textNode);
-      
-      expect(stringUtils.getAllText(div)).toBe('Hello World');
-    });
+            expect(stringUtils.hasText(div)).toBe(true);
+        });
 
-    it('should handle elements with only whitespace', () => {
-      const div = document.createElement('div');
-      const textNode = document.createTextNode('   ');
-      div.appendChild(textNode);
-      
-      // Should use textContent.trim() as fallback for empty text
-      expect(stringUtils.getAllText(div)).toBe('');
-    });
+        it('should return true for nested elements with text', () => {
+            const div = document.createElement('div');
+            const span = document.createElement('span');
+            span.textContent = 'Nested text';
 
-    it('should handle deeply nested structures', () => {
-      const div = document.createElement('div');
-      const section = document.createElement('section');
-      const article = document.createElement('article');
-      const p = document.createElement('p');
-      
-      p.textContent = 'Deep content';
-      article.appendChild(p);
-      section.appendChild(article);
-      div.appendChild(section);
-      
-      expect(stringUtils.getAllText(div)).toBe('Deep content');
-    });
+            div.appendChild(span);
 
-    it('should handle images without alt attributes', () => {
-      const div = document.createElement('div');
-      const img = document.createElement('img');
-      img.setAttribute('src', 'image.jpg');
-      // No alt attribute
-      
-      const text = document.createTextNode('Some text');
-      div.appendChild(text);
-      div.appendChild(img);
-      
-      expect(stringUtils.getAllText(div)).toBe('Some text');
-    });
+            expect(stringUtils.hasText(div)).toBe(true);
+        });
 
-    it('should handle elements without aria-label', () => {
-      const div = document.createElement('div');
-      const button = document.createElement('button');
-      button.textContent = 'Click me';
-      // No aria-label attribute
-      
-      div.appendChild(button);
-      
-      expect(stringUtils.getAllText(div)).toBe('Click me');
-    });
-  });
-
-  describe('hasText', () => {
-    it('should return true for elements with text content', () => {
-      const div = document.createElement('div');
-      div.textContent = 'Hello World';
-      
-      expect(stringUtils.hasText(div)).toBe(true);
-    });
+        it('should return false for elements with empty nested structure', () => {
+            const div = document.createElement('div');
+            const span = document.createElement('span');
+            const p = document.createElement('p');
 
-    it('should return false for empty elements', () => {
-      const div = document.createElement('div');
-      
-      expect(stringUtils.hasText(div)).toBe(false);
-    });
+            div.appendChild(span);
+            span.appendChild(p);
 
-    it('should return false for elements with only whitespace', () => {
-      const div = document.createElement('div');
-      div.textContent = '   \n\t   ';
-      
-      expect(stringUtils.hasText(div)).toBe(false);
-    });
+            expect(stringUtils.hasText(div)).toBe(false);
+        });
 
-    it('should return true for elements with aria-label', () => {
-      const div = document.createElement('div');
-      const button = document.createElement('button');
-      button.setAttribute('aria-label', 'Close');
-      
-      div.appendChild(button);
-      
-      expect(stringUtils.hasText(div)).toBe(true);
-    });
+        it('should return true for input elements with a value', () => {
+            const input = document.createElement('input');
+            input.type = 'text';
+            input.value = 'Some input text';
 
-    it('should return true for elements with image alt text', () => {
-      const div = document.createElement('div');
-      const img = document.createElement('img');
-      img.setAttribute('alt', 'Profile picture');
-      
-      div.appendChild(img);
-      
-      expect(stringUtils.hasText(div)).toBe(true);
-    });
+            expect(stringUtils.hasText(input)).toBe(true);
+        });
 
-    it('should return true for nested elements with text', () => {
-      const div = document.createElement('div');
-      const span = document.createElement('span');
-      span.textContent = 'Nested text';
-      
-      div.appendChild(span);
-      
-      expect(stringUtils.hasText(div)).toBe(true);
-    });
+        it('should return false for input elements with empty value', () => {
+            const input = document.createElement('input');
+            input.type = 'text';
+            input.value = '';
 
-    it('should return false for elements with empty nested structure', () => {
-      const div = document.createElement('div');
-      const span = document.createElement('span');
-      const p = document.createElement('p');
+            expect(stringUtils.hasText(input)).toBe(false);
+        });
 
-      div.appendChild(span);
-      span.appendChild(p);
+        it('should return true for textarea elements with a value', () => {
+            const textarea = document.createElement('textarea');
+            textarea.value = 'Some textarea text';
 
-      expect(stringUtils.hasText(div)).toBe(false);
-    });
-  });
+            expect(stringUtils.hasText(textarea)).toBe(true);
+        });
 
-  describe('getAllText edge cases', () => {
-    it('should handle text nodes with empty nodeValue but non-empty textContent', () => {
-      const div = document.createElement('div');
-      const textNode = document.createTextNode('   ');
-      div.appendChild(textNode);
+        it('should return true for select elements with selected option text', () => {
+            const select = document.createElement('select');
+            const option = document.createElement('option');
+            option.textContent = 'Option 1';
+            select.appendChild(option);
 
-      // This tests the else branch where nodeValue.trim() is empty
-      const result = stringUtils.getAllText(div);
-      expect(typeof result).toBe('string');
+            expect(stringUtils.hasText(select)).toBe(true);
+        });
     });
 
-    it('should handle mixed content with whitespace text nodes', () => {
-      const div = document.createElement('div');
-      div.innerHTML = '  <span>Text</span>  ';
+    describe('getAllText edge cases', () => {
+        it('should handle text nodes with empty nodeValue but non-empty textContent', () => {
+            const div = document.createElement('div');
+            const textNode = document.createTextNode('   ');
+            div.appendChild(textNode);
 
-      const result = stringUtils.getAllText(div);
-      expect(result).toContain('Text');
-    });
+            // This tests the else branch where nodeValue.trim() is empty
+            const result = stringUtils.getAllText(div);
+            expect(typeof result).toBe('string');
+        });
 
-    it('should handle elements with both aria-label and text content', () => {
-      const div = document.createElement('div');
-      const button = document.createElement('button');
-      button.textContent = 'Visual Text';
-      button.setAttribute('aria-label', 'Accessible Label');
-      div.appendChild(button);
+        it('should handle mixed content with whitespace text nodes', () => {
+            const div = document.createElement('div');
+            div.innerHTML = '  <span>Text</span>  ';
 
-      const result = stringUtils.getAllText(div);
-      expect(result).toContain('Accessible Label');
-      expect(result).toContain('Visual Text');
-    });
+            const result = stringUtils.getAllText(div);
+            expect(result).toContain('Text');
+        });
+
+        it('should handle elements with both aria-label and text content', () => {
+            const div = document.createElement('div');
+            const button = document.createElement('button');
+            button.textContent = 'Visual Text';
+            button.setAttribute('aria-label', 'Accessible Label');
+            div.appendChild(button);
+
+            const result = stringUtils.getAllText(div);
+            expect(result).toContain('Accessible Label');
+            expect(result).toContain('Visual Text');
+        });
 
-    it('should handle img without alt attribute', () => {
-      const div = document.createElement('div');
-      const img = document.createElement('img');
-      // No alt attribute
-      div.appendChild(img);
+        it('should handle img without alt attribute', () => {
+            const div = document.createElement('div');
+            const img = document.createElement('img');
+            // No alt attribute
+            div.appendChild(img);
 
-      const result = stringUtils.getAllText(div);
-      expect(typeof result).toBe('string');
+            const result = stringUtils.getAllText(div);
+            expect(typeof result).toBe('string');
+        });
     });
-  });
-});
+});