export const isEmptyCases = [
  { valueInput: '', valueOutput: true },
  { valueInput: ' ', valueOutput: true },
  { valueInput: null, valueOutput: true },
  { valueInput: undefined, valueOutput: true },
  { valueInput: '0', valueOutput: false },
  { valueInput: 'ab', valueOutput: false },
]


export const replaceAccentuatedCharsCases = [
  { valueInput: 'ÁÀÂÃÄ', valueOutput: 'AAAAA' },
  { valueInput: 'áàâãä', valueOutput: 'aaaaa' },
  { valueInput: 'Ç', valueOutput: 'C' },
]

export const replaceAccentuatedCharsKeepSymbolsCases = [
  { valueInput: 'áéíóú', valueOutput: 'AEIOU' },
  { valueInput: 'âêîôû', valueOutput: 'AEIOU' },
  { valueInput: 'çñ', valueOutput: 'CN' },
  { valueInput: 'ãõ', valueOutput: 'AO' },
  { valueInput: 'hello', valueOutput: 'HELLO' },
  { valueInput: 'WORLD', valueOutput: 'WORLD' },
  { valueInput: '12345', valueOutput: '12345' },
  { valueInput: '!@#$%^&*()', valueOutput: '!@#$%^&*()' },
  { valueInput: 'Olá, mundo!', valueOutput: 'OLA, MUNDO!' },
  { valueInput: 'Café com leite!', valueOutput: 'CAFE COM LEITE!' },
  { valueInput: '123 çñ áéíóú', valueOutput: '123 CN AEIOU' },
  { valueInput: '', valueOutput: '' },
  { valueInput: 'àèìòù', valueOutput: 'AEIOU' },
  { valueInput: 'ÀÈÌÒÙ', valueOutput: 'AEIOU' },
  { valueInput: 'ÁÉÍÓÚÇÑãõâêîôû', valueOutput: 'AEIOUCNAOAEIOU' },
];

export const replaceBlankCharactersCases = [
  { valueInput: 'Hello World', valueOutput: 'HelloWorld' },
  { valueInput: 'Test 123', valueOutput: 'Test123' },
  { valueInput: 'Replace    spaces', valueOutput: 'Replacespaces' },
  { valueInput: 'NoSpacesHere', valueOutput: 'NoSpacesHere' },
  { valueInput: 'Multiple    spaces   here', valueOutput: 'Multiplespaceshere' },
  { valueInput: '  Leading and trailing spaces  ', valueOutput: 'Leadingandtrailingspaces' },
  { valueInput: '', valueOutput: '' },
  { valueInput: 'SingleSpace', valueOutput: 'SingleSpace' },
];

export const replaceToSpaceCases = [
  { valueInput: 'Hello World', replaceList: ['World'], valueOutput: 'Hello      ' },
  { valueInput: 'Test 123', replaceList: ['123'], valueOutput: 'Test    ' },
  { valueInput: 'Replace the word', replaceList: ['word'], valueOutput: 'Replace the     ' },
  { valueInput: 'No change here', replaceList: ['no'], valueOutput: 'No change here' },
  { valueInput: 'Multiple words to replace', replaceList: ['Multiple', 'replace'], valueOutput: '         words to        ' },
  { valueInput: '  Leading and trailing spaces  ', replaceList: ['Leading', 'spaces'], valueOutput: '          and trailing         ' },
  { valueInput: '', replaceList: ['word'], valueOutput: '' },
  { valueInput: 'Single word replacement', replaceList: ['word'], valueOutput: 'Single      replacement' },
  { valueInput: 'Only word here', replaceList: ['Only', 'here'], valueOutput: '     word     ' },
  { valueInput: 'Replace multiple occurrences', replaceList: ['multiple'], valueOutput: 'Replace          occurrences' },
];

