@afixt/test-utils 1.1.8 → 1.2.1

package/test/stringUtils.test.js

@@ -2,381 +2,647 @@ 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);
-    });
-
-    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
-    });
+            p.textContent = 'Deep content';
+            article.appendChild(p);
+            section.appendChild(article);
+            div.appendChild(section);
 
-    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
-    });
-  });
+            expect(stringUtils.getAllText(div)).toBe('Deep content');
+        });
 
-  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 images without alt attributes', () => {
+            const div = document.createElement('div');
+            const img = document.createElement('img');
+            img.setAttribute('src', 'image.jpg');
+            // No alt attribute
 
-    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');
-    });
+            const text = document.createTextNode('Some text');
+            div.appendChild(text);
+            div.appendChild(img);
 
-    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.getAllText(div)).toBe('Some text');
+        });
 
-    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 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 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.getAllText(div)).toBe('Click me');
+        });
     });
 
-    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');
-    });
+    describe('hasText', () => {
+        it('should return true for elements with text content', () => {
+            const div = document.createElement('div');
+            div.textContent = 'Hello World';
 
-    it('should handle empty elements', () => {
-      const div = document.createElement('div');
-      expect(stringUtils.getAllText(div)).toBe('');
-    });
+            expect(stringUtils.hasText(div)).toBe(true);
+        });
 
-    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 false for empty elements', () => {
+            const div = document.createElement('div');
 
-    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('');
-    });
+            expect(stringUtils.hasText(div)).toBe(false);
+        });
 
-    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');
-    });
+        it('should return false for elements with only whitespace', () => {
+            const div = document.createElement('div');
+            div.textContent = '   \n\t   ';
 
-    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(false);
+        });
 
-    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 true for elements with aria-label', () => {
+            const div = document.createElement('div');
+            const button = document.createElement('button');
+            button.setAttribute('aria-label', 'Close');
 
-    it('should return false for empty elements', () => {
-      const div = document.createElement('div');
-      
-      expect(stringUtils.hasText(div)).toBe(false);
-    });
+            div.appendChild(button);
 
-    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(true);
+        });
 
-    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 elements with image alt text', () => {
+            const div = document.createElement('div');
+            const img = document.createElement('img');
+            img.setAttribute('alt', 'Profile picture');
 
-    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);
-    });
+            div.appendChild(img);
 
-    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);
-    });
+            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 true for nested elements with text', () => {
+            const div = document.createElement('div');
+            const span = document.createElement('span');
+            span.textContent = 'Nested text';
 
-      div.appendChild(span);
-      span.appendChild(p);
+            div.appendChild(span);
 
-      expect(stringUtils.hasText(div)).toBe(false);
-    });
-  });
+            expect(stringUtils.hasText(div)).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 false for elements with empty nested structure', () => {
+            const div = document.createElement('div');
+            const span = document.createElement('span');
+            const p = document.createElement('p');
 
-      // This tests the else branch where nodeValue.trim() is empty
-      const result = stringUtils.getAllText(div);
-      expect(typeof result).toBe('string');
-    });
+            div.appendChild(span);
+            span.appendChild(p);
 
-    it('should handle mixed content with whitespace text nodes', () => {
-      const div = document.createElement('div');
-      div.innerHTML = '  <span>Text</span>  ';
+            expect(stringUtils.hasText(div)).toBe(false);
+        });
 
-      const result = stringUtils.getAllText(div);
-      expect(result).toContain('Text');
-    });
+        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 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);
+            expect(stringUtils.hasText(input)).toBe(true);
+        });
 