export const replaceAllCases = [
  { valueInput: 'Hello World', strFrom: 'World', strTo: 'Universe', valueOutput: 'Hello Universe' },
  { valueInput: 'Test 123 123', strFrom: '123', strTo: '456', valueOutput: 'Test 456 456' },
  { valueInput: 'Replace all spaces', strFrom: ' ', strTo: '_', valueOutput: 'Replace_all_spaces' },
  { valueInput: 'No changes here', strFrom: 'word', strTo: 'term', valueOutput: 'No changes here' },
  { valueInput: 'Multiple occurrences of term term term', strFrom: 'term', strTo: 'word', valueOutput: 'Multiple occurrences of word word word' },
  { valueInput: 'Case Sensitive Test', strFrom: 'test', strTo: 'exam', valueOutput: 'Case Sensitive Test' },
  { valueInput: 'Multiple words to replace', strFrom: ' ', strTo: '-', valueOutput: 'Multiple-words-to-replace' },
  { valueInput: '', strFrom: 'word', strTo: 'term', valueOutput: '' },
  { valueInput: 'aaaa bbbb aaaa', strFrom: 'aaaa', strTo: 'cccc', valueOutput: 'cccc bbbb cccc' },
  { valueInput: 'Look at this example: example example', strFrom: 'example', strTo: 'demo', valueOutput: 'Look at this demo: demo demo' },
];

export const removeSpecialCharactersCases = [
  { valueInput: 'Hello!@#$ World', valueOutput: 'Hello World' },
  { valueInput: 'Test 123 #$%', valueOutput: 'Test 123 ' },
  { valueInput: 'Remove *&%$# special characters!', valueOutput: 'Remove  special characters' },
  { valueInput: 'NoSpecialCharsHere', valueOutput: 'NoSpecialCharsHere' },
  { valueInput: '!!!Start and End!!!', valueOutput: 'Start and End' },
  { valueInput: '12345', valueOutput: '12345' },
  { valueInput: 'Clean this string @&*#$', valueOutput: 'Clean this string ' },
  { valueInput: '', valueOutput: '' },
  { valueInput: 'We @like $ to @#test!!', valueOutput: 'We like  to test' },
  { valueInput: 'Some $pec!@l #chars %%%%%&*(', valueOutput: 'Some pecl chars ' },
];

export const isStringCases = [
  { valueInput: 'Hello, World!', valueOutput: true },
  { valueInput: '', valueOutput: true },
  { valueInput: new String('Test String'), valueOutput: true },
  { valueInput: 12345, valueOutput: false },
  { valueInput: null, valueOutput: false },
  { valueInput: undefined, valueOutput: false },
  { valueInput: { key: 'value' }, valueOutput: false },
  { valueInput: ['array'], valueOutput: false },
  { valueInput: true, valueOutput: false },
  { valueInput: Symbol('test'), valueOutput: false },
  { valueInput: function () {}, valueOutput: false },
  { valueInput: NaN, valueOutput: false },
];

export const decodeHtmlEntitiesCases = [
  { valueInput: 'Hello & World', valueOutput: 'Hello & World' },
  { valueInput: 'Apostrophe: ' or '', valueOutput: 'Apostrophe: \' or \'' },
  { valueInput: 'Slash: / or /', valueOutput: 'Slash: / or /' },
  { valueInput: 'Less than: &lt; Greater than: &gt;', valueOutput: 'Less than: < Greater than: >' },
  { valueInput: 'Non-breaking space: &nbsp;', valueOutput: 'Non-breaking space:  ' },
  { valueInput: 'Quote: &quot;', valueOutput: 'Quote: "' },
  { valueInput: 'No entities here', valueOutput: 'No entities here' },
  { valueInput: '', valueOutput: '' },
  { valueInput: 'Multiple entities: &amp;&lt;&gt;&quot;', valueOutput: 'Multiple entities: &<>"' },
  { valueInput: null, valueOutput: null },
  { valueInput: undefined, valueOutput: undefined },
];

export const hashCodeCases = [
  { valueInput: 'hello', valueOutput: '99162322' }, // Valor conhecido do hash
  { valueInput: 'world', valueOutput: '113318802' },
  { valueInput: '12345', valueOutput: '46792755' },
  { valueInput: '', valueOutput: '0' }, // Caso de string vazia
  { valueInput: 'a', valueOutput: '97' }, // Código ASCII de 'a'
  { valueInput: 'abc', valueOutput: '96354' }, // Valor hash de 'abc'
  { valueInput: 'Hello, World!', valueOutput: '1498789909' }, // Teste com caracteres especiais
  { valueInput: '😊', valueOutput: '1772909' }, // Emoji (unicode)
  { valueInput: 'Same input, same hash', valueOutput: '-895136796' }, // Consistência do hash
  { valueInput: 'Same input, same hash', valueOutput: '-895136796' }, // Repetição do caso anterior
];

export const getBooleanValueCases = [
  { valueInput: 'true', defaultValue: false, valueOutput: true },
  { valueInput: 'false', defaultValue: true, valueOutput: false },
  { valueInput: 'S', defaultValue: false, valueOutput: true }, // "S" considerado como true
  { valueInput: 'N', defaultValue: true, valueOutput: false }, // "N" considerado como false
  { valueInput: true, defaultValue: false, valueOutput: true }, // Valor booleano verdadeiro
  { valueInput: false, defaultValue: true, valueOutput: false }, // Valor booleano falso
  { valueInput: 'yes', defaultValue: false, valueOutput: false }, // String não reconhecida
  { valueInput: 'no', defaultValue: true, valueOutput: true }, // String não reconhecida
  { valueInput: '', defaultValue: true, valueOutput: true }, // String vazia
  { valueInput: undefined, defaultValue: false, valueOutput: false }, // Valor indefinido
  { valueInput: null, defaultValue: true, valueOutput: true }, // Valor nulo
];

export const padStartCases = [
  { valueInput: { str: '123', len: 6, pad: '0' }, valueOutput: '000123' }, // Preenchimento com '0'
  { valueInput: { str: 'test', len: 8, pad: ' ' }, valueOutput: '    test' }, // Preenchimento com espaços
  { valueInput: { str: '', len: 5, pad: '*' }, valueOutput: '*****' }, // String vazia
  { valueInput: { str: 'short', len: 3, pad: '-' }, valueOutput: 'short' }, // Nenhum preenchimento necessário
  { valueInput: { str: undefined, len: 4, pad: '#' }, valueOutput: '####' }, // `undefined` tratado como string vazia
  { valueInput: { str: null, len: 4, pad: '0' }, valueOutput: '0000' }, // `null` tratado como string vazia
  { valueInput: { str: 'pad', len: 10, pad: '-' }, valueOutput: '-------pad' }, // Preenchimento com um caractere repetido
  { valueInput: { str: '42', len: 5, pad: 'abc' }, valueOutput: 'abc42' }, // Preenchimento com sequência que excede o tamanho necessário
  { valueInput: { str: 'exact', len: 5, pad: '*' }, valueOutput: 'exact' }, // Comprimento já igual ao esperado
  { valueInput: { str: '', len: 0, pad: '-' }, valueOutput: '' }, // Comprimento zero, sem preenchimento
];

export const padEndCases = [
  { valueInput: { str: '123', len: 6, pad: '0' }, valueOutput: '123000' }, // Preenchimento com '0'
  { valueInput: { str: 'test', len: 8, pad: ' ' }, valueOutput: 'test    ' }, // Preenchimento com espaços
  { valueInput: { str: '', len: 5, pad: '*' }, valueOutput: '*****' }, // String vazia
  { valueInput: { str: 'short', len: 3, pad: '-' }, valueOutput: 'short' }, // Nenhum preenchimento necessário
  { valueInput: { str: undefined, len: 4, pad: '#' }, valueOutput: '####' }, // `undefined` tratado como string vazia
  { valueInput: { str: null, len: 4, pad: '0' }, valueOutput: '0000' }, // `null` tratado como string vazia
  { valueInput: { str: 'pad', len: 10, pad: '-' }, valueOutput: 'pad-------' }, // Preenchimento com um caractere repetido
  { valueInput: { str: '42', len: 5, pad: 'abc' }, valueOutput: '42abc' }, // Preenchimento com sequência que excede o tamanho necessário
  { valueInput: { str: 'exact', len: 5, pad: '*' }, valueOutput: 'exact' }, // Comprimento já igual ao esperado
  { valueInput: { str: '', len: 0, pad: '-' }, valueOutput: '' }, // Comprimento zero, sem preenchimento
];