-      const result = stringUtils.getAllText(div);
-      expect(result).toContain('Accessible Label');
-      expect(result).toContain('Visual Text');
-    });
+        it('should return false for input elements with empty value', () => {
+            const input = document.createElement('input');
+            input.type = 'text';
+            input.value = '';
 
-    it('should handle img without alt attribute', () => {
-      const div = document.createElement('div');
-      const img = document.createElement('img');
-      // No alt attribute
-      div.appendChild(img);
+            expect(stringUtils.hasText(input)).toBe(false);
+        });
+
+        it('should return true for textarea elements with a value', () => {
+            const textarea = document.createElement('textarea');
+            textarea.value = 'Some textarea text';
+
+            expect(stringUtils.hasText(textarea)).toBe(true);
+        });
 
-      const result = stringUtils.getAllText(div);
-      expect(typeof result).toBe('string');
-    });
-  });
-});
+        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);
+
+            expect(stringUtils.hasText(select)).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);
+
+            // This tests the else branch where nodeValue.trim() is empty
+            const result = stringUtils.getAllText(div);
+            expect(typeof result).toBe('string');
+        });
+
+        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('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);
+
+            const result = stringUtils.getAllText(div);
+            expect(typeof result).toBe('string');
+        });
+    });
+
+    describe('isEmptyOrWhitespace', () => {
+        it('should return true for null/undefined/empty', () => {
+            expect(stringUtils.isEmptyOrWhitespace(null)).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace(undefined)).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('')).toBe(true);
+        });
+
+        it('should return true for whitespace-only strings', () => {
+            expect(stringUtils.isEmptyOrWhitespace('   ')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\t\n')).toBe(true);
+        });
+
+        it('should return true for strings with zero-width spaces', () => {
+            expect(stringUtils.isEmptyOrWhitespace('\u200B')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\u200C')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\u200D')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\uFEFF')).toBe(true);
+            expect(stringUtils.isEmptyOrWhitespace('\u2060')).toBe(true);
+        });
+
+        it('should return true for non-breaking spaces only', () => {
+            expect(stringUtils.isEmptyOrWhitespace('\u00A0')).toBe(true);
+        });
+
+        it('should return false for strings with visible characters', () => {
+            expect(stringUtils.isEmptyOrWhitespace('hello')).toBe(false);
+            expect(stringUtils.isEmptyOrWhitespace(' a ')).toBe(false);
+            expect(stringUtils.isEmptyOrWhitespace('\u200Bx')).toBe(false);
+        });
+    });
+
+    describe('isGenericTitle', () => {
+        it('should return true for known generic titles', () => {
+            expect(stringUtils.isGenericTitle('iframe')).toBe(true);
+            expect(stringUtils.isGenericTitle('frame')).toBe(true);
+            expect(stringUtils.isGenericTitle('untitled')).toBe(true);
+            expect(stringUtils.isGenericTitle('title')).toBe(true);
+            expect(stringUtils.isGenericTitle('content')).toBe(true);
+            expect(stringUtils.isGenericTitle('main')).toBe(true);
+            expect(stringUtils.isGenericTitle('page')).toBe(true);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(stringUtils.isGenericTitle('IFRAME')).toBe(true);
+            expect(stringUtils.isGenericTitle('Untitled')).toBe(true);
+            expect(stringUtils.isGenericTitle('TITLE')).toBe(true);
+        });
+
+        it('should match numbered variants', () => {
+            expect(stringUtils.isGenericTitle('frame1')).toBe(true);
+            expect(stringUtils.isGenericTitle('iframe2')).toBe(true);
+            expect(stringUtils.isGenericTitle('untitled3')).toBe(true);
+            expect(stringUtils.isGenericTitle('title42')).toBe(true);
+        });
+
+        it('should return false for descriptive titles', () => {
+            expect(stringUtils.isGenericTitle('Contact Form')).toBe(false);
+            expect(stringUtils.isGenericTitle('Product Details')).toBe(false);
+            expect(stringUtils.isGenericTitle('Navigation Menu')).toBe(false);
+        });
+
+        it('should return false for null/undefined', () => {
+            expect(stringUtils.isGenericTitle(null)).toBe(false);
+            expect(stringUtils.isGenericTitle(undefined)).toBe(false);
+        });
+
+        it('should trim whitespace', () => {
+            expect(stringUtils.isGenericTitle('  iframe  ')).toBe(true);
+        });
+    });
+
+    describe('isGenericLinkText', () => {
+        it('should return true for common generic link text', () => {
+            expect(stringUtils.isGenericLinkText('click here')).toBe(true);
+            expect(stringUtils.isGenericLinkText('here')).toBe(true);
+            expect(stringUtils.isGenericLinkText('more')).toBe(true);
+            expect(stringUtils.isGenericLinkText('read more')).toBe(true);
+            expect(stringUtils.isGenericLinkText('learn more')).toBe(true);
+            expect(stringUtils.isGenericLinkText('link')).toBe(true);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(stringUtils.isGenericLinkText('Click Here')).toBe(true);
+            expect(stringUtils.isGenericLinkText('READ MORE')).toBe(true);
+            expect(stringUtils.isGenericLinkText('LEARN MORE')).toBe(true);
+        });
+
+        it('should return false for descriptive text', () => {
+            expect(stringUtils.isGenericLinkText('View product details')).toBe(false);
+            expect(stringUtils.isGenericLinkText('Download annual report')).toBe(false);
+        });
+
+        it('should return false for null/undefined', () => {
+            expect(stringUtils.isGenericLinkText(null)).toBe(false);
+            expect(stringUtils.isGenericLinkText(undefined)).toBe(false);
+        });
+
+        it('should support custom generic list', () => {
+            const custom = ['foo', 'bar'];
+            expect(stringUtils.isGenericLinkText('foo', custom)).toBe(true);
+            expect(stringUtils.isGenericLinkText('bar', custom)).toBe(true);
+            expect(stringUtils.isGenericLinkText('click here', custom)).toBe(false);
+        });
+
+        it('should trim whitespace', () => {
+            expect(stringUtils.isGenericLinkText('  here  ')).toBe(true);
+        });
+    });
+
+    describe('getActualVisibleText', () => {
+        it('should return empty string for null/undefined', () => {
+            expect(stringUtils.getActualVisibleText(null)).toBe('');
+            expect(stringUtils.getActualVisibleText(undefined)).toBe('');
+        });
+
+        it('should return text content of element', () => {
+            const el = document.createElement('span');
+            el.textContent = 'Hello World';
+            expect(stringUtils.getActualVisibleText(el)).toBe('Hello World');
+        });
+
+        it('should trim whitespace', () => {
+            const el = document.createElement('span');
+            el.textContent = '  Hello  ';
+            expect(stringUtils.getActualVisibleText(el)).toBe('Hello');
+        });
+
+        it('should return empty string for empty element', () => {
+            const el = document.createElement('div');
+            expect(stringUtils.getActualVisibleText(el)).toBe('');
+        });
+
+        it('should include nested text content', () => {
+            const el = document.createElement('div');
+            el.innerHTML = '<span>Nested</span> text';
+            expect(stringUtils.getActualVisibleText(el)).toBe('Nested text');
+        });
+    });
+
+    describe('hasNewWindowWarning', () => {
+        it('should return true for text containing "new window"', () => {
+            expect(stringUtils.hasNewWindowWarning('Opens in a new window')).toBe(true);
+        });
+
+        it('should return true for text containing "new tab"', () => {
+            expect(stringUtils.hasNewWindowWarning('Opens in new tab')).toBe(true);
+        });
+
+        it('should return true for "opens in new" variant', () => {
+            expect(stringUtils.hasNewWindowWarning('Link opens in new browser window')).toBe(true);
+        });
+
+        it('should return true for "external link"', () => {
+            expect(stringUtils.hasNewWindowWarning('External link to resource')).toBe(true);
+        });
+
+        it('should return true for "external site"', () => {
+            expect(stringUtils.hasNewWindowWarning('Goes to external site')).toBe(true);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(stringUtils.hasNewWindowWarning('Opens In A New Window')).toBe(true);
+            expect(stringUtils.hasNewWindowWarning('EXTERNAL LINK')).toBe(true);
+        });
+
+        it('should return false for text without warning', () => {
+            expect(stringUtils.hasNewWindowWarning('Contact us')).toBe(false);
+            expect(stringUtils.hasNewWindowWarning('Read the article')).toBe(false);
+        });
+
+        it('should return false for null/undefined', () => {
+            expect(stringUtils.hasNewWindowWarning(null)).toBe(false);
+            expect(stringUtils.hasNewWindowWarning(undefined)).toBe(false);
+        });
+    });
+
+    describe('textIncludingImgAlt', () => {
+        it('should return text content from text nodes', () => {
+            const el = document.createElement('div');
+            el.textContent = 'Hello World';
+            expect(stringUtils.textIncludingImgAlt(el).trim()).toBe('Hello World');
+        });
+
+        it('should include img alt text', () => {
+            const el = document.createElement('div');
+            el.innerHTML = 'Text <img alt="photo"> more text';
+            const result = stringUtils.textIncludingImgAlt(el);
+            expect(result).toContain('Text');
+            expect(result).toContain('photo');
+            expect(result).toContain('more text');
+        });
+
+        it('should handle img without alt', () => {
+            const el = document.createElement('div');
+            el.innerHTML = 'Text <img src="img.png"> more';
+            const result = stringUtils.textIncludingImgAlt(el);
+            expect(result).toContain('Text');
+            expect(result).toContain('more');
+        });
+
+        it('should not include aria-label text', () => {
+            const el = document.createElement('div');
+            el.innerHTML = '<button aria-label="Close">X</button>';
+            const result = stringUtils.textIncludingImgAlt(el);
+            expect(result).toContain('X');
+            expect(result).not.toContain('Close');
+        });
+
+        it('should handle empty element', () => {
+            const el = document.createElement('div');
+            expect(stringUtils.textIncludingImgAlt(el)).toBe('');
+        });
+
+        it('should concatenate text from nested elements', () => {
+            const el = document.createElement('div');
+            el.innerHTML = '<span>First</span> <span>Second</span>';
+            const result = stringUtils.textIncludingImgAlt(el);
+            expect(result).toContain('First');
+            expect(result).toContain('Second');
+        });
+    });
+});