export const compareCases = [
  { valueInput: { a: undefined, b: undefined }, valueOutput: 0 }, // Ambos undefined
  { valueInput: { a: undefined, b: null }, valueOutput: 1 }, // a undefined, b null
  { valueInput: { a: null, b: undefined }, valueOutput: -1 }, // a null, b undefined
  { valueInput: { a: null, b: null }, valueOutput: 0 }, // Ambos null
  { valueInput: { a: 'apple', b: undefined }, valueOutput: -1 }, // b undefined
  { valueInput: { a: undefined, b: 'banana' }, valueOutput: 1 }, // a undefined
  { valueInput: { a: 'apple', b: null }, valueOutput: -1 }, // b null
  { valueInput: { a: null, b: 'banana' }, valueOutput: 1 }, // a null
  { valueInput: { a: 'apple', b: 'banana' }, valueOutput: -1 }, // Comparação lexical
  { valueInput: { a: 'banana', b: 'apple' }, valueOutput: 1 }, // Comparação lexical invertida
  { valueInput: { a: 'apple', b: 'apple' }, valueOutput: 0 }, // Strings iguais
  { valueInput: { a: 'Apple', b: 'apple' }, valueOutput: 1 }, // Case-sensitive (lexical)
  { valueInput: { a: '123', b: '456' }, valueOutput: -1 }, // Strings numéricas
  { valueInput: { a: '', b: 'non-empty' }, valueOutput: -1 }, // String vazia comparada com não vazia
  { valueInput: { a: 'non-empty', b: '' }, valueOutput: 1 }, // Não vazia comparada com vazia
];

export const toCamelCaseCases = [
  { valueInput: 'hello_world', valueOutput: 'helloWorld' }, // Underscore
  { valueInput: 'hello-world', valueOutput: 'helloWorld' }, // Hífen
  { valueInput: 'hello world', valueOutput: 'helloWorld' }, // Espaço
  { valueInput: 'HelloWorld', valueOutput: 'helloworld' }, // Primeiro caractere maiúsculo
  { valueInput: 'helloWorld', valueOutput: 'helloWorld' }, // Já em camelCase
  { valueInput: 'hello.world', valueOutput: 'hello.world' }, // Contém ponto (não altera)
  { valueInput: 'HELLO_WORLD', valueOutput: 'helloWorld' }, // Uppercase e underscore
  { valueInput: 'multiple words-separated_hyphen', valueOutput: 'multipleWordsSeparatedHyphen' }, // Vários separadores
  { valueInput: 'CamelCaseAlready', valueOutput: 'camelcasealready' }, // Já em camelCase com primeiro caractere maiúsculo
  { valueInput: '', valueOutput: '' }, // String vazia
  { valueInput: null, valueOutput: '' }, // Valor nulo
  { valueInput: undefined, valueOutput: '' }, // Valor indefinido
  { valueInput: 'simple', valueOutput: 'simple' }, // Palavra única em minúsculo
  { valueInput: 'PascalCase', valueOutput: 'pascalcase' }, // PascalCase para camelCase
];

export const toPascalCaseCases = [
  { valueInput: 'hello_world', valueOutput: 'Helloworld' }, // Underscore
  { valueInput: 'hello-world', valueOutput: 'Helloworld' }, // Hífen
  { valueInput: 'hello world', valueOutput: 'HelloWorld' }, // Espaço
  { valueInput: 'HelloWorld', valueOutput: 'Helloworld' }, // Já em PascalCase
  { valueInput: 'helloWorld', valueOutput: 'Helloworld' }, // camelCase para PascalCase
  { valueInput: 'hello.world', valueOutput: 'Hello.world' }, // Contém ponto (não altera)
  { valueInput: 'HELLO_WORLD', valueOutput: 'Helloworld' }, // Uppercase e underscore
  { valueInput: 'multiple words-separated_hyphen', valueOutput: 'MultipleWordsseparatedhyphen' }, // Vários separadores
  { valueInput: 'camelCaseAlready', valueOutput: 'Camelcasealready' }, // camelCase para PascalCase
  { valueInput: '', valueOutput: '' }, // String vazia
  { valueInput: null, valueOutput: '' }, // Valor nulo
  { valueInput: undefined, valueOutput: '' }, // Valor indefinido
  { valueInput: 'simple', valueOutput: 'Simple' }, // Palavra única em minúsculo
  { valueInput: 'PascalCase', valueOutput: 'Pascalcase' }, // Já em PascalCase
];

export const toSnakeCaseCases = [
  { valueInput: 'helloWorld', valueOutput: 'helloworld' }, // camelCase para snake_case
  { valueInput: 'HelloWorld', valueOutput: 'helloworld' }, // PascalCase para snake_case
  { valueInput: 'hello-world', valueOutput: 'hello_world' }, // Hífen para underscore
  { valueInput: 'hello world', valueOutput: 'hello_world' }, // Espaço para underscore
  { valueInput: 'hello_world', valueOutput: 'hello_world' }, // Já em snake_case (sem alterações)
  { valueInput: 'HELLO_WORLD', valueOutput: 'hello_world' }, // Tudo maiúsculo para minúsculo
  { valueInput: 'multipleWordsSeparated-Hyphen', valueOutput: 'multiplewordsseparated_hyphen' }, // Mistura de espaços e hífen
  { valueInput: 'CamelCaseAlready', valueOutput: 'camelcasealready' }, // PascalCase para snake_case
  { valueInput: 'simple', valueOutput: 'simple' }, // Palavra única em minúsculo (sem alterações)
  { valueInput: 'PascalCase', valueOutput: 'pascalcase' }, // PascalCase para snake_case
  { valueInput: '', valueOutput: '' }, // String vazia
  { valueInput: null, valueOutput: '' }, // Valor nulo
  { valueInput: undefined, valueOutput: '' }, // Valor indefinido
  { valueInput: 'hello.world', valueOutput: 'hello.world' }, // Contém ponto (não altera)
];

export const toKebabCaseCases = [
  { valueInput: 'helloWorld', valueOutput: 'hello-world' }, // camelCase para kebab-case
  { valueInput: 'HelloWorld', valueOutput: 'hello-world' }, // PascalCase para kebab-case
  { valueInput: 'hello_world', valueOutput: 'hello-world' }, // Underscore para hífen
  { valueInput: 'hello world', valueOutput: 'hello-world' }, // Espaço para hífen
  { valueInput: 'hello-world', valueOutput: 'hello-world' }, // Já em kebab-case (sem alterações)
  { valueInput: 'HELLO_WORLD', valueOutput: 'hello-world' }, // Tudo maiúsculo para minúsculo com underscore
  { valueInput: 'multipleWordsSeparated_Hyphen', valueOutput: 'multiple-words-separated-hyphen' }, // Mistura de espaços e underscore
  { valueInput: 'CamelCaseAlready', valueOutput: 'camel-case-already' }, // PascalCase para kebab-case
  { valueInput: 'simple', valueOutput: 'simple' }, // Palavra única em minúsculo (sem alterações)
  { valueInput: 'PascalCase', valueOutput: 'pascal-case' }, // PascalCase para kebab-case
  { valueInput: '', valueOutput: '' }, // String vazia
  { valueInput: null, valueOutput: '' }, // Valor nulo
  { valueInput: undefined, valueOutput: '' }, // Valor indefinido
  { valueInput: 'hello.world', valueOutput: 'hello.world' }, // Contém ponto (não altera)
];

export const formatBytesCases = [
  { valueInput: 0, valueOutput: '0B' }, // Zero bytes
  { valueInput: 1, valueOutput: '1B' }, // 1 byte
  { valueInput: 512, valueOutput: '512B' }, // Menos que 1KB
  { valueInput: 1023, valueOutput: '1023B' }, // Ainda em bytes
  { valueInput: 1024, valueOutput: '1KB' }, // Exatamente 1KB
  { valueInput: 1536, valueOutput: '1.5KB' }, // 1.5KB
  { valueInput: 1048576, valueOutput: '1MB' }, // Exatamente 1MB
  { valueInput: 1572864, valueOutput: '1.5MB' }, // 1.5MB
  { valueInput: 1073741824, valueOutput: '1GB' }, // Exatamente 1GB
  { valueInput: 1610612736, valueOutput: '1.5GB' }, // 1.5GB
  { valueInput: 1099511627776, valueOutput: '1099511627776B' }, // Acima de GB (mantém em B)
  { valueInput: -1024, valueOutput: '-1024B' }, // Valor negativo (mantém em B)
  { valueInput: NaN, valueOutput: 'NaNundefined' }, // Valor inválido
  { valueInput: null, valueOutput: 'undefinedB' }, // Valor nulo tratado como NaN
  { valueInput: undefined, valueOutput: 'NaNundefined' }, // Valor indefinido tratado como NaN
];

export const prettyPrecisionCases = [
  { valueInput: '100.00', valueOutput: '100' }, // Remove todos os zeros desnecessários
  { valueInput: '123.4500', valueOutput: '123.45' }, // Remove zeros à direita após a vírgula
  { valueInput: '0.900', valueOutput: '0.9' }, // Remove zeros à direita após a vírgula
  { valueInput: '5.10', valueOutput: '5.1' }, // Remove último zero, mantém decimal
  { valueInput: '42.0', valueOutput: '42' }, // Remove ".0" quando não há outra decimal relevante
  { valueInput: '3.14159000', valueOutput: '3.14159' }, // Mantém parte decimal relevante
  { valueInput: '0.000', valueOutput: '0' }, // Apenas zeros devem resultar em "0"
  { valueInput: '250', valueOutput: '250' }, // Número inteiro não muda
  { valueInput: '999.999', valueOutput: '999.999' }, // Nenhum zero extra, mantém como está
  { valueInput: '100.', valueOutput: '100' }, // Remove ponto final se não houver decimal
  { valueInput: '.500', valueOutput: '.5' }, // Adiciona zero antes do ponto se necessário
  { valueInput: '0.', valueOutput: '0' }, // Remove ponto final solitário
  { valueInput: '123.456789000', valueOutput: '123.456789' }, // Mantém casas decimais relevantes
  { valueInput: '0.0', valueOutput: '0' }, // Remove ".0" de zero
  { valueInput: '', valueOutput: '' }, // String vazia permanece vazia
];

export const isCaseableCases = [
  { valueInput: 'hello', valueOutput: true }, // Apenas minúsculas
  { valueInput: 'HELLO', valueOutput: true }, // Apenas maiúsculas
  { valueInput: 'Hello', valueOutput: true }, // Mistura de maiúsculas e minúsculas
  { valueInput: 'hElLo', valueOutput: true }, // Alternância de maiúsculas e minúsculas
  { valueInput: '12345', valueOutput: false }, // Apenas números
  { valueInput: '123ABC', valueOutput: true }, // Números e letras maiúsculas
  { valueInput: '123abc', valueOutput: true }, // Números e letras minúsculas
  { valueInput: '123aBc', valueOutput: true }, // Mistura de números e letras caseáveis
  { valueInput: '!@#$%^&*()', valueOutput: false }, // Apenas caracteres especiais
  { valueInput: 'hello_world', valueOutput: true }, // Contém underscore mas tem letras
  { valueInput: 'HELLO-WORLD', valueOutput: true }, // Contém hífen mas tem letras
  { valueInput: '', valueOutput: false }, // String vazia
  { valueInput: ' ', valueOutput: false }, // Apenas espaço
  { valueInput: null, valueOutput: false }, // Valor nulo
  { valueInput: undefined, valueOutput: false }, // Valor indefinido
];

export const isLowerCaseCases = [
  { valueInput: 'hello', valueOutput: true }, // Apenas minúsculas
  { valueInput: 'HELLO', valueOutput: false }, // Apenas maiúsculas
  { valueInput: 'Hello', valueOutput: true }, // Primeira maiúscula, restante minúscula TODO: REAVALIAR
  { valueInput: 'hElLo', valueOutput: true }, // Alternância de maiúsculas e minúsculas TODO: REAVALIAR
  { valueInput: 'hello world', valueOutput: true }, // Minúsculas com espaço
  { valueInput: 'hello_world', valueOutput: true }, // Minúsculas com underscore
  { valueInput: 'hello-world', valueOutput: true }, // Minúsculas com hífen
  { valueInput: '12345', valueOutput: false }, // Apenas números
  { valueInput: '123abc', valueOutput: true }, // Números e letras minúsculas
  { valueInput: '123ABC', valueOutput: false }, // Números e letras maiúsculas
  { valueInput: '!@#$%^&*()', valueOutput: false }, // Apenas caracteres especiais
  { valueInput: '', valueOutput: false }, // String vazia
  { valueInput: ' ', valueOutput: false }, // Apenas espaço
  { valueInput: null, valueOutput: false }, // Valor nulo
  { valueInput: undefined, valueOutput: false }, // Valor indefinido
];

export const getOppositeCaseCases = [
  { valueInput: 'hello', valueOutput: 'HELLO' }, // Minúsculas para maiúsculas
  { valueInput: 'HELLO', valueOutput: 'hello' }, // Maiúsculas para minúsculas
  { valueInput: 'Hello', valueOutput: 'HELLO' }, // Primeira maiúscula, restante minúscula → tudo minúsculo //TODO: ANALISAR
  { valueInput: 'hElLo', valueOutput: 'HELLO' }, // Alternância de maiúsculas e minúsculas → tudo minúsculo //TODO: ANALISAR
  { valueInput: 'hello world', valueOutput: 'HELLO WORLD' }, // Minúsculas com espaço → Maiúsculas
  { valueInput: 'HELLO WORLD', valueOutput: 'hello world' }, // Maiúsculas com espaço → Minúsculas
  { valueInput: 'hello_world', valueOutput: 'HELLO_WORLD' }, // Minúsculas com underscore → Maiúsculas
  { valueInput: 'HELLO_WORLD', valueOutput: 'hello_world' }, // Maiúsculas com underscore → Minúsculas
  { valueInput: 'hello-world', valueOutput: 'HELLO-WORLD' }, // Minúsculas com hífen → Maiúsculas
  { valueInput: 'HELLO-WORLD', valueOutput: 'hello-world' }, // Maiúsculas com hífen → Minúsculas
  { valueInput: '12345', valueOutput: '12345' }, // Apenas números (sem alteração)
  { valueInput: '123abc', valueOutput: '123ABC' }, // Números e letras minúsculas → Letras maiúsculas
  { valueInput: '123ABC', valueOutput: '123abc' }, // Números e letras maiúsculas → Letras minúsculas
  { valueInput: '!@#$%^&*()', valueOutput: '!@#$%^&*()' }, // Apenas caracteres especiais (sem alteração)
  { valueInput: '', valueOutput: '' }, // String vazia (sem alteração)
  { valueInput: ' ', valueOutput: ' ' }, // Apenas espaço (sem alteração)
  { valueInput: null, valueOutput: '' }, // Valor nulo tratado como string vazia
  { valueInput: undefined, valueOutput: '' }, // Valor indefinido tratado como string vazia
];

export const getSpecialCharactersCases = [
  { valueInput: 'hello', valueOutput: [] }, // Nenhum caractere especial
  { valueInput: 'hello@world.com', valueOutput: ['@', '.'] }, // E-mail: captura '@' e '.'
  { valueInput: 'price: $100.00', valueOutput: [':', '$', '.'] }, // Preço: captura ':', '$' e '.'
  { valueInput: '50% discount!', valueOutput: ['%', '!'] }, // Captura '%' e '!'
  { valueInput: 'C:\\Users\\Admin', valueOutput: [':', '\\', '\\'] }, // Caminho do Windows: captura '\\'
  { valueInput: 'https://example.com', valueOutput: [':', '/', '/', '.'] }, // URL: captura ':', '/', '/', '.'
  { valueInput: 'filename.txt', valueOutput: ['.'] }, // Extensão de arquivo: captura '.'
  { valueInput: 'sum = a + b - c * d / e', valueOutput: ['=', '+', '-', '*', '/'] }, // Operadores matemáticos
  { valueInput: '#hashtag @user!', valueOutput: ['#', '@', '!'] }, // Hashtags e menções
  { valueInput: '(parentheses) & [brackets] {curly}', valueOutput: ['(', ')', '&', '[' ] }, // Captura parênteses e colchetes
  { valueInput: 'one_two-three', valueOutput: ['_', '-'] }, // Captura underscore e hífen
  { valueInput: 'email+alias@gmail.com', valueOutput: ['+', '@', '.'] }, // Captura '+' usado em e-mails
  { valueInput: 'a = "text" or \'char\'', valueOutput: ['=', '"', '"', "'", "'"] }, // Aspas duplas e simples
  { valueInput: '', valueOutput: [] }, // String vazia → Nenhum caractere especial
  { valueInput: '   ', valueOutput: [] }, // Apenas espaços → Nenhum caractere especial
  { valueInput: null, valueOutput: [] }, // Valor nulo tratado como string vazia
  { valueInput: undefined, valueOutput: [] }, // Valor indefinido tratado como string vazia
];

export const getArgumentNumberCases = [
  { valueInput: '42', valueOutput: 42 }, // Número inteiro válido
  { valueInput: '3.14', valueOutput: 3.14 }, // Número decimal válido
  { valueInput: '-100', valueOutput: -100 }, // Número negativo válido
  { valueInput: '0', valueOutput: 0 }, // Zero
  { valueInput: '', valueOutput: NaN }, // String vazia → NaN
  { valueInput: 'abc', valueOutput: NaN }, // String não numérica → NaN
  { valueInput: '123abc', valueOutput: NaN }, // Mistura de número e letras → NaN
  { valueInput: '   50   ', valueOutput: 50 }, // Número com espaços → Convertido corretamente
  { valueInput: '1e3', valueOutput: 1000 }, // Notação científica → 1000
  { valueInput: 'Infinity', valueOutput: Infinity }, // Infinity string → Infinity
  { valueInput: '-Infinity', valueOutput: -Infinity }, // -Infinity string → -Infinity
  { valueInput: null, valueOutput: NaN }, // Valor nulo → NaN
  { valueInput: undefined, valueOutput: NaN }, // Valor indefinido → NaN
];

export const highlightValueCases = [
  {
    valueInput: { argument: 'hello', matchFields: ['field1'], value: 'hello world', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "<span class='card-item__highlight'>hello</span> world"
  }, // Palavra encontrada e destacada
  {
    valueInput: { argument: 'world', matchFields: ['field1'], value: 'hello world', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "hello <span class='card-item__highlight'>world</span>"
  }, // Última palavra destacada
  {
    valueInput: { argument: 'lo', matchFields: ['field1'], value: 'hello world', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "hel<span class='card-item__highlight'>lo</span> world"
  }, // Destacando parte de uma palavra
  {
    valueInput: { argument: 'Hello', matchFields: ['field1'], value: 'hello world', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "<span class='card-item__highlight'>hello</span> world"
  }, // Case insensitive
  {
    valueInput: { argument: 'hello', matchFields: ['field1'], value: 'hello hello', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "<span class='card-item__highlight'>hello</span> hello"
  }, // Destacando palavras repetidas //TODO: analisar, pois não sabe lidar com esse cenário
  {
    valueInput: { argument: '123', matchFields: ['field1'], value: 'abc 123 def', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "abc <span class='card-item__highlight'>123</span> def"
  }, // Destacando número
  {
    valueInput: { argument: 'abc', matchFields: ['field2'], value: 'abc 123 def', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "<span class='card-item__highlight'>abc</span> 123 def"
  }, // Campo não corresponde, não há destaque
  {
    valueInput: { argument: 'abc', matchFields: ['field1'], value: 'abc 123 def', fieldMD: { fieldName: 'field1' }, forceMatch: true },
    valueOutput: "<span class='card-item__highlight'>abc</span> 123 def"
  }, // `forceMatch` ativado, destacando mesmo sem correspondência de campo
  {
    valueInput: { argument: 'abc', matchFields: ['field1'], value: 'ABC 123 def', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "<span class='card-item__highlight'>ABC</span> 123 def"
  }, // Case insensitive destaque
  {
    valueInput: { argument: '!', matchFields: ['field1'], value: 'hello!', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "hello!"
  }, // Caracteres especiais não são destacados
  {
    valueInput: { argument: '', matchFields: ['field1'], value: 'hello world', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "hello world"
  }, // Argumento vazio, sem destaque
  {
    valueInput: { argument: null, matchFields: ['field1'], value: 'hello world', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: "hello world"
  }, // `null` como argumento, sem destaque
  {
    valueInput: { argument: 'hello', matchFields: ['field1'], value: '', fieldMD: { fieldName: 'field1' }, forceMatch: false },
    valueOutput: ""
  }, // Valor vazio, sem destaque
];