Upload folder using huggingface_hub

.gitattributes

@@ -8,4 +8,3 @@
 
 gl/lib/*.diff -whitespace
 src/b2sum filter=lfs diff=lfs merge=lfs -text
-src/cat.bc filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -213,6 +213,7 @@
 /tests/factor/t[0-9][0-9].sh
 /tests/init.sh
 /tests/t?
+!/tests/tr/
 /tests/test-suite.log
 /tight-scope.mk
 ID

test_results_mull.txt

@@ -0,0 +1,665 @@
+program_name,function_name,build,test,mull_score,mull_total,mull_killed,mull_survived
+basenc,usage,True,True,33,6,2,4
+basenc,decode_ctx_finalize,True,True,87,8,7,1
+basenc,base64url_encode,True,True,100,1,1,0
+basenc,base64url_decode_ctx_wrapper,True,False,N/A,0,0,0
+basenc,base32hex_encode,False,False,N/A,0,0,0
+basenc,base32hex_decode_ctx_wrapper,True,True,57,21,12,9
+basenc,base16_encode,True,True,85,7,6,1
+basenc,base16_decode_ctx,True,True,85,28,24,4
+basenc,z85_encode,True,True,90,71,64,7
+basenc,z85_decode_ctx,True,True,91,71,65,6
+basenc,base2msbf_encode,True,False,N/A,0,0,0
+basenc,base2lsbf_encode,True,True,80,10,8,2
+basenc,base2lsbf_decode_ctx,True,True,91,23,21,2
+basenc,base2msbf_decode_ctx,True,True,91,24,22,2
+basenc,base58_length,True,True,73,19,14,5
+basenc,base58_encode_ctx,True,False,N/A,0,0,0
+basenc,base58_encode,True,False,N/A,0,0,0
+basenc,base58_encode_ctx_finalize,True,True,60,35,21,14
+basenc,base58_decode_ctx,True,True,75,24,18,6
+basenc,base58_decode,True,True,85,20,17,3
+basenc,base58_decode_ctx_finalize,True,True,63,71,45,26
+basenc,wrap_write,True,True,100,1,1,0
+basenc,finish_and_exit,True,False,N/A,0,0,0
+basenc,do_encode,True,True,88,27,24,3
+basenc,do_decode,True,False,N/A,0,0,0
+basename,usage,True,True,66,6,4,2
+basename,remove_suffix,True,True,87,8,7,1
+basename,perform_basename,True,True,81,11,9,2
+cat,usage,True,True,33,6,2,4
+cat,next_line_num,True,True,91,12,11,1
+cat,simple_cat,True,False,N/A,0,0,0
+cat,write_pending,True,True,83,6,5,1
+cat,cat,True,True,75,82,62,20
+cat,copy_cat,True,True,33,3,1,2
+chmod,mode_changed,True,True,100,1,1,0
+chmod,describe_change,True,False,N/A,0,0,0
+chmod,process_file,False,False,N/A,0,0,0
+chmod,process_files,False,False,N/A,0,0,0
+chmod,usage,True,True,60,5,3,2
+chown,usage,True,True,58,12,7,5
+comm,usage,True,True,N/A,0,0,0
+comm,writeline,True,False,N/A,0,0,0
+comm,check_order,False,False,N/A,0,0,0
+comm,compare_files,True,True,75,69,52,17
+cp,usage,True,True,42,7,3,4
+cp,re_protect,True,True,13,45,6,39
+cp,make_dir_parents_private,True,False,N/A,0,0,0
+cp,do_copy,True,True,28,251,72,179
+cp,cp_option_init,False,False,N/A,0,0,0
+cp,decode_preserve_arg,True,True,66,3,2,1
+csplit,interrupt_handler,True,True,46,13,6,7
+csplit,read_input,True,True,61,13,8,5
+csplit,keep_new_line,True,False,N/A,0,0,0
+csplit,record_line_starts,True,True,84,33,28,5
+csplit,free_buffer,True,True,0,3,0,3
+csplit,save_buffer,True,True,N/A,0,0,0
+csplit,load_buffer,True,True,74,59,44,15
+csplit,write_to_file,True,False,N/A,0,0,0
+csplit,handle_line_error,False,False,N/A,0,0,0
+csplit,process_line_count,True,False,N/A,0,0,0
+csplit,regexp_error,True,True,59,27,16,11
+csplit,process_regexp,True,True,66,154,103,51
+csplit,split_file,True,False,N/A,0,0,0
+csplit,create_output_file,True,True,75,16,12,4
+csplit,delete_all_files,True,True,58,12,7,5
+csplit,close_output_file,True,True,50,10,5,5
+csplit,save_line_to_file,True,True,100,1,1,0
+csplit,parse_repeat_count,False,False,N/A,0,0,0
+csplit,parse_patterns,True,True,70,60,42,18
+csplit,get_format_flags,True,True,100,1,1,0
+csplit,check_format_conv_type,True,True,100,1,1,0
+csplit,max_out,True,True,77,22,17,5
+csplit,usage,True,True,60,5,3,2
+cut,usage,True,True,50,6,3,3
+cut,cut_bytes,False,False,N/A,0,0,0
+cut,cut_fields,True,True,76,60,46,14
+cut,cut_file,False,False,N/A,0,0,0
+date,usage,True,True,60,5,3,2
+date,show_date_helper,True,True,69,13,9,4
+date,batch_convert,True,True,43,32,14,18
+dd,diagnose,True,False,N/A,0,0,0
+dd,usage,True,True,40,5,2,3
+dd,alloc_ibuf,True,True,55,18,10,8
+dd,alloc_obuf,True,True,40,5,2,3
+dd,print_xfer_stats,True,True,54,31,17,14
+dd,print_stats,True,True,40,30,12,18
+dd,install_signal_handlers,True,True,85,14,12,2
+dd,iclose,True,True,100,1,1,0
+dd,cleanup,True,False,N/A,0,0,0
+dd,process_signals,True,True,78,14,11,3
+dd,cache_round,True,True,80,10,8,2
+dd,invalidate_cache,True,True,41,41,17,24
+dd,iread,True,False,N/A,0,0,0
+dd,iread_fullblock,True,True,42,26,11,15
+dd,iwrite,True,True,45,35,16,19
+dd,write_output,True,False,N/A,0,0,0
+dd,ifdatasync,True,True,42,19,8,11
+dd,ifd_reopen,True,False,N/A,0,0,0
+dd,ifstat,True,True,66,6,4,2
+dd,ifsync,True,True,66,6,4,2
+dd,iftruncate,True,True,50,6,3,3
+dd,parse_symbols,True,True,100,1,1,0
+dd,parse_integer,False,False,N/A,0,0,0
+dd,scanargs,True,True,73,154,113,41
+dd,apply_translations,True,True,84,32,27,5
+dd,skip,True,False,N/A,0,0,0
+dd,advance_input_after_read_error,True,True,56,25,14,11
+dd,copy_simple,True,True,75,28,21,7
+dd,copy_with_block,True,True,86,15,13,2
+dd,copy_with_unblock,True,True,100,1,1,0
+dd,set_fd_flags,True,True,58,24,14,10
+dd,dd_copy,False,False,N/A,0,0,0
+dd,synchronize_output,True,False,N/A,0,0,0
+dircolors,usage,True,True,75,4,3,1
+dircolors,guess_shell_syntax,True,False,N/A,0,0,0
+dircolors,parse_line,True,True,100,1,1,0
+dircolors,append_quoted,True,False,N/A,0,0,0
+dircolors,append_entry,True,False,N/A,0,0,0
+dircolors,dc_parse_stream,True,True,75,70,53,17
+dircolors,dc_parse_file,True,True,55,29,16,13
+dirname,usage,True,True,80,5,4,1
+du,usage,True,False,N/A,0,0,0
+du,print_only_size,True,True,N/A,0,0,0
+du,print_size,True,False,N/A,0,0,0
+du,fill_mount_table,True,True,71,7,5,2
+du,mount_point_in_fts_cycle,False,False,N/A,0,0,0
+du,process_file,True,False,N/A,0,0,0
+du,du_files,True,False,N/A,0,0,0
+echo,usage,True,True,50,4,2,2
+echo,hextobin,True,True,N/A,0,0,0
+env,usage,True,True,50,6,3,3
+env,unset_envvars,True,True,100,1,1,0
+env,check_start_new_arg,True,True,75,20,15,5
+env,parse_split_string,True,True,72,58,42,16
+env,parse_signal_action_params,True,True,63,41,26,15
+env,reset_signal_handlers,True,True,78,19,15,4
+env,parse_block_signal_params,True,True,54,22,12,10
+env,set_signal_proc_mask,True,True,66,9,6,3
+env,list_signal_handling,True,True,66,12,8,4
+expand,usage,True,True,42,7,3,4
+expand,expand,True,False,N/A,0,0,0
+expr,mbs_logical_cspn,False,False,N/A,0,0,0
+expr,usage,True,True,60,5,3,2
+expr,printv,False,False,N/A,0,0,0
+expr,null,True,True,66,9,6,3
+expr,looks_like_integer,True,True,100,1,1,0
+expr,tostring,True,True,66,6,4,2
+expr,toarith,True,True,55,9,5,4
+expr,getsize,False,False,N/A,0,0,0
+expr,nextarg,True,True,100,1,1,0
+expr,trace,True,True,N/A,0,0,0
+factor,uuint,True,False,N/A,0,0,0
+factor,mp_limb_t,True,True,100,1,1,0
+factor,gcd2_odd,True,True,95,22,21,1
+factor,factor_insert_multiplicity,True,True,81,22,18,4
+factor,factor_insert_large,True,True,88,26,23,3
+factor,mpz_va_init,True,True,N/A,0,0,0
+factor,mpn_tdiv_qr,True,True,80,10,8,2
+factor,mp_factor_insert,False,False,N/A,0,0,0
+factor,divblock,True,True,74,27,20,7
+factor,factor_using_division,True,True,77,67,52,15
+factor,mp_finish_up_in_single,True,False,N/A,0,0,0
+factor,mp_factor_using_division,True,True,71,145,104,41
+factor,binv_limb,True,True,85,21,18,3
+factor,mulredc,True,True,89,28,25,3
+factor,mulredc2,True,True,83,37,31,6
+factor,prime_p,True,True,75,12,9,3
+factor,mp_prime_p,False,False,N/A,0,0,0
+factor,factor_using_pollard_rho,True,False,N/A,0,0,0
+factor,factor_using_pollard_rho2,False,False,N/A,0,0,0
+factor,mp_mulredc,True,True,88,43,38,5
+factor,mp_factor_using_pollard_rho,False,False,N/A,0,0,0
+factor,factor_up,False,False,N/A,0,0,0
+factor,mp_factor,True,True,60,271,165,106
+factor,strtouuint,True,True,100,1,1,0
+factor,lbuf_half_flush,True,True,90,11,10,1
+factor,lbuf_putnl,False,False,N/A,0,0,0
+factor,lbuf_putint_append,True,True,100,1,1,0
+factor,print_uuint,True,True,100,1,1,0
+factor,lbuf_putmpz,True,True,80,30,24,6
+factor,print_factors_single,False,False,N/A,0,0,0
+factor,print_factors,True,False,N/A,0,0,0
+factor,usage,True,True,75,4,3,1
+factor,do_stdin,True,False,N/A,0,0,0
+fmt,usage,True,True,33,6,2,4
+fmt,set_prefix,True,True,100,1,1,0
+fmt,fmt,False,False,N/A,0,0,0
+fmt,set_other_indent,True,True,100,1,1,0
+fmt,get_paragraph,True,True,71,113,81,32
+fmt,copy_rest,True,True,85,34,29,5
+fmt,get_line,True,True,86,50,43,7
+fmt,get_prefix,True,True,97,36,35,1
+fmt,get_space,True,True,100,1,1,0
+fmt,check_punctuation,True,True,85,7,6,1
+fmt,flush_paragraph,False,False,N/A,0,0,0
+fmt,fmt_paragraph,True,True,42,42,18,24
+fmt,base_cost,True,True,81,11,9,2
+fmt,line_cost,True,True,100,1,1,0
+fmt,put_line,True,True,80,42,34,8
+fmt,put_word,True,True,100,1,1,0
+fmt,put_space,True,True,100,1,1,0
+fold,usage,True,True,50,6,3,3
+fold,adjust_column,True,True,90,20,18,2
+fold,fold_file,True,True,72,66,48,18
+groups,usage,True,True,75,4,3,1
+head,usage,True,True,50,8,4,4
+head,diagnose_copy_fd_failure,True,True,N/A,0,0,0
+head,xwrite_stdout,True,False,N/A,0,0,0
+head,copy_fd,True,True,93,15,14,1
+head,elseek_diagnostic,True,True,100,1,1,0
+head,elide_tail_bytes_pipe,False,False,N/A,0,0,0
+head,elide_tail_bytes_file,True,True,46,73,34,39
+head,elide_tail_lines_pipe,True,False,N/A,0,0,0
+head,elide_tail_lines_seekable,True,True,81,54,44,10
+head,elide_tail_lines_file,True,False,N/A,0,0,0
+head,head_bytes,True,True,88,18,16,2
+head,head_lines,True,True,80,25,20,5
+head,head,True,True,56,141,80,61
+head,head_file,True,True,57,155,89,66
+id,usage,False,False,N/A,0,0,0
+id,print_user,True,True,100,1,1,0
+id,print_full_info,True,True,40,25,10,15
+id,print_stuff,True,True,13,44,6,38
+join,usage,True,True,75,4,3,1
+join,extract_field,True,True,57,7,4,3
+join,xfields,True,True,86,23,20,3
+join,freeline,False,False,N/A,0,0,0
+join,keycmp,True,True,100,1,1,0
+join,check_order,True,True,51,27,14,13
+join,get_line,True,False,N/A,0,0,0
+join,free_spareline,True,True,0,9,0,9
+join,getseq,True,False,N/A,0,0,0
+join,delseq,True,True,40,10,4,6
+join,prfield,True,True,66,3,2,1
+join,prfields,True,True,100,1,1,0
+join,prjoin,True,True,90,43,39,4
+join,join,True,False,N/A,0,0,0
+join,add_field,True,True,100,1,1,0
+join,string_to_join_field,True,True,81,11,9,2
+join,decode_field_spec,True,True,81,11,9,2
+join,add_field_list,True,True,83,18,15,3
+join,add_file_name,True,True,86,30,26,4
+kill,usage,True,True,33,6,2,4
+kill,list_signals,True,False,N/A,0,0,0
+kill,send_signals,True,True,81,11,9,2
+link,usage,True,True,75,4,3,1
+ln,atomic_link,True,True,100,1,1,0
+ln,do_link,True,True,53,95,51,44
+ln,usage,True,True,42,7,3,4
+logname,usage,True,True,75,4,3,1
+ls,dev_ino_push,True,True,100,1,1,0
+ls,dev_ino_pop,True,True,100,1,1,0
+ls,dired_dump_obstack,True,True,100,1,1,0
+ls,get_stat_btime,True,True,N/A,0,0,0
+ls,time_type_to_statx,False,False,N/A,0,0,0
+ls,calc_req_mask,True,True,100,1,1,0
+ls,do_statx,True,True,66,9,6,3
+ls,abmon_init,True,True,40,27,11,16
+ls,abformat_init,True,True,68,50,34,16
+ls,visit_dir,True,True,75,8,6,2
+ls,is_colored,True,True,100,1,1,0
+ls,set_normal_color,True,True,80,20,16,4
+ls,process_signals,True,False,N/A,0,0,0
+ls,signal_setup,True,True,85,21,18,3
+ls,decode_line_length,False,False,N/A,0,0,0
+ls,decode_switches,True,True,22,151,34,117
+ls,get_funky_string,False,False,N/A,0,0,0
+ls,known_term_type,True,True,87,8,7,1
+ls,parse_ls_color,True,False,N/A,0,0,0
+ls,getenv_quoting_style,False,False,N/A,0,0,0
+ls,queue_directory,True,True,25,4,1,3
+ls,print_dir,False,False,N/A,0,0,0
+ls,add_ignore_pattern,True,True,N/A,0,0,0
+ls,file_ignored,True,True,100,1,1,0
+ls,has_capability,True,True,100,1,1,0
+ls,clear_files,True,True,63,22,14,8
+ls,file_has_aclinfo_cache,True,False,N/A,0,0,0
+ls,has_capability_cache,True,True,37,8,3,5
+ls,gobble_file,True,True,50,74,37,37
+ls,extract_dirs_from_files,True,True,70,34,24,10
+ls,xstrcoll,True,True,100,1,1,0
+ls,update_current_files_info,True,True,61,31,19,12
+ls,sort_files,True,True,54,35,19,16
+ls,print_current_files,False,False,N/A,0,0,0
+ls,long_time_expected_width,True,True,72,11,8,3
+ls,format_user_or_group,True,True,91,12,11,1
+ls,print_long_format,True,False,N/A,0,0,0
+ls,quote_name_buf,True,True,60,45,27,18
+ls,quote_name_width,True,True,52,42,22,20
+ls,quote_name,True,False,N/A,0,0,0
+ls,print_name_with_quoting,True,True,50,55,28,27
+ls,prep_non_filename_text,False,False,N/A,0,0,0
+ls,print_file_name_and_frills,True,True,48,52,25,27
+ls,get_type_indicator,True,True,93,16,15,1
+ls,print_color_indicator,True,True,64,25,16,9
+ls,put_indicator,True,True,70,10,7,3
+ls,length_of_file_name_and_frills,True,True,87,24,21,3
+ls,print_many_per_line,True,False,N/A,0,0,0
+ls,print_horizontal,False,False,N/A,0,0,0
+ls,print_with_separator,True,True,61,52,32,20
+ls,indent,True,True,100,1,1,0
+ls,attach,True,True,100,1,1,0
+ls,init_column_info,True,True,72,25,18,7
+ls,calculate_columns,True,True,79,67,53,14
+ls,usage,True,True,50,6,3,3
+mkdir,usage,True,True,60,5,3,2
+mkdir,make_ancestor,True,False,N/A,0,0,0
+mkdir,process_dir,True,False,N/A,0,0,0
+mkfifo,usage,True,True,60,5,3,2
+mknod,usage,True,True,50,6,3,3
+mktemp,usage,True,True,75,4,3,1
+mv,rm_option_init,True,True,44,9,4,5
+mv,cp_option_init,False,False,N/A,0,0,0
+mv,do_move,True,False,N/A,0,0,0
+mv,usage,True,True,42,7,3,4
+nl,usage,True,True,50,6,3,3
+nl,build_type_arg,False,False,N/A,0,0,0
+nl,proc_text,True,True,N/A,0,0,0
+nl,check_section,True,True,84,13,11,2
+nl,process_file,True,True,81,16,13,3
+nl,nl_file,False,False,N/A,0,0,0
+nproc,usage,True,True,75,4,3,1
+nohup,usage,True,True,28,7,2,5
+numfmt,default_scale_base,True,True,N/A,0,0,0
+numfmt,suffix_power,True,True,N/A,0,0,0
+numfmt,powerld,True,True,100,1,1,0
+numfmt,expld,True,True,81,16,13,3
+numfmt,simple_round,True,False,N/A,0,0,0
+numfmt,simple_strtod_int,True,True,81,22,18,4
+numfmt,simple_strtod_float,True,True,79,43,34,9
+numfmt,simple_strtod_human,False,False,N/A,0,0,0
+numfmt,simple_strtod_fatal,True,True,100,1,1,0
+numfmt,double_to_human,True,True,77,67,52,15
+numfmt,unit_to_umax,True,True,70,17,12,5
+numfmt,usage,True,True,57,7,4,3
+numfmt,parse_format_string,True,False,N/A,0,0,0
+numfmt,parse_human_number,True,True,84,78,66,12
+numfmt,prepare_padded_number,True,True,72,96,70,26
+numfmt,print_padded_number,True,True,100,1,1,0
+numfmt,process_suffixed_number,True,True,76,90,69,21
+numfmt,is_utf8_charset,True,False,N/A,0,0,0
+numfmt,include_field,True,True,100,1,1,0
+numfmt,process_field,True,True,58,141,83,58
+numfmt,process_line,True,False,N/A,0,0,0
+od,usage,True,True,50,6,3,3
+od,dump_hexl_mode_trailer,True,True,100,1,1,0
+od,print_named_ascii,True,True,88,27,24,3
+od,print_ascii,True,True,90,21,19,2
+od,simple_strtoi,True,True,100,1,1,0
+od,ATTRIBUTE_NONNULL,True,True,88,9,8,1
+od,open_next_file,True,True,54,11,6,5
+od,check_and_close,True,True,62,8,5,3
+od,skip,True,True,63,41,26,15
+od,format_address_std,True,True,100,1,1,0
+od,write_block,True,True,70,20,14,6
+od,read_char,True,True,61,21,13,8
+od,read_block,True,False,N/A,0,0,0
+od,parse_old_offset,True,False,N/A,0,0,0
+od,dump,False,False,N/A,0,0,0
+od,dump_strings,True,True,71,66,47,19
+paste,collapse_escapes,True,True,66,3,2,1
+paste,paste_parallel,True,True,71,56,40,16
+paste,paste_serial,True,False,N/A,0,0,0
+paste,usage,True,True,50,6,3,3
+pathchk,usage,True,True,75,4,3,1
+pathchk,no_leading_hyphen,True,True,100,1,1,0
+pathchk,portable_chars_only,True,True,40,5,2,3
+pathchk,validate_file_name,True,True,60,41,25,16
+pr,cols_ready_to_print,True,True,100,1,1,0
+pr,first_last_page,True,True,100,1,1,0
+pr,getoptarg,True,True,66,15,10,5
+pr,init_parameters,True,True,75,41,31,10
+pr,init_fps,True,True,48,58,28,30
+pr,init_funcs,True,True,92,25,23,2
+pr,open_file,True,False,N/A,0,0,0
+pr,close_file,True,True,69,13,9,4
+pr,hold_file,True,True,85,7,6,1
+pr,reset_status,True,True,87,8,7,1
+pr,print_files,True,False,N/A,0,0,0
+pr,init_header,True,True,61,18,11,7
+pr,init_page,True,True,46,100,46,54
+pr,align_column,True,True,64,57,37,20
+pr,print_page,True,False,N/A,0,0,0
+pr,init_store_cols,True,False,N/A,0,0,0
+pr,store_columns,True,False,N/A,0,0,0
+pr,balance,True,True,100,1,1,0
+pr,store_char,True,True,100,1,1,0
+pr,add_line_number,True,True,100,1,1,0
+pr,pad_across_to,True,True,100,1,1,0
+pr,read_rest_of_line,True,True,76,21,16,5
+pr,skip_read,True,True,75,29,22,7
+pr,print_white_space,True,True,86,15,13,2
+pr,print_sep_string,True,True,80,36,29,7
+pr,print_char,True,True,78,23,18,5
+pr,skip_to_page,True,False,N/A,0,0,0
+pr,print_header,True,False,N/A,0,0,0
+pr,read_line,True,True,59,59,35,24
+pr,print_stored,True,True,78,47,37,10
+pr,char_to_clump,True,True,86,60,52,8
+pr,cleanup,True,True,0,5,0,5
+pr,usage,False,False,N/A,0,0,0
+printenv,usage,True,True,60,5,3,2
+printf,usage,True,True,60,5,3,2
+printf,verify_numeric,True,True,100,1,1,0
+printf,print_esc_char,True,True,N/A,0,0,0
+printf,print_esc,True,False,N/A,0,0,0
+printf,print_direc,True,True,62,8,5,3
+printf,get_curr_arg,True,True,93,29,27,2
+printf,print_formatted,False,False,N/A,0,0,0
+ptx,unescape_string,True,True,100,1,1,0
+ptx,compile_regex,True,False,N/A,0,0,0
+ptx,initialize_regex,False,False,N/A,0,0,0
+ptx,swallow_file_in_memory,True,True,100,1,1,0
+ptx,compare_words,True,True,66,27,18,9
+ptx,compare_occurs,True,True,80,21,17,4
+ptx,search_table,True,True,89,39,35,4
+ptx,digest_break_file,True,True,72,11,8,3
+ptx,digest_word_file,True,True,65,43,28,15
+ptx,find_occurs_in_text,True,True,73,92,68,24
+ptx,print_field,True,True,66,3,2,1
+ptx,fix_output_parameters,True,True,76,43,33,10
+ptx,define_all_fields,True,False,N/A,0,0,0
+ptx,output_one_roff_line,True,True,100,1,1,0
+ptx,output_one_tex_line,True,True,44,38,17,21
+ptx,output_one_dumb_line,True,False,N/A,0,0,0
+ptx,generate_all_output,True,False,N/A,0,0,0
+ptx,usage,True,True,50,6,3,3
+pwd,usage,True,True,60,5,3,2
+pwd,file_name_prepend,True,True,58,17,10,7
+pwd,find_dir_entry,True,False,N/A,0,0,0
+pwd,robust_getcwd,True,True,69,53,37,16
+readlink,usage,True,True,75,4,3,1
+realpath,usage,True,True,75,4,3,1
+realpath,path_prefix,True,True,100,1,1,0
+realpath,process_path,True,True,16,6,1,5
+rm,diagnose_leading_hyphen,True,True,87,8,7,1
+rm,usage,True,True,40,5,2,3
+rm,rm_option_init,True,True,20,10,2,8
+rmdir,errno_may_be_non_empty,True,True,N/A,0,0,0
+rmdir,remove_parents,True,True,87,16,14,2
+rmdir,usage,True,True,100,1,1,0
+seq,usage,False,False,N/A,0,0,0
+seq,scan_arg,False,False,N/A,0,0,0
+seq,print_numbers,False,False,N/A,0,0,0
+seq,incr_grows,False,False,N/A,0,0,0
+seq,seq_fast,False,False,N/A,0,0,0
+shred,usage,True,True,66,6,4,2
+shred,periodic_pattern,True,True,93,16,15,1
+shred,fillpattern,True,True,88,26,23,3
+shred,dosync,True,True,72,11,8,3
+shred,direct_mode,True,True,28,7,2,5
+shred,dorewind,True,True,80,5,4,1
+shred,dopass,True,True,30,113,35,78
+shred,genpattern,False,False,N/A,0,0,0
+shred,do_wipefd,False,False,N/A,0,0,0
+shred,wipefd,True,False,N/A,0,0,0
+shred,incname,False,False,N/A,0,0,0
+shred,wipename,True,False,N/A,0,0,0
+shred,wipefile,False,False,N/A,0,0,0
+shuf,usage,True,True,50,6,3,3
+shuf,input_from_argv,True,True,75,12,9,3
+shuf,input_size,True,True,100,1,1,0
+shuf,read_input_reservoir_sampling,False,False,N/A,0,0,0
+shuf,write_permuted_output_reservoir,True,False,N/A,0,0,0
+shuf,read_input,True,True,100,1,1,0
+shuf,write_permuted_lines,True,False,N/A,0,0,0
+shuf,write_permuted_numbers,True,True,88,9,8,1
+shuf,write_random_numbers,False,False,N/A,0,0,0
+shuf,write_random_lines,False,False,N/A,0,0,0
+sleep,usage,True,True,75,4,3,1
+sleep,apply_suffix,False,False,N/A,0,0,0
+sort,usage,True,True,42,7,3,4
+sort,reap,True,True,90,10,9,1
+sort,register_proc,True,True,80,5,4,1
+sort,delete_proc,True,True,100,1,1,0
+sort,exit_cleanup,True,True,N/A,0,0,0
+sort,xfclose,True,True,N/A,0,0,0
+sort,move_fd,True,True,100,1,1,0
+sort,posix_spawn_file_actions_move_fd,True,True,100,1,1,0
+sort,pipe_child,True,True,45,51,23,28
+sort,zaptemp,True,True,20,15,3,12
+sort,inittables,True,True,100,1,1,0
+sort,specify_nmerge,True,True,92,13,12,1
+sort,specify_sort_size,False,False,N/A,0,0,0
+sort,specify_nthreads,False,False,N/A,0,0,0
+sort,default_sort_size,True,True,0,29,0,29
+sort,sort_buffer_size,True,True,57,61,35,26
+sort,initbuf,True,True,88,9,8,1
+sort,fillbuf,True,True,49,63,31,32
+sort,traverse_raw_number,True,True,80,15,12,3
+sort,find_unit_order,True,True,75,24,18,6
+sort,human_numcompare,True,False,N/A,0,0,0
+sort,numcompare,True,True,53,13,7,6
+sort,general_numcompare,True,True,100,1,1,0
+sort,getmonth,True,True,90,31,28,3
+sort,link_libcrypto,True,True,N/A,0,0,0
+sort,random_md5_state_init,True,True,85,7,6,1
+sort,xstrxfrm,True,True,100,1,1,0
+sort,compare_random,True,True,62,56,35,21
+sort,mark_key,True,True,100,1,1,0
+sort,debug_key,True,False,N/A,0,0,0
+sort,default_key_compare,True,True,50,2,1,1
+sort,key_to_opts,True,True,100,1,1,0
+sort,key_warnings,True,False,N/A,0,0,0
+sort,keycompare,True,True,58,82,48,34
+sort,compare,True,True,92,25,23,2
+sort,write_line,True,True,64,28,18,10
+sort,check,True,True,50,90,45,45
+sort,open_input_files,True,True,76,13,10,3
+sort,mergefps,True,True,62,174,109,65
+sort,mergefiles,False,False,N/A,0,0,0
+sort,mergelines,True,False,N/A,0,0,0
+sort,sequential_sort,True,False,N/A,0,0,0
+sort,merge_tree_destroy,True,True,30,30,9,21
+sort,queue_init,True,True,30,13,4,9
+sort,write_unique,True,True,93,16,15,1
+sort,mergelines_node,True,True,84,57,48,9
+sort,queue_check_insert,True,True,55,18,10,8
+sort,queue_check_insert_parent,True,True,50,28,14,14
+sort,merge_loop,True,True,73,80,59,21
+sort,sortlines,True,True,69,165,114,51
+sort,avoid_trashing_input,False,False,N/A,0,0,0
+sort,check_inputs,True,False,N/A,0,0,0
+sort,check_output,True,True,83,6,5,1
+sort,merge,True,False,N/A,0,0,0
+sort,sort,True,False,N/A,0,0,0
+sort,insertkey,True,True,N/A,0,0,0
+sort,check_ordering_compatibility,True,True,28,21,6,15
+split,set_suffix_length,True,True,71,21,15,6
+split,usage,True,True,50,8,4,4
+split,copy_to_tmpfile,True,False,N/A,0,0,0
+split,input_file_size,True,False,N/A,0,0,0
+split,next_file_name,True,False,N/A,0,0,0
+split,create,True,True,75,69,52,17
+split,closeout,True,True,82,28,23,5
+split,cwrite,True,True,62,56,35,21
+split,bytes_split,False,False,N/A,0,0,0
+split,lines_split,True,False,N/A,0,0,0
+split,line_bytes_split,True,False,N/A,0,0,0
+split,lines_chunk_split,True,False,N/A,0,0,0
+split,bytes_chunk_extract,True,True,75,36,27,9
+split,ofile_open,True,True,63,19,12,7
+split,lines_rr,False,False,N/A,0,0,0
+split,parse_chunk,True,True,95,21,20,1
+stat,statfs,True,True,N/A,0,0,0
+stat,make_format,True,True,100,1,1,0
+stat,out_epoch_sec,True,False,N/A,0,0,0
+stat,out_file_context,True,True,71,7,5,2
+stat,print_statfs,True,True,90,11,10,1
+stat,out_mount_point,True,True,25,35,9,26
+stat,getenv_quoting_style,True,True,100,1,1,0
+stat,print_esc_char,True,True,N/A,0,0,0
+stat,format_code_offset,True,False,N/A,0,0,0
+stat,print_it,True,True,53,13,7,6
+stat,do_statfs,True,True,59,22,13,9
+stat,fmt_to_mask,True,True,N/A,0,0,0
+stat,format_to_mask,True,True,100,1,1,0
+stat,do_stat,True,True,45,37,17,20
+stat,get_birthtime,False,False,N/A,0,0,0
+stat,do_stat,True,True,43,39,17,22
+stat,print_stat,True,True,76,17,13,4
+stat,usage,False,False,N/A,0,0,0
+sync,usage,True,True,100,1,1,0
+sync,sync_arg,True,True,44,25,11,14
+tac,usage,True,True,66,6,4,2
+tac,output,True,True,100,1,1,0
+tac,tac_seekable,True,False,N/A,0,0,0
+tac,copy_to_temp,True,False,N/A,0,0,0
+tac,tac_nonseekable,True,False,N/A,0,0,0
+tac,tac_file,True,False,N/A,0,0,0
+tail,usage,False,False,N/A,0,0,0
+tail,xlseek,True,True,75,4,3,1
+tail,record_open_fd,True,True,78,14,11,3
+tail,xwrite_stdout,False,False,N/A,0,0,0
+tail,dump_remainder,True,True,80,25,20,5
+tail,file_lines,False,False,N/A,0,0,0
+tail,pipe_lines,True,True,81,43,35,8
+tail,pipe_bytes,True,True,80,45,36,9
+tail,start_bytes,True,True,83,18,15,3
+tail,start_lines,False,False,N/A,0,0,0
+tail,fremote,True,True,88,9,8,1
+tail,recheck,True,False,N/A,0,0,0
+tail,any_live_files,True,True,85,7,6,1
+tail,some_writers_exist,True,True,92,14,13,1
+tail,tail_forever,False,False,N/A,0,0,0
+tail,check_fspec,True,True,N/A,0,0,0
+tail,tail_forever_inotify,True,False,N/A,0,0,0
+tail,tail_bytes,True,False,N/A,0,0,0
+tail,tail_lines,True,True,69,130,90,40
+tail,tail_file,True,True,51,194,100,94
+tail,parse_obsolete_option,True,True,75,29,22,7
+tail,parse_options,True,False,N/A,0,0,0
+tail,ignore_fifo_and_pipe,True,True,92,13,12,1
+tee,usage,True,True,75,4,3,1
+tee,fail_output,True,True,66,6,4,2
+tee,tee_files,True,False,N/A,0,0,0
+test,binop,True,True,100,1,1,0
+test,term,True,False,N/A,0,0,0
+test,binary_operator,True,True,84,19,16,3
+test,unary_operator,True,False,N/A,0,0,0
+test,and,True,True,53,77,41,36
+test,or,True,True,46,60,28,32
+test,two_arguments,True,True,93,15,14,1
+test,three_arguments,True,True,66,102,68,34
+test,posixtest,True,True,68,106,73,33
+test,usage,True,True,50,4,2,2
+touch,touch,True,False,N/A,0,0,0
+touch,usage,True,True,60,5,3,2
+tr,usage,True,True,75,4,3,1
+tr,is_char_class_member,True,True,N/A,0,0,0
+tr,unquote,True,True,66,6,4,2
+tr,look_up_char_class,True,True,83,6,5,1
+tr,append_normal_char,True,True,100,1,1,0
+tr,append_range,True,True,70,10,7,3
+tr,append_char_class,True,True,90,10,9,1
+tr,append_repeated_char,True,True,100,1,1,0
+tr,append_equiv_class,True,True,100,1,1,0
+tr,find_closing_delim,True,True,80,10,8,2
+tr,find_bracketed_repeat,True,True,72,29,21,8
+tr,star_digits_closebracket,True,True,88,9,8,1
+tr,build_spec_list,True,True,77,119,92,27
+tr,get_next,True,True,92,26,24,2
+tr,card_of_complement,True,True,84,114,96,18
+tr,validate_case_classes,True,True,74,112,83,29
+tr,get_spec_stats,True,True,82,117,96,21
+tr,get_s2_spec_stats,True,True,78,87,68,19
+tr,string2_extend,True,True,77,122,95,27
+tr,homogeneous_spec_list,True,True,90,32,29,3
+tr,validate,True,True,73,184,135,49
+tr,squeeze_filter,True,True,86,43,37,6
+tr,read_and_delete,True,True,100,1,1,0
+tr,set_initialize,True,False,N/A,0,0,0
+true,usage,True,False,N/A,0,0,0
+truncate,usage,True,True,50,6,3,3
+truncate,do_ftruncate,True,True,70,31,22,9
+tsort,usage,True,True,60,5,3,2
+tsort,record_relation,True,True,100,1,1,0
+tsort,scan_zeros,True,True,100,1,1,0
+tsort,detect_loop,True,True,75,8,6,2
+tsort,recurse_tree,True,True,100,1,1,0
+tsort,tsort,True,True,81,66,54,12
+tty,usage,True,True,50,4,2,2
+uname,usage,False,False,N/A,0,0,0
+uname,print_element_env,True,True,100,1,1,0
+uname,decode_switches,False,False,N/A,0,0,0
+unexpand,usage,True,True,42,7,3,4
+unexpand,unexpand,False,False,N/A,0,0,0
+uniq,usage,True,True,33,6,2,4
+uniq,writeline,True,True,100,1,1,0
+uniq,check_file,True,False,N/A,0,0,0
+unlink,usage,True,True,75,4,3,1
+uptime,print_uptime,True,False,N/A,0,0,0
+uptime,uptime,True,False,N/A,0,0,0
+uptime,usage,True,True,57,7,4,3
+wc,avx2_supported,True,True,100,1,1,0
+wc,avx512_supported,True,True,0,1,0,1
+wc,usage,True,True,40,5,2,3
+wc,write_counts,True,True,100,1,1,0
+wc,wc_lines,True,True,67,28,19,9
+wc,wc,True,False,N/A,0,0,0
+wc,wc_file,True,True,43,60,26,34
+wc,compute_number_width,True,True,80,20,16,4
+whoami,usage,True,True,50,4,2,2
+yes,usage,True,True,75,4,3,1

tests/tr/tests_for_append_char_class.c

@@ -0,0 +1,221 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+
+/* The program under test has already included all its own headers
+   and defined all internal symbols (including append_char_class,
+   spec_init, append_normal_char, and the enums/types).
+   We only write tests that call into those. */
+
+/* Helpers */
+static void free_spec_list(struct Spec_list *list)
+{
+    if (!list || !list->head) return;
+    struct List_element *p = list->head;
+    while (p) {
+        struct List_element *next = p->next;
+        free(p);
+        p = next;
+    }
+    /* Don't leave dangling pointers in case caller reuses struct */
+    list->head = NULL;
+    list->tail = NULL;
+}
+
+static size_t count_nodes(const struct Spec_list *list)
+{
+    size_t n = 0;
+    if (!list || !list->head) return 0;
+    for (struct List_element const *p = list->head->next; p; p = p->next)
+        n++;
+    return n;
+}
+
+void setUp(void) {
+    /* No global setup needed */
+}
+
+void tearDown(void) {
+    /* No global teardown needed */
+}
+
+/* Test: invalid inputs should return false and not modify the list */
+void test_append_char_class_invalid_empty_len_zero(void)
+{
+    struct Spec_list list;
+    spec_init(&list);
+    struct List_element *old_tail = list.tail;
+
+    bool ok = append_char_class(&list, "x", 0);
+    TEST_ASSERT_FALSE(ok);
+    TEST_ASSERT_EQUAL_PTR(old_tail, list.tail);
+    TEST_ASSERT_NULL(old_tail->next);
+
+    free_spec_list(&list);
+}
+
+void test_append_char_class_invalid_names_do_not_change_list(void)
+{
+    const char *invalids[] = {
+        "Alpha",   /* wrong case */
+        "alph",    /* too short */
+        "alpha ",  /* trailing space included in len */
+        " xdigit", /* leading space */
+        "xdigitu", /* extra char */
+        "lowercase", /* not a class */
+        "",        /* empty string with len=0 tested separately but also here */
+    };
+    size_t n = sizeof(invalids)/sizeof(invalids[0]);
+
+    for (size_t i = 0; i < n; i++) {
+        struct Spec_list list;
+        spec_init(&list);
+        struct List_element *old_tail = list.tail;
+
+        const char *s = invalids[i];
+        size_t len = strlen(s);
+        bool ok = append_char_class(&list, s, len);
+        TEST_ASSERT_FALSE(ok);
+        TEST_ASSERT_EQUAL_PTR(old_tail, list.tail);
+        TEST_ASSERT_NULL(old_tail->next);
+
+        free_spec_list(&list);
+    }
+}
+
+/* Validate that each known good class name appends correctly with the
+   expected enum value and node type. */
+void test_append_char_class_each_valid_name(void)
+{
+    struct { const char *name; enum Char_class id; } cases[] = {
+        {"alnum",  CC_ALNUM},
+        {"alpha",  CC_ALPHA},
+        {"blank",  CC_BLANK},
+        {"cntrl",  CC_CNTRL},
+        {"digit",  CC_DIGIT},
+        {"graph",  CC_GRAPH},
+        {"lower",  CC_LOWER},
+        {"print",  CC_PRINT},
+        {"punct",  CC_PUNCT},
+        {"space",  CC_SPACE},
+        {"upper",  CC_UPPER},
+        {"xdigit", CC_XDIGIT},
+    };
+
+    for (size_t i = 0; i < sizeof(cases)/sizeof(cases[0]); i++) {
+        struct Spec_list list;
+        spec_init(&list);
+
+        bool ok = append_char_class(&list, cases[i].name, strlen(cases[i].name));
+        TEST_ASSERT_TRUE(ok);
+        TEST_ASSERT_NOT_NULL(list.head);
+        TEST_ASSERT_NOT_NULL(list.head->next);
+        TEST_ASSERT_EQUAL_PTR(list.tail, list.head->next);
+
+        struct List_element *node = list.head->next;
+        TEST_ASSERT_EQUAL_INT(RE_CHAR_CLASS, node->type);
+        TEST_ASSERT_EQUAL_INT(cases[i].id, node->u.char_class);
+        TEST_ASSERT_NULL(node->next);
+        TEST_ASSERT_EQUAL_UINT32(1, count_nodes(&list));
+
+        free_spec_list(&list);
+    }
+}
+
+/* Multiple appends should chain correctly and preserve order */
+void test_append_char_class_multiple_appends_chain_and_tail_updates(void)
+{
+    struct Spec_list list;
+    spec_init(&list);
+
+    bool ok1 = append_char_class(&list, "digit", strlen("digit"));
+    TEST_ASSERT_TRUE(ok1);
+    struct List_element *first = list.head->next;
+    TEST_ASSERT_NOT_NULL(first);
+    TEST_ASSERT_EQUAL_INT(RE_CHAR_CLASS, first->type);
+    TEST_ASSERT_EQUAL_INT(CC_DIGIT, first->u.char_class);
+    TEST_ASSERT_EQUAL_PTR(list.tail, first);
+
+    bool ok2 = append_char_class(&list, "space", strlen("space"));
+    TEST_ASSERT_TRUE(ok2);
+    struct List_element *second = first->next;
+    TEST_ASSERT_NOT_NULL(second);
+    TEST_ASSERT_EQUAL_PTR(list.tail, second);
+    TEST_ASSERT_EQUAL_INT(RE_CHAR_CLASS, second->type);
+    TEST_ASSERT_EQUAL_INT(CC_SPACE, second->u.char_class);
+    TEST_ASSERT_NULL(second->next);
+
+    TEST_ASSERT_EQUAL_UINT32(2, count_nodes(&list));
+
+    free_spec_list(&list);
+}
+
+/* Appending after an existing non-class node should still work. */
+void test_append_char_class_after_existing_other_node(void)
+{
+    struct Spec_list list;
+    spec_init(&list);
+
+    /* Add a normal character node first via provided helper. */
+    append_normal_char(&list, (unsigned char)'X');
+    TEST_ASSERT_EQUAL_UINT32(1, count_nodes(&list));
+
+    bool ok = append_char_class(&list, "upper", strlen("upper"));
+    TEST_ASSERT_TRUE(ok);
+
+    /* Verify structure: head -> normal_char('X') -> char_class(CC_UPPER) */
+    struct List_element *n1 = list.head->next;
+    struct List_element *n2 = n1 ? n1->next : NULL;
+
+    TEST_ASSERT_NOT_NULL(n1);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, n1->type);
+    TEST_ASSERT_EQUAL_UINT8('X', n1->u.normal_char);
+
+    TEST_ASSERT_NOT_NULL(n2);
+    TEST_ASSERT_EQUAL_INT(RE_CHAR_CLASS, n2->type);
+    TEST_ASSERT_EQUAL_INT(CC_UPPER, n2->u.char_class);
+    TEST_ASSERT_EQUAL_PTR(list.tail, n2);
+    TEST_ASSERT_NULL(n2->next);
+
+    TEST_ASSERT_EQUAL_UINT32(2, count_nodes(&list));
+
+    free_spec_list(&list);
+}
+
+/* Invalid when length doesn't exactly match the class name */
+void test_append_char_class_len_mismatch_fails(void)
+{
+    struct Spec_list list;
+    spec_init(&list);
+    struct List_element *old_tail = list.tail;
+
+    const char *name = "alphaX";
+    /* Pass only len for "alpha" substring but pointer points to full string. */
+    bool ok = append_char_class(&list, name, 6); /* "alphaX" length -> should fail */
+    TEST_ASSERT_FALSE(ok);
+    TEST_ASSERT_EQUAL_PTR(old_tail, list.tail);
+    TEST_ASSERT_NULL(old_tail->next);
+
+    /* Now pass len for exact "alpha" but pointer advanced so the slice is exact */
+    ok = append_char_class(&list, name, 5); /* substring "alpha"; however strcmp uses len and compares exact against known names */
+    TEST_ASSERT_TRUE(ok);
+    TEST_ASSERT_NOT_NULL(list.head->next);
+    TEST_ASSERT_EQUAL_INT(RE_CHAR_CLASS, list.head->next->type);
+    TEST_ASSERT_EQUAL_INT(CC_ALPHA, list.head->next->u.char_class);
+
+    free_spec_list(&list);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+
+    RUN_TEST(test_append_char_class_invalid_empty_len_zero);
+    RUN_TEST(test_append_char_class_invalid_names_do_not_change_list);
+    RUN_TEST(test_append_char_class_each_valid_name);
+    RUN_TEST(test_append_char_class_multiple_appends_chain_and_tail_updates);
+    RUN_TEST(test_append_char_class_after_existing_other_node);
+    RUN_TEST(test_append_char_class_len_mismatch_fails);
+
+    return UNITY_END();
+}

tests/tr/tests_for_append_equiv_class.c

@@ -0,0 +1,140 @@
+#include "../../unity/unity.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+/* The program under test includes this file after defining all internal
+   structures and functions, so we can use Spec_list, List_element,
+   RE_EQUIV_CLASS, and spec_init/append_equiv_class directly. */
+
+/* Test fixture state */
+static struct Spec_list list_under_test;
+
+static void free_spec_list(struct Spec_list *lst) {
+    if (!lst || !lst->head) return;
+    struct List_element *p = lst->head;
+    while (p) {
+        struct List_element *next = p->next;
+        free(p);
+        p = next;
+    }
+    lst->head = NULL;
+    lst->tail = NULL;
+}
+
+void setUp(void) {
+    spec_init(&list_under_test);
+}
+
+void tearDown(void) {
+    free_spec_list(&list_under_test);
+}
+
+/* Helper to count elements in the list (excluding dummy head) */
+static size_t count_elements(struct Spec_list *lst) {
+    size_t n = 0;
+    struct List_element *p = lst->head ? lst->head->next : NULL;
+    while (p) { ++n; p = p->next; }
+    return n;
+}
+
+void test_append_equiv_class_len_one_basic(void) {
+    /* Append a single-character equivalence class 'A' */
+    const char *c = "A";
+    struct List_element *old_head = list_under_test.head;
+
+    bool ok = append_equiv_class(&list_under_test, c, 1);
+    TEST_ASSERT_TRUE(ok);
+
+    /* Verify list structure */
+    TEST_ASSERT_NOT_NULL(list_under_test.head);
+    TEST_ASSERT_EQUAL_PTR(old_head, list_under_test.head); /* head unchanged */
+    TEST_ASSERT_NOT_NULL(list_under_test.head->next);
+
+    struct List_element *first = list_under_test.head->next;
+    TEST_ASSERT_EQUAL_INT(RE_EQUIV_CLASS, first->type);
+    TEST_ASSERT_EQUAL_UINT8((unsigned char)'A', first->u.equiv_code);
+    TEST_ASSERT_NULL(first->next);
+    TEST_ASSERT_EQUAL_PTR(first, list_under_test.tail);
+
+    TEST_ASSERT_EQUAL_UINT(1, count_elements(&list_under_test));
+}
+
+void test_append_equiv_class_len_zero_noop(void) {
+    const char *ptr = "X"; /* content irrelevant since len=0 */
+    struct List_element *old_tail = list_under_test.tail;
+    struct List_element *old_next = list_under_test.head->next;
+
+    bool ok = append_equiv_class(&list_under_test, ptr, 0);
+    TEST_ASSERT_FALSE(ok);
+
+    /* Ensure list unchanged */
+    TEST_ASSERT_EQUAL_PTR(old_tail, list_under_test.tail);
+    TEST_ASSERT_EQUAL_PTR(old_next, list_under_test.head->next);
+    TEST_ASSERT_EQUAL_UINT(0, count_elements(&list_under_test));
+}
+
+void test_append_equiv_class_len_gt_one_noop(void) {
+    const char *ptr = "BC"; /* len=2 invalid */
+    struct List_element *old_tail = list_under_test.tail;
+    struct List_element *old_next = list_under_test.head->next;
+
+    bool ok = append_equiv_class(&list_under_test, ptr, 2);
+    TEST_ASSERT_FALSE(ok);
+
+    TEST_ASSERT_EQUAL_PTR(old_tail, list_under_test.tail);
+    TEST_ASSERT_EQUAL_PTR(old_next, list_under_test.head->next);
+    TEST_ASSERT_EQUAL_UINT(0, count_elements(&list_under_test));
+}
+
+void test_append_equiv_class_appends_multiple_and_chains(void) {
+    const char *x = "x";
+    const char *y = "y";
+
+    bool ok1 = append_equiv_class(&list_under_test, x, 1);
+    TEST_ASSERT_TRUE(ok1);
+    struct List_element *first = list_under_test.head->next;
+    TEST_ASSERT_NOT_NULL(first);
+    TEST_ASSERT_EQUAL_INT(RE_EQUIV_CLASS, first->type);
+    TEST_ASSERT_EQUAL_UINT8((unsigned char)'x', first->u.equiv_code);
+    TEST_ASSERT_NULL(first->next);
+
+    bool ok2 = append_equiv_class(&list_under_test, y, 1);
+    TEST_ASSERT_TRUE(ok2);
+
+    struct List_element *second = first->next;
+    TEST_ASSERT_NOT_NULL(second);
+    TEST_ASSERT_EQUAL_INT(RE_EQUIV_CLASS, second->type);
+    TEST_ASSERT_EQUAL_UINT8((unsigned char)'y', second->u.equiv_code);
+    TEST_ASSERT_NULL(second->next);
+
+    TEST_ASSERT_EQUAL_PTR(second, list_under_test.tail);
+    TEST_ASSERT_EQUAL_UINT(2, count_elements(&list_under_test));
+}
+
+void test_append_equiv_class_allows_nul_character(void) {
+    char zero = '\0';
+    bool ok = append_equiv_class(&list_under_test, &zero, 1);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *elem = list_under_test.head->next;
+    TEST_ASSERT_NOT_NULL(elem);
+    TEST_ASSERT_EQUAL_INT(RE_EQUIV_CLASS, elem->type);
+    TEST_ASSERT_EQUAL_UINT8((unsigned char)0, elem->u.equiv_code);
+    TEST_ASSERT_NULL(elem->next);
+    TEST_ASSERT_EQUAL_PTR(elem, list_under_test.tail);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+
+    RUN_TEST(test_append_equiv_class_len_one_basic);
+    RUN_TEST(test_append_equiv_class_len_zero_noop);
+    RUN_TEST(test_append_equiv_class_len_gt_one_noop);
+    RUN_TEST(test_append_equiv_class_appends_multiple_and_chains);
+    RUN_TEST(test_append_equiv_class_allows_nul_character);
+
+    return UNITY_END();
+}

tests/tr/tests_for_append_normal_char.c

@@ -0,0 +1,148 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+
+/* The following types and functions are declared in the program source:
+ * - struct Spec_list, struct List_element
+ * - enum Range_element_type with RE_NORMAL_CHAR
+ * - void spec_init(struct Spec_list*)
+ * - static void append_normal_char(struct Spec_list*, unsigned char)
+ */
+
+static void assert_node_is_char(struct List_element *node, unsigned char expected)
+{
+    TEST_ASSERT_NOT_NULL(node);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, node->type);
+    TEST_ASSERT_EQUAL_UINT8(expected, node->u.normal_char);
+}
+
+void setUp(void) {
+    /* No global state to set for these tests. */
+}
+
+void tearDown(void) {
+    /* We intentionally do not free nodes, since the test process ends. */
+}
+
+void test_append_normal_char_single(void)
+{
+    struct Spec_list list;
+    spec_init(&list);
+
+    struct List_element *orig_head = list.head;
+    struct List_element *orig_tail = list.tail;
+
+    TEST_ASSERT_NOT_NULL(orig_head);
+    TEST_ASSERT_NOT_NULL(orig_tail);
+    TEST_ASSERT_EQUAL_PTR(orig_head, orig_tail);
+    TEST_ASSERT_NULL(list.head->next);
+
+    unsigned char ch = (unsigned char)'A';
+    append_normal_char(&list, ch);
+
+    /* head is unchanged, but now points to first element */
+    TEST_ASSERT_EQUAL_PTR(orig_head, list.head);
+    TEST_ASSERT_NOT_NULL(list.head->next);
+
+    /* tail should have advanced to new node */
+    TEST_ASSERT_NOT_EQUAL(orig_tail, list.tail);
+    TEST_ASSERT_EQUAL_PTR(orig_tail->next, list.tail);
+
+    /* new tail node is a normal char with value 'A' and is terminal */
+    assert_node_is_char(list.tail, ch);
+    TEST_ASSERT_NULL(list.tail->next);
+}
+
+void test_append_normal_char_multiple_order_and_linking(void)
+{
+    struct Spec_list list;
+    spec_init(&list);
+
+    const unsigned char seq[] = { 'A', 'B', 'C' };
+    for (size_t i = 0; i < sizeof(seq); i++)
+        append_normal_char(&list, seq[i]);
+
+    /* Traverse and verify order and types */
+    struct List_element *n = list.head->next;
+    TEST_ASSERT_NOT_NULL(n);
+
+    for (size_t i = 0; i < sizeof(seq); i++) {
+        assert_node_is_char(n, seq[i]);
+        if (i + 1 < sizeof(seq)) {
+            TEST_ASSERT_NOT_NULL(n->next);
+            n = n->next;
+        } else {
+            /* Last node */
+            TEST_ASSERT_NULL(n->next);
+            TEST_ASSERT_EQUAL_PTR(n, list.tail);
+        }
+    }
+}
+
+void test_append_normal_char_handles_zero_and_uchar_max(void)
+{
+    struct Spec_list list;
+    spec_init(&list);
+
+    unsigned char c0 = (unsigned char)0;
+    unsigned char cmax = (unsigned char)UCHAR_MAX;
+
+    append_normal_char(&list, c0);
+    append_normal_char(&list, cmax);
+
+    struct List_element *first = list.head->next;
+    struct List_element *second = first ? first->next : NULL;
+
+    assert_node_is_char(first, c0);
+    TEST_ASSERT_NOT_NULL(second);
+    assert_node_is_char(second, cmax);
+    TEST_ASSERT_EQUAL_PTR(second, list.tail);
+    TEST_ASSERT_NULL(list.tail->next);
+}
+
+void test_append_normal_char_many_appends_integrity(void)
+{
+    struct Spec_list list;
+    spec_init(&list);
+
+    /* Append a sequence of 100 bytes cycling through 0..255 */
+    const size_t count = 100;
+    unsigned char last = 0;
+    for (size_t i = 0; i < count; i++) {
+        unsigned char v = (unsigned char)(i & 0xFF);
+        append_normal_char(&list, v);
+        last = v;
+    }
+
+    /* Verify count and last value by traversal */
+    size_t seen = 0;
+    struct List_element *n = list.head->next;
+    for (; n; n = n->next) {
+        /* For the first few items, verify order exactly */
+        if (seen < 10) {
+            unsigned char expected = (unsigned char)(seen & 0xFF);
+            assert_node_is_char(n, expected);
+        }
+        seen++;
+        if (!n->next) {
+            /* Tail reached */
+            TEST_ASSERT_EQUAL_PTR(n, list.tail);
+            assert_node_is_char(n, last);
+        }
+    }
+    TEST_ASSERT_EQUAL_size_t(count, seen);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_append_normal_char_single);
+    RUN_TEST(test_append_normal_char_multiple_order_and_linking);
+    RUN_TEST(test_append_normal_char_handles_zero_and_uchar_max);
+    RUN_TEST(test_append_normal_char_many_appends_integrity);
+    return UNITY_END();
+}

tests/tr/tests_for_append_range.c

@@ -0,0 +1,152 @@
+#include "../../unity/unity.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Unity setup/teardown */
+void setUp(void) {
+  /* Setup code here, or leave empty */
+}
+void tearDown(void) {
+  /* Cleanup code here, or leave empty */
+}
+
+/* Helper to free a Spec_list allocated via spec_init and append_* helpers */
+static void free_spec_list(struct Spec_list *list) {
+  if (!list) return;
+  struct List_element *p = list->head;
+  while (p) {
+    struct List_element *n = p->next;
+    free(p);
+    p = n;
+  }
+  list->head = NULL;
+  list->tail = NULL;
+}
+
+/* Tests */
+void test_append_range_basic(void) {
+  struct Spec_list list;
+  spec_init(&list);
+
+  bool ok = append_range(&list, (unsigned char)'a', (unsigned char)'d');
+  TEST_ASSERT_TRUE(ok);
+
+  /* After first append, head->next should be the new node and tail should point to it */
+  TEST_ASSERT_NOT_NULL(list.head->next);
+  TEST_ASSERT_EQUAL_PTR(list.tail, list.head->next);
+  TEST_ASSERT_EQUAL_INT(RE_RANGE, list.tail->type);
+  TEST_ASSERT_EQUAL_UINT8('a', list.tail->u.range.first_char);
+  TEST_ASSERT_EQUAL_UINT8('d', list.tail->u.range.last_char);
+  TEST_ASSERT_NULL(list.tail->next);
+
+  free_spec_list(&list);
+}
+
+void test_append_range_singleton_allowed(void) {
+  struct Spec_list list;
+  spec_init(&list);
+
+  bool ok = append_range(&list, (unsigned char)'x', (unsigned char)'x');
+  TEST_ASSERT_TRUE(ok);
+  TEST_ASSERT_NOT_NULL(list.head->next);
+  TEST_ASSERT_EQUAL_PTR(list.tail, list.head->next);
+  TEST_ASSERT_EQUAL_INT(RE_RANGE, list.tail->type);
+  TEST_ASSERT_EQUAL_UINT8('x', list.tail->u.range.first_char);
+  TEST_ASSERT_EQUAL_UINT8('x', list.tail->u.range.last_char);
+
+  free_spec_list(&list);
+}
+
+void test_append_range_reverse_no_modification(void) {
+  struct Spec_list list;
+  spec_init(&list);
+  struct List_element *orig_tail = list.tail; /* should be head */
+
+  bool ok = append_range(&list, (unsigned char)'z', (unsigned char)'a');
+  TEST_ASSERT_FALSE(ok);
+
+  /* Ensure list unchanged: no new node, tail unchanged */
+  TEST_ASSERT_NULL(list.head->next);
+  TEST_ASSERT_EQUAL_PTR(orig_tail, list.tail);
+
+  free_spec_list(&list);
+}
+
+void test_append_range_multiple_appends_linking(void) {
+  struct Spec_list list;
+  spec_init(&list);
+
+  bool ok1 = append_range(&list, (unsigned char)'a', (unsigned char)'b');
+  TEST_ASSERT_TRUE(ok1);
+  struct List_element *first = list.head->next;
+  TEST_ASSERT_NOT_NULL(first);
+  TEST_ASSERT_EQUAL_INT(RE_RANGE, first->type);
+  TEST_ASSERT_EQUAL_UINT8('a', first->u.range.first_char);
+  TEST_ASSERT_EQUAL_UINT8('b', first->u.range.last_char);
+
+  bool ok2 = append_range(&list, (unsigned char)'0', (unsigned char)'3');
+  TEST_ASSERT_TRUE(ok2);
+  struct List_element *second = list.tail; /* tail should now be second */
+  TEST_ASSERT_NOT_NULL(second);
+  TEST_ASSERT_EQUAL_PTR(first->next, second);
+  TEST_ASSERT_EQUAL_INT(RE_RANGE, second->type);
+  TEST_ASSERT_EQUAL_UINT8('0', second->u.range.first_char);
+  TEST_ASSERT_EQUAL_UINT8('3', second->u.range.last_char);
+  TEST_ASSERT_NULL(second->next);
+
+  free_spec_list(&list);
+}
+
+void test_append_range_after_normal_char_tail_update(void) {
+  struct Spec_list list;
+  spec_init(&list);
+
+  /* Create a prior normal element using helper */
+  append_normal_char(&list, (unsigned char)'Q');
+  struct List_element *normal = list.tail;
+  TEST_ASSERT_NOT_NULL(normal);
+  TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, normal->type);
+  TEST_ASSERT_EQUAL_UINT8('Q', normal->u.normal_char);
+
+  bool ok = append_range(&list, (unsigned char)'m', (unsigned char)'p');
+  TEST_ASSERT_TRUE(ok);
+  struct List_element *range_node = list.tail;
+
+  TEST_ASSERT_EQUAL_PTR(normal->next, range_node);
+  TEST_ASSERT_EQUAL_INT(RE_RANGE, range_node->type);
+  TEST_ASSERT_EQUAL_UINT8('m', range_node->u.range.first_char);
+  TEST_ASSERT_EQUAL_UINT8('p', range_node->u.range.last_char);
+  TEST_ASSERT_NULL(range_node->next);
+
+  free_spec_list(&list);
+}
+
+void test_append_range_full_byte_range(void) {
+  struct Spec_list list;
+  spec_init(&list);
+
+  bool ok = append_range(&list, (unsigned char)0, (unsigned char)UCHAR_MAX);
+  TEST_ASSERT_TRUE(ok);
+  TEST_ASSERT_NOT_NULL(list.head->next);
+  TEST_ASSERT_EQUAL_PTR(list.tail, list.head->next);
+  TEST_ASSERT_EQUAL_INT(RE_RANGE, list.tail->type);
+  TEST_ASSERT_EQUAL_UINT8(0, list.tail->u.range.first_char);
+  TEST_ASSERT_EQUAL_UINT8((unsigned char)UCHAR_MAX, list.tail->u.range.last_char);
+
+  free_spec_list(&list);
+}
+
+int main(void) {
+  UNITY_BEGIN();
+  RUN_TEST(test_append_range_basic);
+  RUN_TEST(test_append_range_singleton_allowed);
+  RUN_TEST(test_append_range_reverse_no_modification);
+  RUN_TEST(test_append_range_multiple_appends_linking);
+  RUN_TEST(test_append_range_after_normal_char_tail_update);
+  RUN_TEST(test_append_range_full_byte_range);
+  return UNITY_END();
+}

tests/tr/tests_for_append_repeated_char.c

@@ -0,0 +1,174 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <limits.h>
+#include <stdio.h>
+
+/* Unity hooks */
+void setUp(void) {
+  /* Setup code here, or leave empty */
+}
+void tearDown(void) {
+  /* Cleanup code here, or leave empty */
+}
+
+/* Helper to free a Spec_list created with spec_init and appended nodes.
+   The program allocates with xmalloc which is compatible with free(). */
+static void free_spec_list(struct Spec_list *s) {
+  if (!s) return;
+  struct List_element *p = s->head;
+  while (p) {
+    struct List_element *next = p->next;
+    free(p);
+    p = next;
+  }
+  s->head = s->tail = NULL;
+}
+
+/* Test that appending to a fresh Spec_list creates a single repeated-char node
+   with correct type, fields, and linkages. */
+static void test_append_repeated_char_single_basic(void) {
+  struct Spec_list s;
+  spec_init(&s);
+
+  /* Before append: head exists, tail == head, and head->next == NULL. */
+  TEST_ASSERT_NOT_NULL(s.head);
+  TEST_ASSERT_EQUAL_PTR(s.head, s.tail);
+  TEST_ASSERT_NULL(s.head->next);
+
+  append_repeated_char(&s, (unsigned char)'x', (count)5);
+
+  /* After append: head->next == tail, a single node with correct values. */
+  TEST_ASSERT_NOT_NULL(s.head->next);
+  TEST_ASSERT_EQUAL_PTR(s.head->next, s.tail);
+  TEST_ASSERT_NULL(s.tail->next);
+  TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, s.tail->type);
+  TEST_ASSERT_EQUAL_UINT8('x', s.tail->u.repeated_char.the_repeated_char);
+  TEST_ASSERT_EQUAL_UINT64((uint64_t)5, (uint64_t)s.tail->u.repeated_char.repeat_count);
+
+  free_spec_list(&s);
+}
+
+/* Test that appending after existing nodes correctly links and updates tail. */
+static void test_append_repeated_char_appends_after_existing(void) {
+  struct Spec_list s;
+  spec_init(&s);
+
+  append_normal_char(&s, (unsigned char)'A'); /* First node */
+  struct List_element *first_tail = s.tail;
+
+  append_repeated_char(&s, (unsigned char)'b', (count)2); /* Second node */
+  struct List_element *second = s.tail;
+
+  TEST_ASSERT_NOT_NULL(first_tail->next);
+  TEST_ASSERT_EQUAL_PTR(second, first_tail->next);
+  TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, second->type);
+  TEST_ASSERT_EQUAL_UINT8('b', second->u.repeated_char.the_repeated_char);
+  TEST_ASSERT_EQUAL_UINT64((uint64_t)2, (uint64_t)second->u.repeated_char.repeat_count);
+
+  append_repeated_char(&s, (unsigned char)'c', (count)1); /* Third node */
+  struct List_element *third = s.tail;
+
+  TEST_ASSERT_EQUAL_PTR(third, second->next);
+  TEST_ASSERT_NULL(third->next);
+  TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, third->type);
+  TEST_ASSERT_EQUAL_UINT8('c', third->u.repeated_char.the_repeated_char);
+  TEST_ASSERT_EQUAL_UINT64((uint64_t)1, (uint64_t)third->u.repeated_char.repeat_count);
+
+  free_spec_list(&s);
+}
+
+/* Test get_next() traversal for a single repeated char with repeat_count > 0. */
+static void test_append_repeated_char_get_next_semantics_nonzero(void) {
+  struct Spec_list s;
+  spec_init(&s);
+
+  append_repeated_char(&s, (unsigned char)'Z', (count)3);
+
+  s.state = BEGIN_STATE;
+  int c;
+
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT('Z', c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT('Z', c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT('Z', c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT(-1, c);
+
+  free_spec_list(&s);
+}
+
+/* Test get_next() traversal skips a repeated char with repeat_count == 0. */
+static void test_append_repeated_char_get_next_semantics_zero(void) {
+  struct Spec_list s;
+  spec_init(&s);
+
+  append_normal_char(&s, (unsigned char)'A');
+  append_repeated_char(&s, (unsigned char)'X', (count)0); /* should produce no output */
+  append_normal_char(&s, (unsigned char)'B');
+
+  s.state = BEGIN_STATE;
+
+  int c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT('A', c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT('B', c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT(-1, c);
+
+  free_spec_list(&s);
+}
+
+/* Test that NUL (0) as the repeated character is handled and produced. */
+static void test_append_repeated_char_handles_nul_char(void) {
+  struct Spec_list s;
+  spec_init(&s);
+
+  append_repeated_char(&s, (unsigned char)0x00, (count)2);
+  append_normal_char(&s, (unsigned char)'C');
+
+  s.state = BEGIN_STATE;
+
+  int c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT(0, c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT(0, c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT('C', c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT(-1, c);
+
+  free_spec_list(&s);
+}
+
+/* Test that large repeat_count values are stored correctly without iteration. */
+static void test_append_repeated_char_stores_large_count(void) {
+  struct Spec_list s;
+  spec_init(&s);
+
+  /* Don't iterate this count; just verify it is stored. */
+  count large = (count)123456789; /* well within REPEAT_COUNT_MAXIMUM */
+  append_repeated_char(&s, (unsigned char)'Q', large);
+
+  TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, s.tail->type);
+  TEST_ASSERT_EQUAL_UINT8('Q', s.tail->u.repeated_char.the_repeated_char);
+  TEST_ASSERT_EQUAL_UINT64((uint64_t)large, (uint64_t)s.tail->u.repeated_char.repeat_count);
+
+  free_spec_list(&s);
+}
+
+int main(void) {
+  UNITY_BEGIN();
+
+  RUN_TEST(test_append_repeated_char_single_basic);
+  RUN_TEST(test_append_repeated_char_appends_after_existing);
+  RUN_TEST(test_append_repeated_char_get_next_semantics_nonzero);
+  RUN_TEST(test_append_repeated_char_get_next_semantics_zero);
+  RUN_TEST(test_append_repeated_char_handles_nul_char);
+  RUN_TEST(test_append_repeated_char_stores_large_count);
+
+  return UNITY_END();
+}

tests/tr/tests_for_build_spec_list.c

@@ -0,0 +1,395 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+/* We rely on internal helpers from the program source: 
+   - spec_init
+   - unquote
+   - es_free
+   - build_spec_list
+   and data types/enums/structs defined in the TU. */
+
+/* Local helper to free a Spec_list allocated by spec_init and populated by build_spec_list. */
+static void tests_free_spec_list(struct Spec_list *sl)
+{
+    if (!sl || !sl->head) return;
+    struct List_element *p = sl->head;
+    while (p) {
+        struct List_element *n = p->next;
+        free(p);
+        p = n;
+    }
+    sl->head = sl->tail = NULL;
+}
+
+/* Convenience wrapper to unquote a C string into E_string. Returns true on success. */
+static bool tests_make_es(const char *in, struct E_string *es)
+{
+    return unquote(in, es);
+}
+
+void setUp(void) {
+    /* empty */
+}
+
+void tearDown(void) {
+    /* empty */
+}
+
+static void test_build_spec_list_normal_chars(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("abc", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('a', p->u.normal_char);
+
+    p = p->next; TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('b', p->u.normal_char);
+
+    p = p->next; TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('c', p->u.normal_char);
+
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_range_ok(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("a-c", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_RANGE, p->type);
+    TEST_ASSERT_EQUAL_UINT8('a', p->u.range.first_char);
+    TEST_ASSERT_EQUAL_UINT8('c', p->u.range.last_char);
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_range_reverse_invalid(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("z-a", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_FALSE(ok);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_char_class_digit(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[:digit:]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_CHAR_CLASS, p->type);
+    TEST_ASSERT_EQUAL_INT(CC_DIGIT, p->u.char_class);
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_char_class_invalid(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[:foo:]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_FALSE(ok);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_equiv_class_single_char(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[=A=]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_EQUIV_CLASS, p->type);
+    TEST_ASSERT_EQUAL_UINT8('A', p->u.equiv_code);
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_equiv_class_multi_char_invalid(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[=AB=]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_FALSE(ok);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_repeated_char_with_count_decimal(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[x*5]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('x', p->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64(5, p->u.repeated_char.repeat_count);
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_repeated_char_with_count_octal(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[A*010]", &es)); /* 010(octal) == 8 */
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('A', p->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64(8, p->u.repeated_char.repeat_count);
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_repeated_char_no_count_indefinite(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[y*]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('y', p->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64(0, p->u.repeated_char.repeat_count);
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_mixed_range_and_repeat(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("a-d[y*3]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_RANGE, p->type);
+    TEST_ASSERT_EQUAL_UINT8('a', p->u.range.first_char);
+    TEST_ASSERT_EQUAL_UINT8('d', p->u.range.last_char);
+
+    p = p->next; TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('y', p->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64(3, p->u.repeated_char.repeat_count);
+
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_escaped_dash_is_literal(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    /* The input a\-b produces 'a', '-', 'b' with '-' marked as escaped. */
+    TEST_ASSERT_TRUE(tests_make_es("a\\-b", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('a', p->u.normal_char);
+
+    p = p->next; TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('-', p->u.normal_char);
+
+    p = p->next; TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('b', p->u.normal_char);
+
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_equiv_inner_char_is_escaped_bracket(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    /* [=\]=] should be recognized as an equivalence class for ']' */
+    TEST_ASSERT_TRUE(tests_make_es("[=\\]=]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_EQUIV_CLASS, p->type);
+    TEST_ASSERT_EQUAL_UINT8(']', p->u.equiv_code);
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_brackets_without_construct_are_literals(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[ab]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_TRUE(ok);
+
+    struct List_element *p = sl.head->next;
+    TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('[', p->u.normal_char);
+
+    p = p->next; TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('a', p->u.normal_char);
+
+    p = p->next; TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8('b', p->u.normal_char);
+
+    p = p->next; TEST_ASSERT_NOT_NULL(p);
+    TEST_ASSERT_EQUAL_INT(RE_NORMAL_CHAR, p->type);
+    TEST_ASSERT_EQUAL_UINT8(']', p->u.normal_char);
+
+    TEST_ASSERT_NULL(p->next);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+static void test_build_spec_list_repeat_invalid_count_string(void)
+{
+    struct Spec_list sl = {0};
+    struct E_string es = {0};
+
+    spec_init(&sl);
+    TEST_ASSERT_TRUE(tests_make_es("[A*xyz]", &es));
+
+    bool ok = build_spec_list(&es, &sl);
+    TEST_ASSERT_FALSE(ok);
+
+    es_free(&es);
+    tests_free_spec_list(&sl);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_build_spec_list_normal_chars);
+    RUN_TEST(test_build_spec_list_range_ok);
+    RUN_TEST(test_build_spec_list_range_reverse_invalid);
+    RUN_TEST(test_build_spec_list_char_class_digit);
+    RUN_TEST(test_build_spec_list_char_class_invalid);
+    RUN_TEST(test_build_spec_list_equiv_class_single_char);
+    RUN_TEST(test_build_spec_list_equiv_class_multi_char_invalid);
+    RUN_TEST(test_build_spec_list_repeated_char_with_count_decimal);
+    RUN_TEST(test_build_spec_list_repeated_char_with_count_octal);
+    RUN_TEST(test_build_spec_list_repeated_char_no_count_indefinite);
+    RUN_TEST(test_build_spec_list_mixed_range_and_repeat);
+    RUN_TEST(test_build_spec_list_escaped_dash_is_literal);
+    RUN_TEST(test_build_spec_list_equiv_inner_char_is_escaped_bracket);
+    RUN_TEST(test_build_spec_list_brackets_without_construct_are_literals);
+    RUN_TEST(test_build_spec_list_repeat_invalid_count_string);
+    return UNITY_END();
+}

tests/tr/tests_for_card_of_complement.c

@@ -0,0 +1,114 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* We rely on internal functions/types from the included tr source:
+   - struct Spec_list
+   - void spec_init(struct Spec_list *)
+   - bool parse_str(char const *, struct Spec_list *)
+   - int card_of_complement(struct Spec_list *)
+   - N_CHARS enum value
+*/
+
+static struct Spec_list make_spec(const char *s)
+{
+    struct Spec_list spec;
+    spec_init(&spec);
+    bool ok = parse_str(s, &spec);
+    TEST_ASSERT_TRUE_MESSAGE(ok, "parse_str failed for input spec");
+    return spec;
+}
+
+void setUp(void) {
+    /* No global state to set for these tests */
+}
+
+void tearDown(void) {
+    /* No teardown needed */
+}
+
+/* Empty spec: complement should be all characters */
+void test_card_of_complement_empty(void)
+{
+    struct Spec_list spec = make_spec("");
+    int got = card_of_complement(&spec);
+    TEST_ASSERT_EQUAL_INT(N_CHARS, got);
+}
+
+/* Single normal character */
+void test_card_of_complement_single_char(void)
+{
+    struct Spec_list spec = make_spec("A");
+    int got = card_of_complement(&spec);
+    TEST_ASSERT_EQUAL_INT(N_CHARS - 1, got);
+}
+
+/* Simple range a-z (26 characters) */
+void test_card_of_complement_range_az(void)
+{
+    struct Spec_list spec = make_spec("a-z");
+    int got = card_of_complement(&spec);
+    TEST_ASSERT_EQUAL_INT(N_CHARS - 26, got);
+}
+
+/* Full byte range \000-\377 should cover all 256 characters */
+void test_card_of_complement_full_range(void)
+{
+    struct Spec_list spec = make_spec("\\000-\\377");
+    int got = card_of_complement(&spec);
+    TEST_ASSERT_EQUAL_INT(0, got);
+}
+
+/* Character class [:digit:] (10 characters) */
+void test_card_of_complement_class_digit(void)
+{
+    struct Spec_list spec = make_spec("[:digit:]");
+    int got = card_of_complement(&spec);
+    TEST_ASSERT_EQUAL_INT(N_CHARS - 10, got);
+}
+
+/* Overlapping constructs: "0-95-7" -> union is still 10 digits */
+void test_card_of_complement_overlap_and_duplicates(void)
+{
+    struct Spec_list spec = make_spec("0-95-7");
+    int got = card_of_complement(&spec);
+    TEST_ASSERT_EQUAL_INT(N_CHARS - 10, got);
+}
+
+/* Repeated char constructs: [x*5]x -> still only 'x' in the set
+   Indefinite repeat [x*] contributes nothing to the set */
+void test_card_of_complement_bracketed_repeat_and_indef(void)
+{
+    /* [x*5]x */
+    struct Spec_list spec1 = make_spec("[x*5]x");
+    int got1 = card_of_complement(&spec1);
+    TEST_ASSERT_EQUAL_INT(N_CHARS - 1, got1);
+
+    /* [x*] should contribute nothing */
+    struct Spec_list spec2 = make_spec("[x*]");
+    int got2 = card_of_complement(&spec2);
+    TEST_ASSERT_EQUAL_INT(N_CHARS, got2);
+}
+
+/* Equivalence class [=A=] (per implementation: only 'A') */
+void test_card_of_complement_equiv_class(void)
+{
+    struct Spec_list spec = make_spec("[=A=]");
+    int got = card_of_complement(&spec);
+    TEST_ASSERT_EQUAL_INT(N_CHARS - 1, got);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_card_of_complement_empty);
+    RUN_TEST(test_card_of_complement_single_char);
+    RUN_TEST(test_card_of_complement_range_az);
+    RUN_TEST(test_card_of_complement_full_range);
+    RUN_TEST(test_card_of_complement_class_digit);
+    RUN_TEST(test_card_of_complement_overlap_and_duplicates);
+    RUN_TEST(test_card_of_complement_bracketed_repeat_and_indef);
+    RUN_TEST(test_card_of_complement_equiv_class);
+    return UNITY_END();
+}

tests/tr/tests_for_find_bracketed_repeat.c

@@ -0,0 +1,234 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Helper to build an E_string with no escapes. */
+static struct E_string t_new_es_from_str(const char *str)
+{
+    struct E_string es;
+    size_t len = strlen(str);
+    es.len = len;
+    es.s = (char*)malloc(len);
+    memcpy(es.s, str, len);
+    es.escaped = (bool*)calloc(len, sizeof(bool));
+    return es;
+}
+
+/* Helper to build an E_string and mark given indices as escaped. */
+static struct E_string t_new_es_with_escapes(const char *str, const size_t *idxs, size_t nidx)
+{
+    struct E_string es = t_new_es_from_str(str);
+    for (size_t i = 0; i < nidx; ++i)
+    {
+        if (idxs[i] < es.len)
+            es.escaped[idxs[i]] = true;
+    }
+    return es;
+}
+
+static void t_free_es(struct E_string *es)
+{
+    if (!es) return;
+    free(es->s);
+    free(es->escaped);
+    es->s = NULL;
+    es->escaped = NULL;
+    es->len = 0;
+}
+
+void setUp(void) {
+    /* Setup code here, or leave empty */
+}
+
+void tearDown(void) {
+    /* Cleanup code here, or leave empty */
+}
+
+/* 1) Basic: [a*] -> success, repeat_count = 0, ']' index correct */
+void test_find_bracketed_repeat_basic_no_count(void)
+{
+    struct E_string es = t_new_es_from_str("[a*]");
+    unsigned char c = 0;
+    count rep = (count)12345; /* init to non-zero */
+    size_t close_idx = 9999;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(0, r);
+    TEST_ASSERT_EQUAL_INT('a', c);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)0, (uint64_t)rep);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)3, (uint64_t)close_idx);
+
+    t_free_es(&es);
+}
+
+/* 2) Decimal count: [x*12] -> repeat_count = 12 */
+void test_find_bracketed_repeat_decimal_count(void)
+{
+    struct E_string es = t_new_es_from_str("[x*12]");
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(0, r);
+    TEST_ASSERT_EQUAL_INT('x', c);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)12, (uint64_t)rep);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)5, (uint64_t)close_idx);
+
+    t_free_es(&es);
+}
+
+/* 3) Octal count: [y*010] -> repeat_count = 8 (octal 10) */
+void test_find_bracketed_repeat_octal_count(void)
+{
+    struct E_string es = t_new_es_from_str("[y*010]");
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(0, r);
+    TEST_ASSERT_EQUAL_INT('y', c);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)8, (uint64_t)rep);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)6, (uint64_t)close_idx);
+
+    t_free_es(&es);
+}
+
+/* 4) Invalid numeric part: [z*1x3] -> -2 */
+void test_find_bracketed_repeat_invalid_digits(void)
+{
+    struct E_string es = t_new_es_from_str("[z*1x3]");
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(-2, r);
+
+    t_free_es(&es);
+}
+
+/* 5) No closing bracket: [q*123  -> -1 */
+void test_find_bracketed_repeat_no_closing_bracket(void)
+{
+    struct E_string es = t_new_es_from_str("[q*123");
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(-1, r);
+
+    t_free_es(&es);
+}
+
+/* 6) Escaped '*' (i.e., not matching) -> -1 */
+void test_find_bracketed_repeat_star_escaped(void)
+{
+    const char *s = "[a*5]";
+    size_t esc_idxs[] = { 2 }; /* index of '*' */
+    struct E_string es = t_new_es_with_escapes(s, esc_idxs, 1);
+
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(-1, r);
+
+    t_free_es(&es);
+}
+
+/* 7) Escaped ']' (closing bracket escaped) -> -1 */
+void test_find_bracketed_repeat_closing_bracket_escaped(void)
+{
+    const char *s = "[a*5]";
+    size_t esc_idxs[] = { 4 }; /* index of ']' */
+    struct E_string es = t_new_es_with_escapes(s, esc_idxs, 1);
+
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(-1, r);
+
+    t_free_es(&es);
+}
+
+/* 8) Overflow numeric part: a very long sequence of digits -> -2 */
+void test_find_bracketed_repeat_overflow_digits(void)
+{
+    /* Many digits to ensure overflow on typical platforms. */
+    const char *s = "[a*999999999999999999999999999999999999]";
+    struct E_string es = t_new_es_from_str(s);
+
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(-2, r);
+
+    t_free_es(&es);
+}
+
+/* 9) Any escaped character within the digits causes non-match -> -1 */
+void test_find_bracketed_repeat_digit_escaped_in_middle(void)
+{
+    const char *s = "[a*12]";
+    size_t esc_idxs[] = { 4 }; /* index of '2' */
+    struct E_string es = t_new_es_with_escapes(s, esc_idxs, 1);
+
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(-1, r);
+
+    t_free_es(&es);
+}
+
+/* 10) Missing '*' immediately after c -> -1 */
+void test_find_bracketed_repeat_missing_star(void)
+{
+    struct E_string es = t_new_es_from_str("[a+12]");
+    unsigned char c = 0;
+    count rep = 0;
+    size_t close_idx = 0;
+
+    int r = find_bracketed_repeat(&es, 1, &c, &rep, &close_idx);
+
+    TEST_ASSERT_EQUAL_INT(-1, r);
+
+    t_free_es(&es);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_find_bracketed_repeat_basic_no_count);
+    RUN_TEST(test_find_bracketed_repeat_decimal_count);
+    RUN_TEST(test_find_bracketed_repeat_octal_count);
+    RUN_TEST(test_find_bracketed_repeat_invalid_digits);
+    RUN_TEST(test_find_bracketed_repeat_no_closing_bracket);
+    RUN_TEST(test_find_bracketed_repeat_star_escaped);
+    RUN_TEST(test_find_bracketed_repeat_closing_bracket_escaped);
+    RUN_TEST(test_find_bracketed_repeat_overflow_digits);
+    RUN_TEST(test_find_bracketed_repeat_digit_escaped_in_middle);
+    RUN_TEST(test_find_bracketed_repeat_missing_star);
+    return UNITY_END();
+}

tests/tr/tests_for_find_closing_delim.c

@@ -0,0 +1,149 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+/* Unity hooks */
+void setUp(void) {
+  /* Setup code here, or leave empty */
+}
+void tearDown(void) {
+  /* Cleanup code here, or leave empty */
+}
+
+/* Helper to init an E_string with provided data and length. */
+static void init_es(struct E_string *es, char *data, size_t len) {
+  es->s = data; /* data must remain valid for the test duration */
+  es->len = len;
+  es->escaped = (bool *)calloc(len, sizeof(bool));
+  TEST_ASSERT_NOT_NULL(es->escaped);
+}
+
+/* Helper to free E_string escaped map (when allocated via init_es). */
+static void free_es(struct E_string *es) {
+  free(es->escaped);
+  es->escaped = NULL;
+}
+
+/* Test: basic match for [: ... :] — should find ":]" starting at index 2 */
+void test_find_closing_delim_basic_colon(void) {
+  char data[] = "[::]"; /* indexes: 0:'[',1:':',2:':',3:']' */
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  size_t idx = (size_t)-1;
+  TEST_ASSERT_TRUE(find_closing_delim(&es, 2, ':', &idx));
+  TEST_ASSERT_EQUAL_UINT(2, idx);
+  free_es(&es);
+}
+
+/* Test: escaped pre-bracket char should not match */
+void test_find_closing_delim_escaped_colon(void) {
+  char data[] = "[::]";
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  es.escaped[2] = true; /* escape ':' at index 2 */
+  size_t idx;
+  TEST_ASSERT_FALSE(find_closing_delim(&es, 2, ':', &idx));
+  free_es(&es);
+}
+
+/* Test: escaped closing bracket should not match */
+void test_find_closing_delim_escaped_bracket(void) {
+  char data[] = "[::]";
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  es.escaped[3] = true; /* escape ']' at index 3 */
+  size_t idx;
+  TEST_ASSERT_FALSE(find_closing_delim(&es, 2, ':', &idx));
+  free_es(&es);
+}
+
+/* Test: ensure start_idx is honored (ignore earlier pairs) */
+void test_find_closing_delim_respects_start_idx(void) {
+  char data[] = "a:]:]"; /* indexes: 0 'a', 1 ':', 2 ']', 3 ':', 4 ']' */
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  size_t idx = 0;
+  /* Start at index 2, should skip pair at 1 and find pair at 3 */
+  TEST_ASSERT_TRUE(find_closing_delim(&es, 2, ':', &idx));
+  TEST_ASSERT_EQUAL_UINT(3, idx);
+  free_es(&es);
+}
+
+/* Test: no match present */
+void test_find_closing_delim_no_match(void) {
+  char data[] = "abcxyz";
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  size_t idx;
+  TEST_ASSERT_FALSE(find_closing_delim(&es, 0, ':', &idx));
+  free_es(&es);
+}
+
+/* Test: start_idx at last character (cannot match due to lack of room) */
+void test_find_closing_delim_start_at_last_char(void) {
+  char data[] = ":]"; /* len=2, last index=1 */
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  size_t idx;
+  TEST_ASSERT_FALSE(find_closing_delim(&es, 1, ':', &idx));
+  free_es(&es);
+}
+
+/* Test: equals variant [==] should find '=]' starting at index 2 */
+void test_find_closing_delim_equals_variant(void) {
+  char data[] = "[==]"; /* 0:'[',1:'=',2:'=',3:']' */
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  size_t idx = 0;
+  TEST_ASSERT_TRUE(find_closing_delim(&es, 2, '=', &idx));
+  TEST_ASSERT_EQUAL_UINT(2, idx);
+  free_es(&es);
+}
+
+/* Test: embedded NUL bytes are handled (search should still succeed) */
+void test_find_closing_delim_handles_nul_bytes(void) {
+  char data[6];
+  data[0] = 'a';
+  data[1] = ':';
+  data[2] = ']';
+  data[3] = '\0';
+  data[4] = ':';
+  data[5] = ']';
+  struct E_string es; init_es(&es, data, 6);
+  size_t idx = 999;
+  TEST_ASSERT_TRUE(find_closing_delim(&es, 0, ':', &idx));
+  TEST_ASSERT_EQUAL_UINT(1, idx); /* first occurrence at 1,2 */
+  free_es(&es);
+}
+
+/* Test: skip escaped first pair and find later valid pair */
+void test_find_closing_delim_skips_escaped_pair(void) {
+  char data[] = ":]:]"; /* 0 ':',1 ']',2 ':',3 ']' */
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  es.escaped[0] = true; /* escape first ':' so 0,1 is invalid */
+  size_t idx = (size_t)-1;
+  TEST_ASSERT_TRUE(find_closing_delim(&es, 0, ':', &idx));
+  TEST_ASSERT_EQUAL_UINT(2, idx); /* should match pair at 2,3 */
+  free_es(&es);
+}
+
+/* Test: escaped ']' in first pair; should find the next unescaped pair */
+void test_find_closing_delim_skips_escaped_bracket_then_finds_next(void) {
+  char data[] = ":]:]"; /* 0 ':',1 ']',2 ':',3 ']' */
+  struct E_string es; init_es(&es, data, sizeof(data) - 1);
+  es.escaped[1] = true; /* escape ']' at index 1 */
+  size_t idx = 0;
+  TEST_ASSERT_TRUE(find_closing_delim(&es, 0, ':', &idx));
+  TEST_ASSERT_EQUAL_UINT(2, idx); /* match at 2,3 */
+  free_es(&es);
+}
+
+int main(void) {
+  UNITY_BEGIN();
+  RUN_TEST(test_find_closing_delim_basic_colon);
+  RUN_TEST(test_find_closing_delim_escaped_colon);
+  RUN_TEST(test_find_closing_delim_escaped_bracket);
+  RUN_TEST(test_find_closing_delim_respects_start_idx);
+  RUN_TEST(test_find_closing_delim_no_match);
+  RUN_TEST(test_find_closing_delim_start_at_last_char);
+  RUN_TEST(test_find_closing_delim_equals_variant);
+  RUN_TEST(test_find_closing_delim_handles_nul_bytes);
+  RUN_TEST(test_find_closing_delim_skips_escaped_pair);
+  RUN_TEST(test_find_closing_delim_skips_escaped_bracket_then_finds_next);
+  return UNITY_END();
+}

tests/tr/tests_for_get_next.c

@@ -0,0 +1,187 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <locale.h>
+
+/* Unity fixtures */
+void setUp(void) {
+  /* Ensure predictable ctype behavior */
+  setlocale(LC_ALL, "C");
+}
+void tearDown(void) {
+}
+
+/* Local helpers for building specs for get_next */
+static void tsl_spec_init(struct Spec_list *s) {
+  spec_init(s);
+  s->state = BEGIN_STATE;
+}
+
+/* Tests */
+static void test_get_next_normal_char_single(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  append_normal_char(&s, (unsigned char)'A');
+
+  enum Upper_Lower_class cls = UL_NONE;
+  int c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT('A', c);
+  TEST_ASSERT_EQUAL_INT(UL_NONE, cls);
+
+  c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT(-1, c);
+}
+
+static void test_get_next_range_basic(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  /* Range c..f yields c,d,e,f */
+  TEST_ASSERT_TRUE_MESSAGE(append_range(&s, (unsigned char)'c', (unsigned char)'f'), "append_range failed");
+
+  enum Upper_Lower_class cls;
+  int c;
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT('c', c); TEST_ASSERT_EQUAL_INT(UL_NONE, cls);
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT('d', c); TEST_ASSERT_EQUAL_INT(UL_NONE, cls);
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT('e', c); TEST_ASSERT_EQUAL_INT(UL_NONE, cls);
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT('f', c); TEST_ASSERT_EQUAL_INT(UL_NONE, cls);
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT(-1, c);
+}
+
+static void test_get_next_char_class_lower_iteration(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  /* Append [:lower:] */
+  TEST_ASSERT_TRUE_MESSAGE(append_char_class(&s, "lower", strlen("lower")), "append_char_class lower failed");
+
+  enum Upper_Lower_class cls;
+  int prev = -1;
+  int count = 0;
+  while (1) {
+    int c = get_next(&s, &cls);
+    if (c == -1) break;
+    TEST_ASSERT_EQUAL_INT(UL_LOWER, cls);
+    TEST_ASSERT_TRUE_MESSAGE(islower(c) != 0, "Returned char not in lower class");
+    if (prev != -1) {
+      TEST_ASSERT_TRUE_MESSAGE(c > prev, "Class enumeration not strictly increasing");
+    }
+    prev = c;
+    count++;
+    /* Safety guard; in C locale should be finite and <= N_CHARS */
+    TEST_ASSERT_TRUE(count <= N_CHARS);
+  }
+  TEST_ASSERT_TRUE_MESSAGE(count > 0, "lower class produced no characters");
+}
+
+static void test_get_next_char_class_digit_class_is_UL_NONE(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  TEST_ASSERT_TRUE_MESSAGE(append_char_class(&s, "digit", strlen("digit")), "append_char_class digit failed");
+  enum Upper_Lower_class cls = UL_UPPER; /* initialize to different to catch no-change */
+  int c = get_next(&s, &cls);
+  TEST_ASSERT_NOT_EQUAL(-1, c);
+  TEST_ASSERT_EQUAL_INT(UL_NONE, cls);
+}
+
+static void test_get_next_equiv_class_single(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  /* [=X=] equivalent in this implementation returns X once */
+  TEST_ASSERT_TRUE_MESSAGE(append_equiv_class(&s, "X", 1), "append_equiv_class failed");
+
+  enum Upper_Lower_class cls;
+  int c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT('X', c);
+  TEST_ASSERT_EQUAL_INT(UL_NONE, cls);
+  c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT(-1, c);
+}
+
+static void test_get_next_repeated_char_positive_count(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  append_repeated_char(&s, (unsigned char)'Z', (count)3);
+
+  enum Upper_Lower_class cls;
+  int c;
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT('Z', c);
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT('Z', c);
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT('Z', c);
+  c = get_next(&s, &cls); TEST_ASSERT_EQUAL_INT(-1, c);
+}
+
+static void test_get_next_repeated_char_zero_only(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  append_repeated_char(&s, (unsigned char)'Y', (count)0);
+
+  enum Upper_Lower_class cls;
+  int c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT(-1, c);
+}
+
+static void test_get_next_repeated_char_zero_then_normal(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  append_repeated_char(&s, (unsigned char)'W', (count)0);
+  append_normal_char(&s, (unsigned char)'Q');
+
+  enum Upper_Lower_class cls;
+  int c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT('Q', c);
+  c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT(-1, c);
+}
+
+static void test_get_next_two_char_classes_transition(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  TEST_ASSERT_TRUE_MESSAGE(append_char_class(&s, "lower", strlen("lower")), "append lower failed");
+  TEST_ASSERT_TRUE_MESSAGE(append_char_class(&s, "upper", strlen("upper")), "append upper failed");
+
+  enum Upper_Lower_class cls;
+  int c = get_next(&s, &cls);
+  TEST_ASSERT_NOT_EQUAL(-1, c);
+  TEST_ASSERT_EQUAL_INT(UL_LOWER, cls);
+  TEST_ASSERT_TRUE(islower(c));
+
+  /* Skip the rest of the lower-class element to transition to next element */
+  skip_construct(&s);
+
+  c = get_next(&s, &cls);
+  TEST_ASSERT_NOT_EQUAL(-1, c);
+  TEST_ASSERT_EQUAL_INT(UL_UPPER, cls);
+  TEST_ASSERT_TRUE(isupper(c));
+}
+
+static void test_get_next_reset_begin_state_restarts(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  append_normal_char(&s, (unsigned char)'A');
+  append_normal_char(&s, (unsigned char)'B');
+
+  enum Upper_Lower_class cls;
+  int c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT('A', c);
+
+  /* Reset and ensure we start from the beginning again */
+  s.state = BEGIN_STATE;
+  c = get_next(&s, &cls);
+  TEST_ASSERT_EQUAL_INT('A', c);
+}
+
+static void test_get_next_null_class_pointer(void) {
+  struct Spec_list s; tsl_spec_init(&s);
+  append_normal_char(&s, (unsigned char)'C');
+
+  int c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT('C', c);
+  c = get_next(&s, NULL);
+  TEST_ASSERT_EQUAL_INT(-1, c);
+}
+
+int main(void) {
+  UNITY_BEGIN();
+  RUN_TEST(test_get_next_normal_char_single);
+  RUN_TEST(test_get_next_range_basic);
+  RUN_TEST(test_get_next_char_class_lower_iteration);
+  RUN_TEST(test_get_next_char_class_digit_class_is_UL_NONE);
+  RUN_TEST(test_get_next_equiv_class_single);
+  RUN_TEST(test_get_next_repeated_char_positive_count);
+  RUN_TEST(test_get_next_repeated_char_zero_only);
+  RUN_TEST(test_get_next_repeated_char_zero_then_normal);
+  RUN_TEST(test_get_next_two_char_classes_transition);
+  RUN_TEST(test_get_next_reset_begin_state_restarts);
+  RUN_TEST(test_get_next_null_class_pointer);
+  return UNITY_END();
+}

tests/tr/tests_for_get_s2_spec_stats.c

@@ -0,0 +1,210 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+/* The test file is included into the tr.c translation unit, so we can
+   directly access internal (static) functions and types. */
+
+static void free_spec_list(struct Spec_list *s)
+{
+    if (!s || !s->head) return;
+    struct List_element *p = s->head;
+    while (p) {
+        struct List_element *n = p->next;
+        free(p);
+        p = n;
+    }
+    s->head = NULL;
+    s->tail = NULL;
+}
+
+static void init_and_parse(struct Spec_list *s, const char *str)
+{
+    spec_init(s);
+    bool ok = parse_str(str, s);
+    TEST_ASSERT_MESSAGE(ok, "parse_str failed for input");
+}
+
+static size_t count_indefinite_repeat_nodes(struct Spec_list *s)
+{
+    size_t cnt = 0;
+    for (struct List_element *p = s->head->next; p; p = p->next) {
+        if (p->type == RE_REPEATED_CHAR && p->u.repeated_char.repeat_count == 0)
+            cnt++;
+    }
+    return cnt;
+}
+
+static struct List_element* find_first_repeat_node(struct Spec_list *s)
+{
+    for (struct List_element *p = s->head->next; p; p = p->next) {
+        if (p->type == RE_REPEATED_CHAR)
+            return p;
+    }
+    return NULL;
+}
+
+void setUp(void) {
+    /* no-op */
+}
+
+void tearDown(void) {
+    /* no-op */
+}
+
+/* 1) No indefinite repeats: lengths are computed, nothing extended */
+void test_get_s2_spec_stats_no_indefinite(void)
+{
+    struct Spec_list s2 = {0};
+    init_and_parse(&s2, "AB[Z*3]"); /* length = 2 + 3 = 5 */
+
+    get_s2_spec_stats(&s2, 10);
+
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)5, (unsigned long long)s2.length);
+    TEST_ASSERT_EQUAL_UINT32(0u, (unsigned int)s2.n_indefinite_repeats);
+
+    struct List_element *rep = find_first_repeat_node(&s2);
+    TEST_ASSERT_NOT_NULL(rep);
+    TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, rep->type);
+    TEST_ASSERT_EQUAL_UINT32(3u, (unsigned int)rep->u.repeated_char.repeat_count);
+
+    free_spec_list(&s2);
+}
+
+/* 2) Single [c*] indefinite: extended to len_s1 */
+void test_get_s2_spec_stats_single_indefinite_extend(void)
+{
+    struct Spec_list s2 = {0};
+    init_and_parse(&s2, "A[Y*]Z"); /* initial length = 2 (1 + 0 + 1) */
+
+    get_s2_spec_stats(&s2, 26);
+
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)26, (unsigned long long)s2.length);
+    TEST_ASSERT_NOT_NULL(s2.indefinite_repeat_element);
+    TEST_ASSERT_EQUAL_INT('Y', s2.indefinite_repeat_element->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)24,
+                             (unsigned long long)s2.indefinite_repeat_element->u.repeated_char.repeat_count);
+
+    /* Recompute stats to ensure it's no longer treated as indefinite */
+    get_spec_stats(&s2);
+    TEST_ASSERT_EQUAL_UINT32(0u, (unsigned int)s2.n_indefinite_repeats);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)26, (unsigned long long)s2.length);
+
+    free_spec_list(&s2);
+}
+
+/* 3) Single [c*] indefinite: len_s1 == s2.length, no change */
+void test_get_s2_spec_stats_single_indefinite_equal_length(void)
+{
+    struct Spec_list s2 = {0};
+    init_and_parse(&s2, "M[N*]"); /* initial length = 1 */
+
+    get_s2_spec_stats(&s2, 1);
+
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)1, (unsigned long long)s2.length);
+    TEST_ASSERT_NOT_NULL(s2.indefinite_repeat_element);
+    TEST_ASSERT_EQUAL_INT('N', s2.indefinite_repeat_element->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)0,
+                             (unsigned long long)s2.indefinite_repeat_element->u.repeated_char.repeat_count);
+
+    free_spec_list(&s2);
+}
+
+/* 4) Single [c*] indefinite: len_s1 < s2.length, no extension occurs */
+void test_get_s2_spec_stats_single_indefinite_len_s1_smaller(void)
+{
+    struct Spec_list s2 = {0};
+    init_and_parse(&s2, "P[Q*]R"); /* initial length = 2 */
+
+    get_s2_spec_stats(&s2, 1);
+
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)2, (unsigned long long)s2.length);
+    TEST_ASSERT_NOT_NULL(s2.indefinite_repeat_element);
+    TEST_ASSERT_EQUAL_INT('Q', s2.indefinite_repeat_element->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)0,
+                             (unsigned long long)s2.indefinite_repeat_element->u.repeated_char.repeat_count);
+
+    free_spec_list(&s2);
+}
+
+/* 5) [c*0] is treated as indefinite and extended */
+void test_get_s2_spec_stats_indefinite_zero_explicit(void)
+{
+    struct Spec_list s2 = {0};
+    init_and_parse(&s2, "X[W*0]Y"); /* initial length = 2 */
+
+    get_s2_spec_stats(&s2, 5);
+
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)5, (unsigned long long)s2.length);
+    TEST_ASSERT_NOT_NULL(s2.indefinite_repeat_element);
+    TEST_ASSERT_EQUAL_INT('W', s2.indefinite_repeat_element->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)3,
+                             (unsigned long long)s2.indefinite_repeat_element->u.repeated_char.repeat_count);
+
+    /* Recompute to ensure resolution of indefiniteness */
+    get_spec_stats(&s2);
+    TEST_ASSERT_EQUAL_UINT32(0u, (unsigned int)s2.n_indefinite_repeats);
+
+    free_spec_list(&s2);
+}
+
+/* 6) Multiple indefinite repeats: no extension should occur */
+void test_get_s2_spec_stats_multiple_indefinite_no_extension(void)
+{
+    struct Spec_list s2 = {0};
+    init_and_parse(&s2, "[A*][B*]"); /* initial length = 0, two indefinites */
+
+    get_s2_spec_stats(&s2, 10);
+
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)0, (unsigned long long)s2.length);
+
+    /* Both repeats should still be indefinite (repeat_count == 0). */
+    size_t indef = count_indefinite_repeat_nodes(&s2);
+    TEST_ASSERT_EQUAL_UINT32(2u, (unsigned int)indef);
+
+    /* Also ensure neither was modified inadvertently. */
+    size_t zero_repeat_nodes = 0;
+    size_t nonzero_repeat_nodes = 0;
+    for (struct List_element *p = s2.head->next; p; p = p->next) {
+        if (p->type == RE_REPEATED_CHAR) {
+            if (p->u.repeated_char.repeat_count == 0) zero_repeat_nodes++;
+            else nonzero_repeat_nodes++;
+        }
+    }
+    TEST_ASSERT_EQUAL_UINT32(2u, (unsigned int)zero_repeat_nodes);
+    TEST_ASSERT_EQUAL_UINT32(0u, (unsigned int)nonzero_repeat_nodes);
+
+    free_spec_list(&s2);
+}
+
+/* 7) Range plus single indefinite: extend to len_s1 */
+void test_get_s2_spec_stats_range_and_indefinite(void)
+{
+    struct Spec_list s2 = {0};
+    init_and_parse(&s2, "a-c[Z*]"); /* range a-c -> 3, plus 0 => initial length 3 */
+
+    get_s2_spec_stats(&s2, 5);
+
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)5, (unsigned long long)s2.length);
+    TEST_ASSERT_NOT_NULL(s2.indefinite_repeat_element);
+    TEST_ASSERT_EQUAL_INT('Z', s2.indefinite_repeat_element->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)2,
+                             (unsigned long long)s2.indefinite_repeat_element->u.repeated_char.repeat_count);
+
+    free_spec_list(&s2);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_get_s2_spec_stats_no_indefinite);
+    RUN_TEST(test_get_s2_spec_stats_single_indefinite_extend);
+    RUN_TEST(test_get_s2_spec_stats_single_indefinite_equal_length);
+    RUN_TEST(test_get_s2_spec_stats_single_indefinite_len_s1_smaller);
+    RUN_TEST(test_get_s2_spec_stats_indefinite_zero_explicit);
+    RUN_TEST(test_get_s2_spec_stats_multiple_indefinite_no_extension);
+    RUN_TEST(test_get_s2_spec_stats_range_and_indefinite);
+    return UNITY_END();
+}

tests/tr/tests_for_get_spec_stats.c

@@ -0,0 +1,213 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdint.h>
+
+/* setUp and tearDown required by Unity */
+void setUp(void) {
+  /* no-op */
+}
+void tearDown(void) {
+  /* no-op */
+}
+
+/* Helpers: build a Spec_list via program internals and free it. */
+
+static void init_and_parse(struct Spec_list *s, const char *pattern)
+{
+  spec_init(s);
+  bool ok = parse_str(pattern, s);
+  TEST_ASSERT_TRUE_MESSAGE(ok, "parse_str() failed for pattern");
+}
+
+static void free_spec(struct Spec_list *s)
+{
+  struct List_element *p = s->head;
+  while (p) {
+    struct List_element *next = p->next;
+    free(p);
+    p = next;
+  }
+}
+
+static uintmax_t count_upper_via_ctype(void)
+{
+  uintmax_t n = 0;
+  for (int i = 0; i <= UCHAR_MAX; i++) {
+    if (isupper(i)) n++;
+  }
+  return n;
+}
+
+static uintmax_t count_lower_via_ctype(void)
+{
+  uintmax_t n = 0;
+  for (int i = 0; i <= UCHAR_MAX; i++) {
+    if (islower(i)) n++;
+  }
+  return n;
+}
+
+/* Tests */
+
+void test_get_spec_stats_simple_chars(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  init_and_parse(&s, "abc");
+
+  get_spec_stats(&s);
+
+  TEST_ASSERT_TRUE(s.length == 3);
+  TEST_ASSERT_EQUAL_UINT(0, s.n_indefinite_repeats);
+  TEST_ASSERT_FALSE(s.has_char_class);
+  TEST_ASSERT_FALSE(s.has_restricted_char_class);
+  TEST_ASSERT_FALSE(s.has_equiv_class);
+
+  free_spec(&s);
+}
+
+void test_get_spec_stats_range(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  init_and_parse(&s, "a-c");
+
+  get_spec_stats(&s);
+
+  TEST_ASSERT_TRUE(s.length == 3);
+  TEST_ASSERT_EQUAL_UINT(0, s.n_indefinite_repeats);
+  TEST_ASSERT_FALSE(s.has_char_class);
+  TEST_ASSERT_FALSE(s.has_restricted_char_class);
+  TEST_ASSERT_FALSE(s.has_equiv_class);
+
+  free_spec(&s);
+}
+
+void test_get_spec_stats_digit_class_restricted(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  init_and_parse(&s, "[:digit:]");
+
+  get_spec_stats(&s);
+
+  TEST_ASSERT_TRUE(s.length == 10);
+  TEST_ASSERT_TRUE(s.has_char_class);
+  TEST_ASSERT_TRUE(s.has_restricted_char_class);
+  TEST_ASSERT_FALSE(s.has_equiv_class);
+  TEST_ASSERT_EQUAL_UINT(0, s.n_indefinite_repeats);
+
+  free_spec(&s);
+}
+
+void test_get_spec_stats_xdigit_class_length(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  init_and_parse(&s, "[:xdigit:]");
+
+  get_spec_stats(&s);
+
+  /* Expect 0-9 (10) + A-F (6) + a-f (6) = 22 in ASCII semantics */
+  TEST_ASSERT_TRUE(s.length == 22);
+  TEST_ASSERT_TRUE(s.has_char_class);
+  TEST_ASSERT_TRUE(s.has_restricted_char_class);
+  TEST_ASSERT_FALSE(s.has_equiv_class);
+
+  free_spec(&s);
+}
+
+void test_get_spec_stats_upper_class_unrestricted_and_length_matches_locale(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  init_and_parse(&s, "[:upper:]");
+
+  get_spec_stats(&s);
+
+  uintmax_t expected = count_upper_via_ctype();
+  TEST_ASSERT_TRUE(s.length == expected);
+  TEST_ASSERT_TRUE(s.has_char_class);
+  TEST_ASSERT_FALSE(s.has_restricted_char_class);
+  TEST_ASSERT_FALSE(s.has_equiv_class);
+
+  free_spec(&s);
+}
+
+void test_get_spec_stats_equiv_class_singleton(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  init_and_parse(&s, "[=A=]");
+
+  get_spec_stats(&s);
+
+  TEST_ASSERT_TRUE(s.length == 1);
+  TEST_ASSERT_TRUE(s.has_equiv_class);
+  TEST_ASSERT_FALSE(s.has_char_class);
+  TEST_ASSERT_FALSE(s.has_restricted_char_class);
+  TEST_ASSERT_EQUAL_UINT(0, s.n_indefinite_repeats);
+
+  free_spec(&s);
+}
+
+void test_get_spec_stats_repeated_char_definite_count(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  init_and_parse(&s, "[x*5]");
+
+  get_spec_stats(&s);
+
+  TEST_ASSERT_TRUE(s.length == 5);
+  TEST_ASSERT_EQUAL_UINT(0, s.n_indefinite_repeats);
+  TEST_ASSERT_FALSE(s.has_char_class);
+  TEST_ASSERT_FALSE(s.has_restricted_char_class);
+  TEST_ASSERT_FALSE(s.has_equiv_class);
+
+  free_spec(&s);
+}
+
+void test_get_spec_stats_indefinite_repeats_zero_and_empty(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  init_and_parse(&s, "[x*][y*0]a");
+
+  get_spec_stats(&s);
+
+  /* [x*] and [y*0] add no length but are both counted; plus 'a' */
+  TEST_ASSERT_TRUE(s.length == 1);
+  TEST_ASSERT_EQUAL_UINT(2, s.n_indefinite_repeats);
+  TEST_ASSERT_FALSE(s.has_char_class);
+  TEST_ASSERT_FALSE(s.has_restricted_char_class);
+  TEST_ASSERT_FALSE(s.has_equiv_class);
+
+  free_spec(&s);
+}
+
+void test_get_spec_stats_mixed_constructs(void)
+{
+  struct Spec_list s; memset(&s, 0, sizeof s);
+  /* A (1), [=B=] (1), c (1), 0-2 (3), [:digit:] (10), [x*3] (3), [y*] (0) */
+  init_and_parse(&s, "A[=B=]c0-2[:digit:][x*3][y*]");
+
+  get_spec_stats(&s);
+
+  TEST_ASSERT_TRUE(s.length == (uintmax_t)19);
+  TEST_ASSERT_TRUE(s.has_equiv_class);
+  TEST_ASSERT_TRUE(s.has_char_class);
+  TEST_ASSERT_TRUE(s.has_restricted_char_class);
+  TEST_ASSERT_EQUAL_UINT(1, s.n_indefinite_repeats);
+
+  free_spec(&s);
+}
+
+int main(void)
+{
+  UNITY_BEGIN();
+  RUN_TEST(test_get_spec_stats_simple_chars);
+  RUN_TEST(test_get_spec_stats_range);
+  RUN_TEST(test_get_spec_stats_digit_class_restricted);
+  RUN_TEST(test_get_spec_stats_xdigit_class_length);
+  RUN_TEST(test_get_spec_stats_upper_class_unrestricted_and_length_matches_locale);
+  RUN_TEST(test_get_spec_stats_equiv_class_singleton);
+  RUN_TEST(test_get_spec_stats_repeated_char_definite_count);
+  RUN_TEST(test_get_spec_stats_indefinite_repeats_zero_and_empty);
+  RUN_TEST(test_get_spec_stats_mixed_constructs);
+  return UNITY_END();
+}

tests/tr/tests_for_homogeneous_spec_list.c

@@ -0,0 +1,127 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+/* The program source includes this test file after all internal
+   definitions, so we can use Spec_list and helper functions directly. */
+
+void setUp(void) {
+  /* Setup code here, or leave empty */
+}
+
+void tearDown(void) {
+  /* Cleanup code here, or leave empty */
+}
+
+/* Helper to initialize a fresh Spec_list. */
+static void init_list(struct Spec_list *s) {
+  spec_init(s);
+}
+
+void test_homogeneous_spec_list_empty_returns_false(void) {
+  struct Spec_list s;
+  init_list(&s);
+  TEST_ASSERT_FALSE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_single_normal_char_true(void) {
+  struct Spec_list s;
+  init_list(&s);
+  append_normal_char(&s, 'x');
+  TEST_ASSERT_TRUE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_two_identical_normal_chars_true(void) {
+  struct Spec_list s;
+  init_list(&s);
+  append_normal_char(&s, 'a');
+  append_normal_char(&s, 'a');
+  TEST_ASSERT_TRUE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_two_different_normal_chars_false(void) {
+  struct Spec_list s;
+  init_list(&s);
+  append_normal_char(&s, 'a');
+  append_normal_char(&s, 'b');
+  TEST_ASSERT_FALSE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_range_same_endpoints_true(void) {
+  struct Spec_list s;
+  init_list(&s);
+  TEST_ASSERT_TRUE_MESSAGE(append_range(&s, 'm', 'm'), "append_range must succeed for same endpoints");
+  TEST_ASSERT_TRUE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_range_different_endpoints_false(void) {
+  struct Spec_list s;
+  init_list(&s);
+  TEST_ASSERT_TRUE_MESSAGE(append_range(&s, 'a', 'b'), "append_range must succeed for increasing endpoints");
+  TEST_ASSERT_FALSE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_repeated_char_positive_count_true(void) {
+  struct Spec_list s;
+  init_list(&s);
+  append_repeated_char(&s, 'z', 5);
+  TEST_ASSERT_TRUE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_repeated_char_zero_count_only_false(void) {
+  struct Spec_list s;
+  init_list(&s);
+  append_repeated_char(&s, 'q', 0); /* contributes nothing */
+  TEST_ASSERT_FALSE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_mixed_all_same_char_true(void) {
+  struct Spec_list s;
+  init_list(&s);
+  /* Sequence expansion will be: 'c', 'c','c','c','c', 'c' */
+  TEST_ASSERT_TRUE(append_range(&s, 'c', 'c'));
+  append_repeated_char(&s, 'c', 4);
+  append_normal_char(&s, 'c');
+  TEST_ASSERT_TRUE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_zero_repeat_then_single_char_true(void) {
+  struct Spec_list s;
+  init_list(&s);
+  append_repeated_char(&s, 'x', 0); /* no output */
+  append_normal_char(&s, 'x');      /* single output */
+  TEST_ASSERT_TRUE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_char_class_digit_false(void) {
+  struct Spec_list s;
+  init_list(&s);
+  TEST_ASSERT_TRUE_MESSAGE(append_char_class(&s, "digit", 5), "append_char_class 'digit' should succeed");
+  TEST_ASSERT_FALSE(homogeneous_spec_list(&s));
+}
+
+void test_homogeneous_spec_list_equiv_class_single_char_true(void) {
+  struct Spec_list s;
+  init_list(&s);
+  TEST_ASSERT_TRUE_MESSAGE(append_equiv_class(&s, "Q", 1), "append_equiv_class with single char should succeed");
+  TEST_ASSERT_TRUE(homogeneous_spec_list(&s));
+}
+
+int main(void) {
+  UNITY_BEGIN();
+  RUN_TEST(test_homogeneous_spec_list_empty_returns_false);
+  RUN_TEST(test_homogeneous_spec_list_single_normal_char_true);
+  RUN_TEST(test_homogeneous_spec_list_two_identical_normal_chars_true);
+  RUN_TEST(test_homogeneous_spec_list_two_different_normal_chars_false);
+  RUN_TEST(test_homogeneous_spec_list_range_same_endpoints_true);
+  RUN_TEST(test_homogeneous_spec_list_range_different_endpoints_false);
+  RUN_TEST(test_homogeneous_spec_list_repeated_char_positive_count_true);
+  RUN_TEST(test_homogeneous_spec_list_repeated_char_zero_count_only_false);
+  RUN_TEST(test_homogeneous_spec_list_mixed_all_same_char_true);
+  RUN_TEST(test_homogeneous_spec_list_zero_repeat_then_single_char_true);
+  RUN_TEST(test_homogeneous_spec_list_char_class_digit_false);
+  RUN_TEST(test_homogeneous_spec_list_equiv_class_single_char_true);
+  return UNITY_END();
+}

tests/tr/tests_for_is_char_class_member.c

@@ -0,0 +1,159 @@
+#include "../../unity/unity.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <locale.h>
+#include <ctype.h>
+#include <limits.h>
+
+/* Unity hooks */
+void setUp(void) {
+  /* Ensure C-locale so standard ctype behaviors are predictable (ASCII). */
+  setlocale(LC_ALL, "C");
+}
+void tearDown(void) {
+  /* Nothing to clean */
+}
+
+/* Reference classifier using the same predicates the target uses. */
+static bool ref_is_member(enum Char_class cls, unsigned char c) {
+  switch (cls) {
+    case CC_ALNUM:  return isalnum(c) != 0;
+    case CC_ALPHA:  return isalpha(c) != 0;
+    case CC_BLANK:  return isblank(c) != 0;
+    case CC_CNTRL:  return iscntrl(c) != 0;
+    case CC_DIGIT:  return c_isdigit(c) != 0;   /* ASCII-digit only */
+    case CC_GRAPH:  return isgraph(c) != 0;
+    case CC_LOWER:  return islower(c) != 0;
+    case CC_PRINT:  return isprint(c) != 0;
+    case CC_PUNCT:  return ispunct(c) != 0;
+    case CC_SPACE:  return isspace(c) != 0;
+    case CC_UPPER:  return isupper(c) != 0;
+    case CC_XDIGIT: return c_isxdigit(c) != 0;  /* ASCII-hex only */
+    default:        return false; /* Do not test CC_NO_CLASS here. */
+  }
+}
+
+/* Basic spot checks per class. */
+void test_is_char_class_member_alpha_basic(void) {
+  TEST_ASSERT_TRUE(is_char_class_member(CC_ALPHA, 'A'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_ALPHA, 'z'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_ALPHA, '0'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_ALPHA, '_'));
+}
+
+void test_is_char_class_member_alnum_basic(void) {
+  TEST_ASSERT_TRUE(is_char_class_member(CC_ALNUM, 'A'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_ALNUM, '0'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_ALNUM, ' '));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_ALNUM, '!'));
+}
+
+void test_is_char_class_member_digit_basic(void) {
+  TEST_ASSERT_TRUE(is_char_class_member(CC_DIGIT, '0'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_DIGIT, '5'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_DIGIT, '9'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_DIGIT, 'a'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_DIGIT, '/'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_DIGIT, ':'));
+}
+
+void test_is_char_class_member_xdigit_basic(void) {
+  TEST_ASSERT_TRUE(is_char_class_member(CC_XDIGIT, '0'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_XDIGIT, '9'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_XDIGIT, 'a'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_XDIGIT, 'f'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_XDIGIT, 'A'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_XDIGIT, 'F'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_XDIGIT, 'g'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_XDIGIT, 'G'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_XDIGIT, 'z'));
+}
+
+void test_is_char_class_member_lower_upper_basic(void) {
+  TEST_ASSERT_TRUE(is_char_class_member(CC_LOWER, 'a'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_LOWER, 'z'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_LOWER, 'A'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_LOWER, '0'));
+
+  TEST_ASSERT_TRUE(is_char_class_member(CC_UPPER, 'A'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_UPPER, 'Z'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_UPPER, 'a'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_UPPER, '0'));
+}
+
+void test_is_char_class_member_space_blank_basic(void) {
+  /* CC_SPACE: any whitespace */
+  TEST_ASSERT_TRUE(is_char_class_member(CC_SPACE, ' '));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_SPACE, '\t'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_SPACE, '\n'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_SPACE, '\r'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_SPACE, '\v'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_SPACE, '\f'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_SPACE, 'A'));
+
+  /* CC_BLANK: space or horizontal tab only */
+  TEST_ASSERT_TRUE(is_char_class_member(CC_BLANK, ' '));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_BLANK, '\t'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_BLANK, '\n'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_BLANK, 'A'));
+}
+
+void test_is_char_class_member_print_graph_punct_basic(void) {
+  /* PRINT includes space; GRAPH excludes space */
+  TEST_ASSERT_TRUE(is_char_class_member(CC_PRINT, ' '));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_PRINT, 'A'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_PRINT, '\n'));
+
+  TEST_ASSERT_FALSE(is_char_class_member(CC_GRAPH, ' '));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_GRAPH, '!'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_GRAPH, 'A'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_GRAPH, '\n'));
+
+  /* PUNCT: printable, not alnum, not space */
+  TEST_ASSERT_TRUE(is_char_class_member(CC_PUNCT, '!'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_PUNCT, '.'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_PUNCT, '_'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_PUNCT, 'A'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_PUNCT, '0'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_PUNCT, ' '));
+}
+
+void test_is_char_class_member_cntrl_basic(void) {
+  TEST_ASSERT_TRUE(is_char_class_member(CC_CNTRL, '\0'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_CNTRL, '\n'));
+  TEST_ASSERT_TRUE(is_char_class_member(CC_CNTRL, '\177')); /* DEL */
+  TEST_ASSERT_FALSE(is_char_class_member(CC_CNTRL, 'A'));
+  TEST_ASSERT_FALSE(is_char_class_member(CC_CNTRL, ' '));
+}
+
+/* Exhaustive cross-check: for all bytes and all valid classes,
+   the function should match the reference behavior. */
+void test_is_char_class_member_exhaustive_matches_reference(void) {
+  for (int cls = CC_ALNUM; cls <= CC_XDIGIT; ++cls) {
+    enum Char_class ccls = (enum Char_class)cls;
+    for (int v = 0; v <= UCHAR_MAX; ++v) {
+      unsigned char uc = (unsigned char)v;
+      bool got = is_char_class_member(ccls, uc);
+      bool exp = ref_is_member(ccls, uc);
+      TEST_ASSERT_EQUAL_INT_MESSAGE(
+        (int)exp, (int)got, "Mismatch in exhaustive check");
+    }
+  }
+}
+
+int main(void) {
+  UNITY_BEGIN();
+  RUN_TEST(test_is_char_class_member_alpha_basic);
+  RUN_TEST(test_is_char_class_member_alnum_basic);
+  RUN_TEST(test_is_char_class_member_digit_basic);
+  RUN_TEST(test_is_char_class_member_xdigit_basic);
+  RUN_TEST(test_is_char_class_member_lower_upper_basic);
+  RUN_TEST(test_is_char_class_member_space_blank_basic);
+  RUN_TEST(test_is_char_class_member_print_graph_punct_basic);
+  RUN_TEST(test_is_char_class_member_cntrl_basic);
+  RUN_TEST(test_is_char_class_member_exhaustive_matches_reference);
+  return UNITY_END();
+}

tests/tr/tests_for_look_up_char_class.c

@@ -0,0 +1,99 @@
+#include "../../unity/unity.h"
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+
+void setUp(void) {
+  /* Setup code here, or leave empty */
+}
+
+void tearDown(void) {
+  /* Cleanup code here, or leave empty */
+}
+
+/* Target: static enum Char_class look_up_char_class (char const *class_str, size_t len) */
+
+static void assert_lookup_eq(const char *s, size_t len, enum Char_class expected)
+{
+  enum Char_class got = look_up_char_class(s, len);
+  TEST_ASSERT_EQUAL_INT((int)expected, (int)got);
+}
+
+void test_look_up_char_class_all_valid_exact(void)
+{
+  struct { const char *name; enum Char_class cls; } cases[] = {
+    {"alnum",  CC_ALNUM},
+    {"alpha",  CC_ALPHA},
+    {"blank",  CC_BLANK},
+    {"cntrl",  CC_CNTRL},
+    {"digit",  CC_DIGIT},
+    {"graph",  CC_GRAPH},
+    {"lower",  CC_LOWER},
+    {"print",  CC_PRINT},
+    {"punct",  CC_PUNCT},
+    {"space",  CC_SPACE},
+    {"upper",  CC_UPPER},
+    {"xdigit", CC_XDIGIT},
+  };
+
+  for (size_t i = 0; i < sizeof(cases)/sizeof(cases[0]); i++) {
+    assert_lookup_eq(cases[i].name, strlen(cases[i].name), cases[i].cls);
+  }
+}
+
+void test_look_up_char_class_case_sensitivity(void)
+{
+  /* Upper/lower/capitalized variants should not match */
+  assert_lookup_eq("ALPHA", 5, CC_NO_CLASS);
+  assert_lookup_eq("Alpha", 5, CC_NO_CLASS);
+  assert_lookup_eq("AlPhA", 5, CC_NO_CLASS);
+}
+
+void test_look_up_char_class_trimmed_len_matches_prefix_only(void)
+{
+  /* Provide a longer string but len equal to the class name length. */
+  const char *s = "alphabeta"; /* longer than "alpha" */
+  assert_lookup_eq(s, 5, CC_ALPHA);
+
+  const char *s2 = "uppermost"; /* prefix is "upper" */
+  assert_lookup_eq(s2, 5, CC_UPPER);
+}
+
+void test_look_up_char_class_too_short_len_fails(void)
+{
+  /* len shorter than actual class name should not match */
+  assert_lookup_eq("alpha", 4, CC_NO_CLASS);
+  assert_lookup_eq("xdigit", 5, CC_NO_CLASS); /* missing final 't' */
+}
+
+void test_look_up_char_class_non_null_terminated_segment(void)
+{
+  /* Pass a pointer into a buffer with no terminating NUL at len */
+  char buf[] = "zzlowerzz"; /* we want to match "lower" starting at buf+2 */
+  assert_lookup_eq(buf + 2, 5, CC_LOWER);
+}
+
+void test_look_up_char_class_len_zero_fails(void)
+{
+  assert_lookup_eq("alpha", 0, CC_NO_CLASS);
+}
+
+void test_look_up_char_class_invalid_names_fail(void)
+{
+  assert_lookup_eq("foo", 3, CC_NO_CLASS);
+  assert_lookup_eq("", 0, CC_NO_CLASS);
+  assert_lookup_eq("alnumx", 6, CC_NO_CLASS); /* extra char with full len */
+}
+
+int main(void)
+{
+  UNITY_BEGIN();
+  RUN_TEST(test_look_up_char_class_all_valid_exact);
+  RUN_TEST(test_look_up_char_class_case_sensitivity);
+  RUN_TEST(test_look_up_char_class_trimmed_len_matches_prefix_only);
+  RUN_TEST(test_look_up_char_class_too_short_len_fails);
+  RUN_TEST(test_look_up_char_class_non_null_terminated_segment);
+  RUN_TEST(test_look_up_char_class_len_zero_fails);
+  RUN_TEST(test_look_up_char_class_invalid_names_fail);
+  return UNITY_END();
+}

tests/tr/tests_for_read_and_delete.c

@@ -0,0 +1,200 @@
+#include "../../unity/unity.h"
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+
+/* Access to program internals: in_delete_set and read_and_delete are
+   visible since this file is included into the same translation unit. */
+
+static int g_saved_stdin = -1;
+
+static void reset_delete_set(void) {
+    for (size_t i = 0; i < N_CHARS; i++) {
+        in_delete_set[i] = false;
+    }
+}
+
+static void set_delete_byte(unsigned char b) {
+    in_delete_set[b] = true;
+}
+
+/* Replace STDIN with a pipe containing 'data' of length 'len'. */
+static void replace_stdin_with_bytes(const unsigned char *data, size_t len) {
+    int fds[2];
+    if (pipe(fds) != 0) {
+        /* If pipe fails, abort the test */
+        TEST_FAIL_MESSAGE("pipe() failed");
+    }
+
+    /* Save original stdin if not yet saved */
+    if (g_saved_stdin == -1) {
+        g_saved_stdin = dup(STDIN_FILENO);
+        TEST_ASSERT_NOT_EQUAL_MESSAGE(-1, g_saved_stdin, "dup(STDIN) failed");
+    }
+
+    /* Write all bytes to the write end */
+    size_t written = 0;
+    while (written < len) {
+        ssize_t w = write(fds[1], data + written, len - written);
+        TEST_ASSERT_TRUE_MESSAGE(w >= 0, "write() failed");
+        written += (size_t)w;
+    }
+    /* Close writer to signal EOF */
+    close(fds[1]);
+
+    /* Replace stdin */
+    TEST_ASSERT_NOT_EQUAL_MESSAGE(-1, dup2(fds[0], STDIN_FILENO), "dup2() failed");
+    close(fds[0]);
+}
+
+/* Replace STDIN with an immediate EOF (empty pipe) */
+static void replace_stdin_with_eof(void) {
+    int fds[2];
+    if (pipe(fds) != 0) {
+        TEST_FAIL_MESSAGE("pipe() failed");
+    }
+    if (g_saved_stdin == -1) {
+        g_saved_stdin = dup(STDIN_FILENO);
+        TEST_ASSERT_NOT_EQUAL_MESSAGE(-1, g_saved_stdin, "dup(STDIN) failed");
+    }
+    /* Close writer immediately to make reader see EOF */
+    close(fds[1]);
+    TEST_ASSERT_NOT_EQUAL_MESSAGE(-1, dup2(fds[0], STDIN_FILENO), "dup2() failed");
+    close(fds[0]);
+}
+
+static void assert_buf_equals(const unsigned char *buf, size_t n,
+                              const unsigned char *expected, size_t m) {
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)m, (uint64_t)n);
+    for (size_t i = 0; i < m; i++) {
+        if (buf[i] != expected[i]) {
+            char msg[128];
+            snprintf(msg, sizeof msg, "byte mismatch at index %zu", i);
+            TEST_FAIL_MESSAGE(msg);
+        }
+    }
+}
+
+void setUp(void) {
+    /* Ensure a clean delete set and save stdin for restoration */
+    reset_delete_set();
+    if (g_saved_stdin == -1) {
+        g_saved_stdin = dup(STDIN_FILENO);
+        TEST_ASSERT_NOT_EQUAL_MESSAGE(-1, g_saved_stdin, "dup(STDIN) in setUp failed");
+    }
+}
+
+void tearDown(void) {
+    /* Restore original stdin if changed */
+    if (g_saved_stdin != -1) {
+        int r = dup2(g_saved_stdin, STDIN_FILENO);
+        TEST_ASSERT_NOT_EQUAL_MESSAGE(-1, r, "dup2 restore in tearDown failed");
+        close(g_saved_stdin);
+        g_saved_stdin = -1;
+    }
+}
+
+/* 1) No deletions: should return all input unchanged */
+static void test_read_and_delete_no_deletion_returns_all(void) {
+    const unsigned char input[] = { 'a','b','c' };
+    replace_stdin_with_bytes(input, sizeof input);
+
+    unsigned char buf[16];
+    size_t n = read_and_delete((char*)buf, sizeof buf);
+
+    const unsigned char exp[] = { 'a','b','c' };
+    assert_buf_equals(buf, n, exp, sizeof exp);
+}
+
+/* 2) Delete specific characters in the middle and scattered */
+static void test_read_and_delete_deletes_specific_characters(void) {
+    reset_delete_set();
+    set_delete_byte((unsigned char)'b');
+    set_delete_byte((unsigned char)'x');
+    const unsigned char input[] = { 'a','b','b','b','x','c' }; /* -> "ac" */
+    replace_stdin_with_bytes(input, sizeof input);
+
+    unsigned char buf[16];
+    size_t n = read_and_delete((char*)buf, sizeof buf);
+
+    const unsigned char exp[] = { 'a','c' };
+    assert_buf_equals(buf, n, exp, sizeof exp);
+}
+
+/* 3) Deletions at the start of buffer */
+static void test_read_and_delete_deletes_at_start(void) {
+    reset_delete_set();
+    set_delete_byte((unsigned char)'b');
+    const unsigned char input[] = { 'b','b','a','b','c' }; /* -> "ac"? Actually 'b's deleted => "ac" */
+    replace_stdin_with_bytes(input, sizeof input);
+
+    unsigned char buf[16];
+    size_t n = read_and_delete((char*)buf, sizeof buf);
+
+    const unsigned char exp[] = { 'a','c' };
+    assert_buf_equals(buf, n, exp, sizeof exp);
+}
+
+/* 4) First read yields only deletions (n_saved==0), then next read yields data */
+static void test_read_and_delete_handles_two_reads_when_first_has_only_deletes(void) {
+    reset_delete_set();
+    set_delete_byte((unsigned char)'x');
+    const unsigned char input[] = { 'x','x','x','a','b','c' }; /* size=3 ensures 2 reads: "xxx" then "abc" */
+    replace_stdin_with_bytes(input, sizeof input);
+
+    unsigned char buf[3];
+    size_t n = read_and_delete((char*)buf, sizeof buf); /* size=3 */
+
+    const unsigned char exp[] = { 'a','b','c' };
+    assert_buf_equals(buf, n, exp, sizeof exp);
+}
+
+/* 5) All bytes deleted followed by EOF should return 0 */
+static void test_read_and_delete_returns_zero_when_all_deleted_and_eof(void) {
+    reset_delete_set();
+    set_delete_byte((unsigned char)'x');
+    const unsigned char input[] = { 'x','x','x' }; /* all deleted */
+    replace_stdin_with_bytes(input, sizeof input);
+
+    unsigned char buf[8];
+    size_t n = read_and_delete((char*)buf, sizeof buf);
+
+    TEST_ASSERT_EQUAL_UINT64(0, (uint64_t)n);
+}
+
+/* 6) Immediate EOF should return 0 */
+static void test_read_and_delete_returns_zero_on_immediate_eof(void) {
+    replace_stdin_with_eof();
+    unsigned char buf[8];
+    size_t n = read_and_delete((char*)buf, sizeof buf);
+    TEST_ASSERT_EQUAL_UINT64(0, (uint64_t)n);
+}
+
+/* 7) Ensure NUL bytes are preserved if not deleted and deletions elsewhere apply */
+static void test_read_and_delete_preserves_nul_bytes(void) {
+    reset_delete_set();
+    set_delete_byte((unsigned char)'A');
+    const unsigned char input[] = { 0x00, 'A', 0x00 };
+    replace_stdin_with_bytes(input, sizeof input);
+
+    unsigned char buf[8];
+    size_t n = read_and_delete((char*)buf, sizeof buf);
+
+    const unsigned char exp[] = { 0x00, 0x00 };
+    assert_buf_equals(buf, n, exp, sizeof exp);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+    RUN_TEST(test_read_and_delete_no_deletion_returns_all);
+    RUN_TEST(test_read_and_delete_deletes_specific_characters);
+    RUN_TEST(test_read_and_delete_deletes_at_start);
+    RUN_TEST(test_read_and_delete_handles_two_reads_when_first_has_only_deletes);
+    RUN_TEST(test_read_and_delete_returns_zero_when_all_deleted_and_eof);
+    RUN_TEST(test_read_and_delete_returns_zero_on_immediate_eof);
+    RUN_TEST(test_read_and_delete_preserves_nul_bytes);
+    return UNITY_END();
+}

tests/tr/tests_for_set_initialize.c

@@ -0,0 +1,188 @@
+#include "../../unity/unity.h"
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+
+/* The test file is included into the tr source after all internal
+   declarations, so we can use the program's internal symbols directly. */
+
+static size_t count_true(const bool *arr)
+{
+    size_t c = 0;
+    for (size_t i = 0; i < N_CHARS; i++)
+        if (arr[i]) c++;
+    return c;
+}
+
+static void clear_bool_array(bool *arr)
+{
+    memset(arr, 0, N_CHARS * sizeof(bool));
+}
+
+static void build_spec(const char *s, struct Spec_list *out)
+{
+    spec_init(out);
+    bool ok = parse_str(s, out);
+    TEST_ASSERT_TRUE_MESSAGE(ok, "parse_str failed for input spec");
+}
+
+void setUp(void) {
+    /* no-op */
+}
+
+void tearDown(void) {
+    /* no-op */
+}
+
+/* 1) Simple normal characters */
+void test_set_initialize_single_chars(void)
+{
+    struct Spec_list sp;
+    bool in_set[N_CHARS];
+    build_spec("ABC", &sp);
+    clear_bool_array(in_set);
+
+    set_initialize(&sp, false, in_set);
+
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'A']);
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'B']);
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'C']);
+    TEST_ASSERT_EQUAL_size_t(3u, count_true(in_set));
+}
+
+/* 2) Range a-d => a,b,c,d */
+void test_set_initialize_range(void)
+{
+    struct Spec_list sp;
+    bool in_set[N_CHARS];
+    build_spec("a-d", &sp);
+    clear_bool_array(in_set);
+
+    set_initialize(&sp, false, in_set);
+
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'a']);
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'b']);
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'c']);
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'d']);
+    TEST_ASSERT_EQUAL_size_t(4u, count_true(in_set));
+}
+
+/* 3) Character class [:digit:] => '0'..'9' */
+void test_set_initialize_char_class_digit(void)
+{
+    struct Spec_list sp;
+    bool in_set[N_CHARS];
+    build_spec("[[:digit:]]", &sp);
+    clear_bool_array(in_set);
+
+    set_initialize(&sp, false, in_set);
+
+    for (int i = 0; i <= 9; i++)
+        TEST_ASSERT_TRUE(in_set[(unsigned char)('0' + i)]);
+    TEST_ASSERT_FALSE(in_set[(unsigned char)'a']);
+    TEST_ASSERT_EQUAL_size_t(10u, count_true(in_set));
+}
+
+/* 4) Repeated character [x*5] => just 'x' is a member */
+void test_set_initialize_repeated_char_n(void)
+{
+    struct Spec_list sp;
+    bool in_set[N_CHARS];
+    build_spec("[x*5]", &sp);
+    clear_bool_array(in_set);
+
+    set_initialize(&sp, false, in_set);
+
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'x']);
+    TEST_ASSERT_EQUAL_size_t(1u, count_true(in_set));
+}
+
+/* 5) Indefinite repeat [q*] should contribute no members */
+void test_set_initialize_indefinite_repeat_zero_effect(void)
+{
+    struct Spec_list sp;
+    bool in_set[N_CHARS];
+    build_spec("A[q*]B", &sp);
+    clear_bool_array(in_set);
+
+    set_initialize(&sp, false, in_set);
+
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'A']);
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'B']);
+    TEST_ASSERT_FALSE(in_set[(unsigned char)'q']);
+    TEST_ASSERT_EQUAL_size_t(2u, count_true(in_set));
+}
+
+/* 6) Equivalence class [=m=] => behaves like 'm' in this implementation */
+void test_set_initialize_equiv_class_single_char(void)
+{
+    struct Spec_list sp;
+    bool in_set[N_CHARS];
+    build_spec("[=m=]", &sp);
+    clear_bool_array(in_set);
+
+    set_initialize(&sp, false, in_set);
+
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'m']);
+    TEST_ASSERT_EQUAL_size_t(1u, count_true(in_set));
+}
+
+/* 7) Complement behavior: complement of {'a'} => all except 'a' */
+void test_set_initialize_complement_simple(void)
+{
+    struct Spec_list sp;
+    bool in_set[N_CHARS];
+    build_spec("a", &sp);
+    clear_bool_array(in_set);
+
+    set_initialize(&sp, true, in_set);
+
+    TEST_ASSERT_FALSE(in_set[(unsigned char)'a']);
+    /* Count should be N_CHARS - 1 */
+    TEST_ASSERT_EQUAL_size_t((size_t)N_CHARS - 1, count_true(in_set));
+}
+
+/* 8) Composite spec: a-c, digits, Z, [=x=], [y*3], [q*] (no effect) */
+void test_set_initialize_composite_union(void)
+{
+    struct Spec_list sp;
+    bool in_set[N_CHARS];
+    build_spec("a-c[[:digit:]]Z[=x=][y*3][q*]", &sp);
+    clear_bool_array(in_set);
+
+    set_initialize(&sp, false, in_set);
+
+    /* Range a-c */
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'a']);
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'b']);
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'c']);
+    /* Digits */
+    for (int i = 0; i <= 9; i++)
+        TEST_ASSERT_TRUE(in_set[(unsigned char)('0' + i)]);
+    /* Z */
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'Z']);
+    /* [=x=] */
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'x']);
+    /* [y*3] */
+    TEST_ASSERT_TRUE(in_set[(unsigned char)'y']);
+    /* [q*] has no effect */
+    TEST_ASSERT_FALSE(in_set[(unsigned char)'q']);
+
+    /* Total expected: 3 (a-c) + 10 (digits) + 1 (Z) + 1 (x) + 1 (y) = 16 */
+    TEST_ASSERT_EQUAL_size_t(16u, count_true(in_set));
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_set_initialize_single_chars);
+    RUN_TEST(test_set_initialize_range);
+    RUN_TEST(test_set_initialize_char_class_digit);
+    RUN_TEST(test_set_initialize_repeated_char_n);
+    RUN_TEST(test_set_initialize_indefinite_repeat_zero_effect);
+    RUN_TEST(test_set_initialize_equiv_class_single_char);
+    RUN_TEST(test_set_initialize_complement_simple);
+    RUN_TEST(test_set_initialize_composite_union);
+    return UNITY_END();
+}

tests/tr/tests_for_squeeze_filter.c

@@ -0,0 +1,297 @@
+#include "../../unity/unity.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdbool.h>
+
+/* We are included into the tr.c translation unit, so we can access:
+   - static void squeeze_filter(char *buf, size_t size, size_t (*reader)(char*, size_t))
+   - static bool in_squeeze_set[N_CHARS];
+   - N_CHARS constant
+*/
+
+/* ------------------------ Test Harness Helpers ------------------------ */
+
+/* Reader context (globals local to this test file, to avoid passing ctx) */
+static const unsigned char *t_in_data = NULL;
+static size_t t_in_len = 0;
+static size_t t_in_pos = 0;
+static size_t t_reader_chunk = 0; /* max bytes returned per reader call */
+
+/* Reader implementation: returns up to min(size, t_reader_chunk, remaining) */
+static size_t test_reader_fixed_chunks(char *buf, size_t size)
+{
+    if (t_in_pos >= t_in_len)
+        return 0;
+    size_t remaining = t_in_len - t_in_pos;
+    size_t n = remaining;
+    if (t_reader_chunk > 0 && n > t_reader_chunk)
+        n = t_reader_chunk;
+    if (n > size)
+        n = size;
+    memcpy(buf, t_in_data + t_in_pos, n);
+    t_in_pos += n;
+    return n;
+}
+
+/* Clear and set the squeeze set */
+static void clear_squeeze_set(void)
+{
+    /* in_squeeze_set is defined in tr.c */
+    for (size_t i = 0; i < N_CHARS; i++)
+        in_squeeze_set[i] = false;
+}
+
+static void set_squeeze_chars(const unsigned char *chars, size_t n)
+{
+    clear_squeeze_set();
+    for (size_t i = 0; i < n; i++)
+        in_squeeze_set[chars[i]] = true;
+}
+
+/* Capture stdout produced by squeeze_filter into a buffer we return. */
+struct Captured {
+    char *data;
+    size_t len;
+};
+
+static struct Captured run_and_capture(const unsigned char *input, size_t in_len,
+                                       size_t reader_chunk, size_t squeeze_buf_size)
+{
+    struct Captured cap = { NULL, 0 };
+
+    /* Prepare temp file for capturing stdout */
+    FILE *tmpf = tmpfile();
+    if (!tmpf) {
+        TEST_FAIL_MESSAGE("tmpfile() failed; cannot capture stdout");
+    }
+    int tmpfd = fileno(tmpf);
+
+    /* Save and redirect stdout */
+    fflush(stdout);
+    int saved_stdout = dup(STDOUT_FILENO);
+    if (saved_stdout < 0) {
+        fclose(tmpf);
+        TEST_FAIL_MESSAGE("dup(STDOUT_FILENO) failed");
+    }
+    if (dup2(tmpfd, STDOUT_FILENO) < 0) {
+        int errsv = errno;
+        dup2(saved_stdout, STDOUT_FILENO);
+        close(saved_stdout);
+        fclose(tmpf);
+        (void)errsv; /* avoid unused warning */
+        TEST_FAIL_MESSAGE("dup2(tmpfd, STDOUT_FILENO) failed");
+    }
+
+    /* Setup reader ctx */
+    t_in_data = input;
+    t_in_len = in_len;
+    t_in_pos = 0;
+    t_reader_chunk = reader_chunk;
+
+    /* Run the function under test */
+    char *work_buf = (char *)malloc(squeeze_buf_size > 0 ? squeeze_buf_size : 1);
+    if (!work_buf) {
+        /* Restore stdout before failing */
+        fflush(stdout);
+        dup2(saved_stdout, STDOUT_FILENO);
+        close(saved_stdout);
+        fclose(tmpf);
+        TEST_FAIL_MESSAGE("malloc failed");
+    }
+
+    squeeze_filter(work_buf, squeeze_buf_size, test_reader_fixed_chunks);
+
+    free(work_buf);
+
+    /* Restore stdout */
+    fflush(stdout);
+    if (dup2(saved_stdout, STDOUT_FILENO) < 0) {
+        close(saved_stdout);
+        fclose(tmpf);
+        TEST_FAIL_MESSAGE("dup2(restore stdout) failed");
+    }
+    close(saved_stdout);
+
+    /* Read back captured output */
+    if (fseek(tmpf, 0, SEEK_END) != 0) {
+        fclose(tmpf);
+        TEST_FAIL_MESSAGE("fseek end failed");
+    }
+    long sz = ftell(tmpf);
+    if (sz < 0) {
+        fclose(tmpf);
+        TEST_FAIL_MESSAGE("ftell failed");
+    }
+    if (fseek(tmpf, 0, SEEK_SET) != 0) {
+        fclose(tmpf);
+        TEST_FAIL_MESSAGE("fseek set failed");
+    }
+
+    cap.len = (size_t)sz;
+    cap.data = (char *)malloc(cap.len ? cap.len : 1);
+    if (!cap.data) {
+        fclose(tmpf);
+        TEST_FAIL_MESSAGE("malloc for captured output failed");
+    }
+    size_t nread = fread(cap.data, 1, cap.len, tmpf);
+    fclose(tmpf);
+    if (nread != cap.len) {
+        free(cap.data);
+        cap.data = NULL;
+        cap.len = 0;
+        TEST_FAIL_MESSAGE("fread captured output failed");
+    }
+
+    return cap;
+}
+
+/* ------------------------ Unity Setup/Teardown ------------------------ */
+
+void setUp(void) {
+    /* Reset the squeeze set before each test */
+    clear_squeeze_set();
+}
+
+void tearDown(void) {
+    /* Nothing to cleanup */
+}
+
+/* ------------------------------ Tests -------------------------------- */
+
+/* No characters in squeeze set: output must equal input */
+void test_squeeze_filter_no_squeeze_set_identity(void)
+{
+    const char *in = "abcabc";
+    /* No squeeze chars set */
+    struct Captured cap = run_and_capture((const unsigned char*)in, strlen(in),
+                                          4 /*reader chunk*/, 64 /*buf size*/);
+    TEST_ASSERT_EQUAL_UINT64(strlen(in), cap.len);
+    TEST_ASSERT_EQUAL_MEMORY(in, cap.data, cap.len);
+    free(cap.data);
+}
+
+/* Squeeze runs of a single character inside one buffer */
+void test_squeeze_filter_single_char(void)
+{
+    const char *in = "aaabaaa";
+    const char *expected = "aba";
+    const unsigned char squeeze_chars[] = { (unsigned char)'a' };
+    set_squeeze_chars(squeeze_chars, 1);
+
+    struct Captured cap = run_and_capture((const unsigned char*)in, strlen(in),
+                                          64, 128);
+    TEST_ASSERT_EQUAL_UINT64(strlen(expected), cap.len);
+    TEST_ASSERT_EQUAL_MEMORY(expected, cap.data, cap.len);
+    free(cap.data);
+}
+
+/* Squeeze runs of multiple different characters; other chars preserved */
+void test_squeeze_filter_multiple_chars(void)
+{
+    const char *in = "aaabbbccbaaa";  /* runs of a & b; cc should remain */
+    const char *expected = "abccba";
+    const unsigned char squeeze_chars[] = { (unsigned char)'a', (unsigned char)'b' };
+    set_squeeze_chars(squeeze_chars, 2);
+
+    struct Captured cap = run_and_capture((const unsigned char*)in, strlen(in),
+                                          64, 128);
+    TEST_ASSERT_EQUAL_UINT64(strlen(expected), cap.len);
+    TEST_ASSERT_EQUAL_MEMORY(expected, cap.data, cap.len);
+    free(cap.data);
+}
+
+/* Boundary case: last byte of a buffer is in squeeze set and the run continues
+   in the next buffer. Ensure only a single occurrence is output across boundary. */
+void test_squeeze_filter_cross_boundary_run_continues(void)
+{
+    const char *in = "abbb";    /* 'b' squeezed, boundary after "ab" */
+    const char *expected = "ab";
+    const unsigned char squeeze_chars[] = { (unsigned char)'b' };
+    set_squeeze_chars(squeeze_chars, 1);
+
+    struct Captured cap = run_and_capture((const unsigned char*)in, strlen(in),
+                                          2 /*reader chunk to split after 'ab'*/, 64);
+    TEST_ASSERT_EQUAL_UINT64(strlen(expected), cap.len);
+    TEST_ASSERT_EQUAL_MEMORY(expected, cap.data, cap.len);
+    free(cap.data);
+}
+
+/* All bytes are squeezable and come in many small buffers: should yield one byte */
+void test_squeeze_filter_all_squeezed_across_many_buffers(void)
+{
+    const char *in = "xxxx";
+    const char *expected = "x";
+    const unsigned char squeeze_chars[] = { (unsigned char)'x' };
+    set_squeeze_chars(squeeze_chars, 1);
+
+    struct Captured cap = run_and_capture((const unsigned char*)in, strlen(in),
+                                          1 /*one byte per read*/, 16);
+    TEST_ASSERT_EQUAL_UINT64(strlen(expected), cap.len);
+    TEST_ASSERT_EQUAL_MEMORY(expected, cap.data, cap.len);
+    free(cap.data);
+}
+
+/* Repeats of non-squeezable characters must be preserved */
+void test_squeeze_filter_non_squeezable_repeats_preserved(void)
+{
+    const char *in = "bbbbbbb";  /* 'b' not squeezed */
+    const unsigned char squeeze_chars[] = { (unsigned char)'a' };
+    set_squeeze_chars(squeeze_chars, 1);
+
+    struct Captured cap = run_and_capture((const unsigned char*)in, strlen(in),
+                                          3 /*chunk*/, 32);
+    TEST_ASSERT_EQUAL_UINT64(strlen(in), cap.len);
+    TEST_ASSERT_EQUAL_MEMORY(in, cap.data, cap.len);
+    free(cap.data);
+}
+
+/* Non-ASCII byte handling: squeezing byte 0x80 across boundary */
+void test_squeeze_filter_non_ascii_byte(void)
+{
+    unsigned char in[] = { 0x80, 0x80, 'a', 0x80 };
+    unsigned char expected[] = { 0x80, 'a', 0x80 };
+    unsigned char squeeze_chars[] = { 0x80 };
+    set_squeeze_chars(squeeze_chars, 1);
+
+    struct Captured cap = run_and_capture(in, sizeof(in),
+                                          2 /*chunk to split after first two bytes*/, 32);
+    TEST_ASSERT_EQUAL_UINT64(sizeof(expected), cap.len);
+    TEST_ASSERT_EQUAL_MEMORY(expected, cap.data, cap.len);
+    free(cap.data);
+}
+
+/* Alternating runs with multiple squeezable chars across boundaries */
+void test_squeeze_filter_multiple_runs_across_boundaries(void)
+{
+    const char *in = "aaabbbcccaaabbb";
+    const char *expected = "abcccab"; /* 'a' and 'b' squeezed; 'c' preserved */
+    const unsigned char squeeze_chars[] = { (unsigned char)'a', (unsigned char)'b' };
+    set_squeeze_chars(squeeze_chars, 2);
+
+    /* Choose small reader chunk to force multiple boundaries */
+    struct Captured cap = run_and_capture((const unsigned char*)in, strlen(in),
+                                          3, 64);
+    TEST_ASSERT_EQUAL_UINT64(strlen(expected), cap.len);
+    TEST_ASSERT_EQUAL_MEMORY(expected, cap.data, cap.len);
+    free(cap.data);
+}
+
+/* ------------------------------ main --------------------------------- */
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_squeeze_filter_no_squeeze_set_identity);
+    RUN_TEST(test_squeeze_filter_single_char);
+    RUN_TEST(test_squeeze_filter_multiple_chars);
+    RUN_TEST(test_squeeze_filter_cross_boundary_run_continues);
+    RUN_TEST(test_squeeze_filter_all_squeezed_across_many_buffers);
+    RUN_TEST(test_squeeze_filter_non_squeezable_repeats_preserved);
+    RUN_TEST(test_squeeze_filter_non_ascii_byte);
+    RUN_TEST(test_squeeze_filter_multiple_runs_across_boundaries);
+    return UNITY_END();
+}

tests/tr/tests_for_star_digits_closebracket.c

@@ -0,0 +1,154 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+/* Helper to initialize an E_string from a C string literal. */
+static void es_init_from_cstr(struct E_string *es, const char *lit)
+{
+    size_t len = strlen(lit);
+    es->len = len;
+    es->s = (char*)malloc(len);
+    es->escaped = (bool*)calloc(len, sizeof(bool));
+    memcpy(es->s, lit, len);
+}
+
+/* Helper to free E_string allocated by es_init_from_cstr. */
+static void es_free_local(struct E_string *es)
+{
+    free(es->s);
+    free(es->escaped);
+    es->s = NULL;
+    es->escaped = NULL;
+    es->len = 0;
+}
+
+void setUp(void) {
+    /* Setup code here, or leave empty */
+}
+
+void tearDown(void) {
+    /* Cleanup code here, or leave empty */
+}
+
+/* 1) Basic true: "*]" starting at index 0 */
+void test_star_digits_closebracket_basic_true_empty_digits(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "*]");
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_TRUE(got);
+    es_free_local(&es);
+}
+
+/* 2) True with digits: "*123]" */
+void test_star_digits_closebracket_true_with_digits(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "*123]");
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_TRUE(got);
+    es_free_local(&es);
+}
+
+/* 3) True when pattern starts mid-string: "abc*456]xyz" at index 3 */
+void test_star_digits_closebracket_true_mid_string_start_index(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "abc*456]xyz");
+    bool got = star_digits_closebracket(&es, 3);
+    TEST_ASSERT_TRUE(got);
+    es_free_local(&es);
+}
+
+/* 4) False: starting character is not '*' */
+void test_star_digits_closebracket_false_starts_not_star(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "a*]");
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_FALSE(got);
+    es_free_local(&es);
+}
+
+/* 5) False: '*' is escaped */
+void test_star_digits_closebracket_false_star_escaped(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "*]");
+    es.escaped[0] = true; /* escape the '*' */
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_FALSE(got);
+    es_free_local(&es);
+}
+
+/* 6) False: closing ']' is escaped */
+void test_star_digits_closebracket_false_escaped_closing_bracket(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "*]");
+    es.escaped[1] = true; /* escape the ']' */
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_FALSE(got);
+    es_free_local(&es);
+}
+
+/* 7) False: an escaped digit occurs (escapes are not allowed) */
+void test_star_digits_closebracket_false_escaped_digit(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "*1]");
+    es.escaped[1] = true; /* escape the '1' */
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_FALSE(got);
+    es_free_local(&es);
+}
+
+/* 8) False: non-digit before ']' */
+void test_star_digits_closebracket_false_non_digit_before_close(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "*12a]");
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_FALSE(got);
+    es_free_local(&es);
+}
+
+/* 9) False: no closing bracket at all */
+void test_star_digits_closebracket_false_no_closing_bracket(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "*123");
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_FALSE(got);
+    es_free_local(&es);
+}
+
+/* 10) False: '*' at end of string (no room for "]") */
+void test_star_digits_closebracket_false_star_at_end(void)
+{
+    struct E_string es; es_init_from_cstr(&es, "abc*");
+    bool got = star_digits_closebracket(&es, 3);
+    TEST_ASSERT_FALSE(got);
+    es_free_local(&es);
+}
+
+/* 11) False: first non-digit after '*' is an escaped ']' (even if a later unescaped ']' exists) */
+void test_star_digits_closebracket_false_escaped_bracket_then_later_valid_bracket(void)
+{
+    /* String: "*1]2]" where the first ']' is escaped; function should stop at that escaped ']' and return false */
+    struct E_string es; es_init_from_cstr(&es, "*1]2]");
+    es.escaped[2] = true; /* escape the first ']' */
+    bool got = star_digits_closebracket(&es, 0);
+    TEST_ASSERT_FALSE(got);
+    es_free_local(&es);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_star_digits_closebracket_basic_true_empty_digits);
+    RUN_TEST(test_star_digits_closebracket_true_with_digits);
+    RUN_TEST(test_star_digits_closebracket_true_mid_string_start_index);
+    RUN_TEST(test_star_digits_closebracket_false_starts_not_star);
+    RUN_TEST(test_star_digits_closebracket_false_star_escaped);
+    RUN_TEST(test_star_digits_closebracket_false_escaped_closing_bracket);
+    RUN_TEST(test_star_digits_closebracket_false_escaped_digit);
+    RUN_TEST(test_star_digits_closebracket_false_non_digit_before_close);
+    RUN_TEST(test_star_digits_closebracket_false_no_closing_bracket);
+    RUN_TEST(test_star_digits_closebracket_false_star_at_end);
+    RUN_TEST(test_star_digits_closebracket_false_escaped_bracket_then_later_valid_bracket);
+    return UNITY_END();
+}

tests/tr/tests_for_string2_extend.c

@@ -0,0 +1,180 @@
+#include "../../unity/unity.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+/* The program under test has included this file after defining all
+   internal functions and globals. We can use its internal symbols here. */
+
+/* Helpers for tests */
+static void build_spec(struct Spec_list *s, const char *str)
+{
+    spec_init(s);
+    TEST_ASSERT_TRUE_MESSAGE(parse_str(str, s), "parse_str failed");
+}
+
+static size_t expand_spec(struct Spec_list *s, unsigned char *out, size_t max)
+{
+    size_t n = 0;
+    int c;
+    s->state = BEGIN_STATE;
+    while ((c = get_next(s, NULL)) != -1)
+    {
+        if (n < max) out[n] = (unsigned char)c;
+        n++;
+    }
+    return n;
+}
+
+void setUp(void) {
+    /* Ensure translating mode is enabled for string2_extend preconditions. */
+    translating = true;
+    /* Ensure defaults that don't interfere. */
+    complement = false;
+    truncate_set1 = false;
+}
+
+void tearDown(void) {
+    /* No persistent resources to clean. */
+}
+
+/* Test: s2 ends with a normal character; extend by repeating that char. */
+void test_string2_extend_after_normal_char(void)
+{
+    struct Spec_list s1, s2;
+    build_spec(&s1, "abcd");          /* length 4 */
+    get_s1_spec_stats(&s1);
+
+    build_spec(&s2, "ab");            /* length 2, ends with 'b' */
+    get_s2_spec_stats(&s2, s1.length);
+
+    TEST_ASSERT_TRUE(s1.length > s2.length);
+    size_t need = s1.length - s2.length;
+
+    string2_extend(&s1, &s2);
+
+    TEST_ASSERT_EQUAL_UINT64(s1.length, s2.length);
+    TEST_ASSERT_NOT_NULL(s2.tail);
+    TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, s2.tail->type);
+    TEST_ASSERT_EQUAL_UINT8('b', s2.tail->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64(need, s2.tail->u.repeated_char.repeat_count);
+
+    unsigned char buf[64];
+    size_t n = expand_spec(&s2, buf, sizeof buf);
+    TEST_ASSERT_EQUAL_UINT64(s1.length, n);
+    TEST_ASSERT_EQUAL_UINT8('a', buf[0]);
+    TEST_ASSERT_EQUAL_UINT8('b', buf[1]);
+    /* The rest should be 'b'. */
+    for (size_t i = 2; i < n; i++)
+        TEST_ASSERT_EQUAL_UINT8('b', buf[i]);
+}
+
+/* Test: s2 ends with a range; extend with last char of the range. */
+void test_string2_extend_after_range(void)
+{
+    struct Spec_list s1, s2;
+    build_spec(&s1, "abcde");         /* length 5 */
+    get_s1_spec_stats(&s1);
+
+    build_spec(&s2, "a-c");           /* expands to a,b,c (len 3), last 'c' */
+    get_s2_spec_stats(&s2, s1.length);
+
+    TEST_ASSERT_TRUE(s1.length > s2.length);
+    size_t need = s1.length - s2.length; /* expect 2 */
+
+    string2_extend(&s1, &s2);
+
+    TEST_ASSERT_EQUAL_UINT64(s1.length, s2.length);
+    TEST_ASSERT_NOT_NULL(s2.tail);
+    TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, s2.tail->type);
+    TEST_ASSERT_EQUAL_UINT8('c', s2.tail->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64(need, s2.tail->u.repeated_char.repeat_count);
+
+    unsigned char buf[64];
+    size_t n = expand_spec(&s2, buf, sizeof buf);
+    TEST_ASSERT_EQUAL_UINT64(s1.length, n);
+    TEST_ASSERT_EQUAL_UINT8('a', buf[0]);
+    TEST_ASSERT_EQUAL_UINT8('b', buf[1]);
+    TEST_ASSERT_EQUAL_UINT8('c', buf[2]);
+    for (size_t i = 3; i < n; i++)
+        TEST_ASSERT_EQUAL_UINT8('c', buf[i]);
+}
+
+/* Test: s2 ends with a repeated-char construct; extend with that char. */
+void test_string2_extend_after_repeated_char(void)
+{
+    struct Spec_list s1, s2;
+    build_spec(&s1, "[A*5]");         /* length 5 */
+    get_s1_spec_stats(&s1);
+
+    build_spec(&s2, "[x*3]");         /* length 3, last is RE_REPEATED_CHAR 'x' */
+    get_s2_spec_stats(&s2, s1.length);
+
+    TEST_ASSERT_TRUE(s1.length > s2.length);
+    size_t need = s1.length - s2.length; /* expect 2 */
+
+    string2_extend(&s1, &s2);
+
+    TEST_ASSERT_EQUAL_UINT64(s1.length, s2.length);
+    TEST_ASSERT_NOT_NULL(s2.tail);
+    TEST_ASSERT_EQUAL_INT(RE_REPEATED_CHAR, s2.tail->type);
+    TEST_ASSERT_EQUAL_UINT8('x', s2.tail->u.repeated_char.the_repeated_char);
+    TEST_ASSERT_EQUAL_UINT64(need, s2.tail->u.repeated_char.repeat_count);
+
+    unsigned char buf[64];
+    size_t n = expand_spec(&s2, buf, sizeof buf);
+    TEST_ASSERT_EQUAL_UINT64(s1.length, n);
+    for (size_t i = 0; i < n; i++)
+        TEST_ASSERT_EQUAL_UINT8('x', buf[i]);
+}
+
+/* Test: error path when s2 ends with a character class and needs extension.
+   We run in a child process to observe the EXIT_FAILURE without aborting tests. */
+void test_string2_extend_error_when_class_tail(void)
+{
+    struct Spec_list s1, s2;
+    build_spec(&s1, "[A*300]");       /* ensure s1.length > any class size */
+    get_s1_spec_stats(&s1);
+
+    build_spec(&s2, "[:lower:]");     /* ends with RE_CHAR_CLASS */
+    get_s2_spec_stats(&s2, s1.length);
+
+    TEST_ASSERT_TRUE(s1.length > s2.length);
+
+    fflush(stdout);
+    fflush(stderr);
+    pid_t pid = fork();
+    TEST_ASSERT_MESSAGE(pid >= 0, "fork failed");
+
+    if (pid == 0) {
+        /* Child: call the function expecting it to exit with failure. */
+        /* Avoid Unity asserts in child. */
+        string2_extend(&s1, &s2);
+        /* If we get here, the function did not exit as expected. */
+        _exit(0);
+    } else {
+        int status = 0;
+        pid_t w = waitpid(pid, &status, 0);
+        TEST_ASSERT_EQUAL_INT(pid, w);
+        TEST_ASSERT_TRUE(WIFEXITED(status));
+        /* Expect EXIT_FAILURE; accept any non-zero failure to be robust. */
+        int code = WEXITSTATUS(status);
+        TEST_ASSERT_TRUE_MESSAGE(code != 0, "Child did not exit with failure");
+    }
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_string2_extend_after_normal_char);
+    RUN_TEST(test_string2_extend_after_range);
+    RUN_TEST(test_string2_extend_after_repeated_char);
+    RUN_TEST(test_string2_extend_error_when_class_tail);
+    return UNITY_END();
+}

tests/tr/tests_for_unquote.c

@@ -0,0 +1,253 @@
+#include "../../unity/unity.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <unistd.h>
+
+/* Helper: capture stderr without affecting stdout (Unity uses stdout). */
+typedef struct {
+  int old_fd;
+  FILE *tmp;
+} StderrCapture;
+
+static void stderr_capture_start(StderrCapture *cap) {
+  fflush(stderr);
+  cap->old_fd = dup(STDERR_FILENO);
+  cap->tmp = tmpfile();
+  dup2(fileno(cap->tmp), STDERR_FILENO);
+}
+
+static char* stderr_capture_finish(StderrCapture *cap) {
+  fflush(stderr);
+  long size;
+  fseek(cap->tmp, 0, SEEK_END);
+  size = ftell(cap->tmp);
+  fseek(cap->tmp, 0, SEEK_SET);
+  char *buf = (char*)malloc((size_t)size + 1);
+  if (!buf) buf = NULL;
+  if (buf && size > 0) {
+    size_t n = fread(buf, 1, (size_t)size, cap->tmp);
+    buf[n] = '\0';
+  } else if (buf) {
+    buf[0] = '\0';
+  }
+  dup2(cap->old_fd, STDERR_FILENO);
+  close(cap->old_fd);
+  fclose(cap->tmp);
+  return buf;
+}
+
+/* Helper: assert E_string contents and escaped flags. */
+static void assert_es_eq(const struct E_string *es,
+                         const unsigned char *exp_bytes, size_t exp_len,
+                         const bool *exp_escaped /* may be NULL to skip */) {
+  TEST_ASSERT_NOT_NULL(es);
+  TEST_ASSERT_NOT_NULL(es->s);
+  TEST_ASSERT_NOT_NULL(es->escaped);
+  TEST_ASSERT_EQUAL_size_t(exp_len, es->len);
+  for (size_t i = 0; i < exp_len; i++) {
+    TEST_ASSERT_EQUAL_UINT8(exp_bytes[i], (unsigned char)es->s[i]);
+    if (exp_escaped) {
+      TEST_ASSERT_EQUAL_INT(exp_escaped[i], es->escaped[i]);
+    }
+  }
+}
+
+void setUp(void) {
+  /* no-op */
+}
+void tearDown(void) {
+  /* no-op */
+}
+
+/* Tests */
+
+static void test_unquote_no_escapes(void) {
+  struct E_string es;
+  const char *in = "abc";
+  bool ok = unquote(in, &es);
+  TEST_ASSERT_TRUE(ok);
+
+  unsigned char exp[] = { 'a', 'b', 'c' };
+  bool esc[] = { false, false, false };
+  assert_es_eq(&es, exp, sizeof(exp), esc);
+
+  es_free(&es);
+}
+
+static void test_unquote_standard_escapes(void) {
+  struct E_string es;
+  /* Input representing: \a \b \f \n \r \t \v \\ */
+  const char *in = "\\a\\b\\f\\n\\r\\t\\v\\\\";
+  bool ok = unquote(in, &es);
+  TEST_ASSERT_TRUE(ok);
+
+  unsigned char exp[] = { '\a', '\b', '\f', '\n', '\r', '\t', '\v', '\\' };
+  bool esc[] = { true,  true,  true,  true,  true,  true,  true,  true };
+  assert_es_eq(&es, exp, sizeof(exp), esc);
+
+  es_free(&es);
+}
+
+static void test_unquote_octal_basic(void) {
+  struct E_string es;
+
+  /* One digit octal: \7A -> 0x07, 'A' */
+  const char *in1 = "\\7A";
+  bool ok1 = unquote(in1, &es);
+  TEST_ASSERT_TRUE(ok1);
+  {
+    unsigned char exp1[] = { 7, 'A' };
+    bool esc1[] = { true, false };
+    assert_es_eq(&es, exp1, sizeof(exp1), esc1);
+    es_free(&es);
+  }
+
+  /* Two digit octal: \12 -> 0x0A (newline) */
+  const char *in2 = "\\12";
+  bool ok2 = unquote(in2, &es);
+  TEST_ASSERT_TRUE(ok2);
+  {
+    unsigned char exp2[] = { 10 };
+    bool esc2[] = { true };
+    assert_es_eq(&es, exp2, sizeof(exp2), esc2);
+    es_free(&es);
+  }
+
+  /* Three digit octal within range: \377X -> 255, 'X' */
+  const char *in3 = "\\377X";
+  bool ok3 = unquote(in3, &es);
+  TEST_ASSERT_TRUE(ok3);
+  {
+    unsigned char exp3[] = { 255, 'X' };
+    bool esc3[] = { true, false };
+    assert_es_eq(&es, exp3, sizeof(exp3), esc3);
+    es_free(&es);
+  }
+}
+
+static void test_unquote_octal_ambiguous_400_warns_and_leaves_digit(void) {
+  struct E_string es;
+  const char *in = "\\400"; /* 0400 would overflow 8-bit if third digit consumed */
+
+  StderrCapture cap;
+  stderr_capture_start(&cap);
+  bool ok = unquote(in, &es);
+  char *captured = stderr_capture_finish(&cap);
+
+  TEST_ASSERT_TRUE(ok);
+
+  /* Expect two outputs: ' ' (32) and '0' leftover */
+  unsigned char exp[] = { 32, '0' };
+  bool esc[] = { true, false };
+  assert_es_eq(&es, exp, sizeof(exp), esc);
+
+  /* Warning should be emitted */
+  TEST_ASSERT_NOT_NULL(captured);
+  TEST_ASSERT_TRUE_MESSAGE(strlen(captured) > 0, "Expected warning on stderr");
+  free(captured);
+
+  es_free(&es);
+}
+
+static void test_unquote_octal_ambiguous_777_warns_and_leaves_digit(void) {
+  struct E_string es;
+  const char *in = "\\777Y";
+
+  StderrCapture cap;
+  stderr_capture_start(&cap);
+  bool ok = unquote(in, &es);
+  char *captured = stderr_capture_finish(&cap);
+
+  TEST_ASSERT_TRUE(ok);
+
+  /* \77 -> 63 ('?'), leftover '7', then 'Y' */
+  unsigned char exp[] = { 63, '7', 'Y' };
+  bool esc[] = { true, false, false };
+  assert_es_eq(&es, exp, sizeof(exp), esc);
+
+  TEST_ASSERT_NOT_NULL(captured);
+  TEST_ASSERT_TRUE_MESSAGE(strlen(captured) > 0, "Expected warning on stderr");
+  free(captured);
+
+  es_free(&es);
+}
+
+static void test_unquote_unknown_escape(void) {
+  struct E_string es;
+  const char *in = "\\q";
+  bool ok = unquote(in, &es);
+  TEST_ASSERT_TRUE(ok);
+
+  unsigned char exp[] = { 'q' };
+  bool esc[] = { true };
+  assert_es_eq(&es, exp, sizeof(exp), esc);
+
+  es_free(&es);
+}
+
+static void test_unquote_trailing_backslash_warns_and_literal_backslash(void) {
+  struct E_string es;
+  const char *in = "\\";
+
+  StderrCapture cap;
+  stderr_capture_start(&cap);
+  bool ok = unquote(in, &es);
+  char *captured = stderr_capture_finish(&cap);
+
+  TEST_ASSERT_TRUE(ok);
+
+  /* Should produce a single backslash with escaped=false */
+  unsigned char exp[] = { '\\' };
+  bool esc[] = { false };
+  assert_es_eq(&es, exp, sizeof(exp), esc);
+
+  TEST_ASSERT_NOT_NULL(captured);
+  TEST_ASSERT_TRUE_MESSAGE(strlen(captured) > 0, "Expected warning on stderr");
+  free(captured);
+
+  es_free(&es);
+}
+
+static void test_unquote_zero_byte_produced(void) {
+  struct E_string es;
+  const char *in = "\\0X";
+  bool ok = unquote(in, &es);
+  TEST_ASSERT_TRUE(ok);
+
+  unsigned char exp[] = { 0, 'X' };
+  bool esc[] = { true, false };
+  assert_es_eq(&es, exp, sizeof(exp), esc);
+
+  es_free(&es);
+}
+
+static void test_unquote_mixed_sequence(void) {
+  struct E_string es;
+  const char *in = "ab\\n\\123z";
+  bool ok = unquote(in, &es);
+  TEST_ASSERT_TRUE(ok);
+
+  unsigned char exp[] = { 'a', 'b', '\n', 0123, 'z' };
+  bool esc[] = { false, false, true, true, false };
+  assert_es_eq(&es, exp, sizeof(exp), esc);
+
+  es_free(&es);
+}
+
+int main(void) {
+  UNITY_BEGIN();
+
+  RUN_TEST(test_unquote_no_escapes);
+  RUN_TEST(test_unquote_standard_escapes);
+  RUN_TEST(test_unquote_octal_basic);
+  RUN_TEST(test_unquote_octal_ambiguous_400_warns_and_leaves_digit);
+  RUN_TEST(test_unquote_octal_ambiguous_777_warns_and_leaves_digit);
+  RUN_TEST(test_unquote_unknown_escape);
+  RUN_TEST(test_unquote_trailing_backslash_warns_and_literal_backslash);
+  RUN_TEST(test_unquote_zero_byte_produced);
+  RUN_TEST(test_unquote_mixed_sequence);
+
+  return UNITY_END();
+}

tests/tr/tests_for_usage.c

@@ -0,0 +1,194 @@
+#include "../../unity/unity.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <errno.h>
+
+/* usage(int) is defined in the included program source. */
+extern void usage (int status);
+
+/* program_name is provided by gnulib (declared via earlier includes in the TU). */
+extern const char *program_name;
+
+static bool str_contains(const char *haystack, const char *needle) {
+    if (!haystack || !needle) return false;
+    return strstr(haystack, needle) != NULL;
+}
+
+typedef struct {
+    int exit_status;  /* -1 if did not exit normally */
+    char *out_buf;    /* captured stdout */
+    size_t out_len;
+    char *err_buf;    /* captured stderr */
+    size_t err_len;
+} UsageRunResult;
+
+static void free_result(UsageRunResult *r) {
+    if (!r) return;
+    free(r->out_buf);
+    free(r->err_buf);
+    r->out_buf = NULL;
+    r->err_buf = NULL;
+}
+
+static char *read_all_from_fd(int fd, size_t *out_len) {
+    size_t cap = 4096;
+    size_t len = 0;
+    char *buf = (char *)malloc(cap);
+    if (!buf) return NULL;
+
+    while (1) {
+        if (len == cap) {
+            size_t new_cap = cap * 2;
+            char *nb = (char *)realloc(buf, new_cap);
+            if (!nb) { free(buf); return NULL; }
+            buf = nb; cap = new_cap;
+        }
+        ssize_t n = read(fd, buf + len, cap - len);
+        if (n < 0) {
+            if (errno == EINTR) continue;
+            free(buf);
+            return NULL;
+        }
+        if (n == 0) break; /* EOF */
+        len += (size_t)n;
+    }
+    /* NUL-terminate for convenience in strstr, though binary-safe length is kept */
+    if (len == cap) {
+        char *nb = (char *)realloc(buf, cap + 1);
+        if (!nb) { free(buf); return NULL; }
+        buf = nb; cap += 1;
+    }
+    buf[len] = '\0';
+    if (out_len) *out_len = len;
+    return buf;
+}
+
+static UsageRunResult run_usage_and_capture(int status_to_pass, const char *progname_to_set) {
+    UsageRunResult res;
+    memset(&res, 0, sizeof(res));
+    res.exit_status = -1;
+    res.out_buf = NULL; res.err_buf = NULL; res.out_len = 0; res.err_len = 0;
+
+    int out_pipe[2];
+    int err_pipe[2];
+    if (pipe(out_pipe) != 0) return res;
+    if (pipe(err_pipe) != 0) { close(out_pipe[0]); close(out_pipe[1]); return res; }
+
+    fflush(stdout);
+    fflush(stderr);
+    pid_t pid = fork();
+    if (pid == -1) {
+        close(out_pipe[0]); close(out_pipe[1]);
+        close(err_pipe[0]); close(err_pipe[1]);
+        return res;
+    }
+
+    if (pid == 0) {
+        /* Child: redirect stdout/stderr, set program_name, then call usage */
+        /* Close read ends */
+        close(out_pipe[0]);
+        close(err_pipe[0]);
+        /* Duplicate write ends to stdout/stderr */
+        if (dup2(out_pipe[1], STDOUT_FILENO) == -1) _exit(127);
+        if (dup2(err_pipe[1], STDERR_FILENO) == -1) _exit(127);
+        /* Close original write ends */
+        close(out_pipe[1]);
+        close(err_pipe[1]);
+
+        /* Set the program name visible to usage() */
+        program_name = progname_to_set ? progname_to_set : "tr";
+
+        /* Call function under test; it will exit() */
+        usage(status_to_pass);
+        /* Should not reach here; ensure child exits */
+        _exit(127);
+    }
+
+    /* Parent */
+    close(out_pipe[1]);
+    close(err_pipe[1]);
+
+    res.out_buf = read_all_from_fd(out_pipe[0], &res.out_len);
+    res.err_buf = read_all_from_fd(err_pipe[0], &res.err_len);
+
+    close(out_pipe[0]);
+    close(err_pipe[0]);
+
+    int wstatus = 0;
+    if (waitpid(pid, &wstatus, 0) == pid) {
+        if (WIFEXITED(wstatus)) {
+            res.exit_status = WEXITSTATUS(wstatus);
+        } else {
+            res.exit_status = -1;
+        }
+    }
+
+    return res;
+}
+
+void setUp(void) {
+    /* Nothing needed */
+}
+
+void tearDown(void) {
+    /* Nothing needed */
+}
+
+/* Test that usage(EXIT_SUCCESS) prints full usage to stdout, exits 0, and not to stderr. */
+void test_usage_prints_help_to_stdout_and_exits_zero(void) {
+    UsageRunResult r = run_usage_and_capture(EXIT_SUCCESS, "tr");
+
+    TEST_ASSERT_EQUAL_INT_MESSAGE(0, r.exit_status, "usage(EXIT_SUCCESS) should exit(0)");
+    TEST_ASSERT_NOT_NULL_MESSAGE(r.out_buf, "stdout capture should not be NULL");
+    TEST_ASSERT_TRUE_MESSAGE(r.out_len > 0, "stdout should be non-empty for success case");
+    TEST_ASSERT_EQUAL_size_t_MESSAGE(0, r.err_len, "stderr should be empty for success case");
+
+    /* Check that the Usage line mentions the program name and expected tokens */
+    TEST_ASSERT_TRUE_MESSAGE(str_contains(r.out_buf, "Usage:"), "Output should contain 'Usage:'");
+    TEST_ASSERT_TRUE_MESSAGE(str_contains(r.out_buf, "Usage: tr "), "Usage line should reference program_name");
+    TEST_ASSERT_TRUE_MESSAGE(str_contains(r.out_buf, "STRING1"), "Output should mention STRING1");
+
+    free_result(&r);
+}
+
+/* Test that non-zero status emits try-help on stderr and exits with that status, stdout empty. */
+void test_usage_nonzero_emits_try_help_to_stderr_and_exits_status(void) {
+    int code = 2;
+    UsageRunResult r = run_usage_and_capture(code, "tr");
+
+    TEST_ASSERT_EQUAL_INT_MESSAGE(code, r.exit_status, "usage(nonzero) should exit with provided status");
+    TEST_ASSERT_EQUAL_size_t_MESSAGE(0, r.out_len, "stdout should be empty for nonzero status");
+    TEST_ASSERT_NOT_NULL_MESSAGE(r.err_buf, "stderr capture should not be NULL");
+    TEST_ASSERT_TRUE_MESSAGE(r.err_len > 0, "stderr should be non-empty for nonzero status");
+
+    /* Look for the '--help' hint and program name mention */
+    TEST_ASSERT_TRUE_MESSAGE(str_contains(r.err_buf, "--help"), "stderr should suggest --help");
+    TEST_ASSERT_TRUE_MESSAGE(str_contains(r.err_buf, "tr"), "stderr should mention program name");
+
+    free_result(&r);
+}
+
+/* Test that program_name is respected in the Usage line. */
+void test_usage_respects_program_name_variable(void) {
+    const char *alt = "mytr";
+    UsageRunResult r = run_usage_and_capture(EXIT_SUCCESS, alt);
+
+    TEST_ASSERT_EQUAL_INT_MESSAGE(0, r.exit_status, "usage(EXIT_SUCCESS) should exit(0)");
+    TEST_ASSERT_NOT_NULL_MESSAGE(r.out_buf, "stdout capture should not be NULL");
+    TEST_ASSERT_TRUE_MESSAGE(str_contains(r.out_buf, "Usage: mytr "), "Usage line should reflect custom program_name");
+
+    free_result(&r);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+    RUN_TEST(test_usage_prints_help_to_stdout_and_exits_zero);
+    RUN_TEST(test_usage_nonzero_emits_try_help_to_stderr_and_exits_status);
+    RUN_TEST(test_usage_respects_program_name_variable);
+    return UNITY_END();
+}

tests/tr/tests_for_validate.c

@@ -0,0 +1,239 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+/* The test file is included after the program source, so we can directly
+   use the program's internal functions and globals: spec_init, parse_str,
+   validate, get_next, etc., and flags translating, complement, truncate_set1. */
+
+static void init_spec_from_str(struct Spec_list *s, const char *str)
+{
+    spec_init(s);
+    bool ok = parse_str(str, s);
+    TEST_ASSERT_TRUE_MESSAGE(ok, "parse_str failed for test input");
+}
+
+/* Expand a spec into a C string for small ASCII-only tests. */
+static void expand_spec(struct Spec_list *s, char *out, size_t out_cap)
+{
+    size_t idx = 0;
+    s->state = BEGIN_STATE;
+    int c;
+    while ((c = get_next(s, NULL)) != -1 && idx + 1 < out_cap)
+    {
+        out[idx++] = (char)c;
+    }
+    out[idx] = '\0';
+}
+
+/* Run validate in a child process to capture exit on fatal errors without
+   stopping the whole test suite. Returns child's exit status (or 255 on error). */
+static int run_validate_in_child(const char *s1, const char *s2,
+                                 bool trans, bool comp, bool trunc)
+{
+    fflush(stdout);
+    fflush(stderr);
+    pid_t pid = fork();
+    if (pid < 0)
+        return 255;
+    if (pid == 0)
+    {
+        struct Spec_list a, b;
+        init_spec_from_str(&a, s1);
+        struct Spec_list *pb = NULL;
+        if (s2)
+        {
+            init_spec_from_str(&b, s2);
+            pb = &b;
+        }
+        translating = trans;
+        complement = comp;
+        truncate_set1 = trunc;
+        /* If validate returns, exit success (0). If it calls error(EXIT_FAILURE,
+           ...), the process will exit with EXIT_FAILURE. */
+        validate(&a, pb);
+        _exit(0);
+    }
+    int status = 0;
+    if (waitpid(pid, &status, 0) < 0)
+        return 255;
+    if (WIFEXITED(status))
+        return WEXITSTATUS(status);
+    return 255;
+}
+
+void setUp(void) {
+    /* Reset globals to safe defaults for each test. */
+    translating = false;
+    complement = false;
+    truncate_set1 = false;
+}
+void tearDown(void) {
+}
+
+/* Non-translating basic: s2 == NULL; length computed. */
+static void test_validate_non_translating_basic(void)
+{
+    struct Spec_list s1;
+    init_spec_from_str(&s1, "abc");
+    translating = false;
+    complement = false;
+    validate(&s1, NULL);
+    TEST_ASSERT_EQUAL_UINT64(3, (unsigned long long)s1.length);
+}
+
+/* Translating: equal lengths, no extension. */
+static void test_validate_translating_equal_lengths(void)
+{
+    struct Spec_list s1, s2;
+    init_spec_from_str(&s1, "ab");
+    init_spec_from_str(&s2, "XY");
+    translating = true;
+    complement = false;
+    truncate_set1 = false;
+    validate(&s1, &s2);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)s1.length,
+                             (unsigned long long)s2.length);
+    TEST_ASSERT_EQUAL_UINT64(2, (unsigned long long)s1.length);
+}
+
+/* Translating: string2 extended by repeating its last char. */
+static void test_validate_translating_extend_string2(void)
+{
+    struct Spec_list s1, s2;
+    init_spec_from_str(&s1, "abcd");
+    init_spec_from_str(&s2, "XY");
+    translating = true;
+    complement = false;
+    truncate_set1 = false;
+    validate(&s1, &s2);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)s1.length,
+                             (unsigned long long)s2.length);
+    char buf[16];
+    expand_spec(&s2, buf, sizeof buf);
+    TEST_ASSERT_EQUAL_STRING("XYYY", buf);
+}
+
+/* Translating with --truncate-set1: no extension of string2. */
+static void test_validate_translating_no_extend_when_truncate(void)
+{
+    struct Spec_list s1, s2;
+    init_spec_from_str(&s1, "abcd");
+    init_spec_from_str(&s2, "XY");
+    translating = true;
+    complement = false;
+    truncate_set1 = true;
+    validate(&s1, &s2);
+    TEST_ASSERT_EQUAL_UINT64(4, (unsigned long long)s1.length);
+    TEST_ASSERT_EQUAL_UINT64(2, (unsigned long long)s2.length);
+}
+
+/* Case classes aligned: [:upper:] vs [:lower:] with trailing literals.
+   Lengths both discounted to 2 independent of actual class sizes. */
+static void test_validate_case_class_alignment_success_and_length_adjust(void)
+{
+    struct Spec_list s1, s2;
+    init_spec_from_str(&s1, "[:upper:]a");
+    init_spec_from_str(&s2, "[:lower:]b");
+    translating = true;
+    complement = false;
+    truncate_set1 = false;
+    validate(&s1, &s2);
+    TEST_ASSERT_EQUAL_UINT64(2, (unsigned long long)s1.length);
+    TEST_ASSERT_EQUAL_UINT64(2, (unsigned long long)s2.length);
+}
+
+/* Complemented class with homogeneous s2 mapping: valid. */
+static void test_validate_complement_class_homogeneous_ok(void)
+{
+    struct Spec_list s1, s2;
+    init_spec_from_str(&s1, "[:digit:]");
+    init_spec_from_str(&s2, "[X*]");
+    translating = true;
+    complement = true;
+    truncate_set1 = false;
+    validate(&s1, &s2);
+    TEST_ASSERT_EQUAL_UINT64((unsigned long long)s1.length,
+                             (unsigned long long)s2.length);
+}
+
+/* Error: s2 has equivalence class when translating. */
+static void test_validate_error_s2_equiv_class(void)
+{
+    int st = run_validate_in_child("A", "[=A=]", true, false, false);
+    TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, st);
+}
+
+/* Error: s2 empty and extension required without --truncate-set1. */
+static void test_validate_error_s2_empty_requires_non_truncate(void)
+{
+    int st = run_validate_in_child("abc", "", true, false, false);
+    TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, st);
+}
+
+/* Error: multiple [c*] constructs in string2. */
+static void test_validate_error_multiple_indefinite_in_s2(void)
+{
+    int st = run_validate_in_child("abcd", "[X*][Y*]", true, false, false);
+    TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, st);
+}
+
+/* Error: [c*] appears in string1. */
+static void test_validate_error_indefinite_in_s1(void)
+{
+    int st = run_validate_in_child("[X*]", "A", false, false, false);
+    TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, st);
+}
+
+/* Error: restricted class (e.g., [:digit:]) in string2 when translating. */
+static void test_validate_error_s2_restricted_class(void)
+{
+    int st = run_validate_in_child("ab", "[:digit:]", true, false, false);
+    TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, st);
+}
+
+/* Error: misaligned case classes (s2 uses [:upper:] but s1 doesn't). */
+static void test_validate_error_misaligned_case_classes(void)
+{
+    int st = run_validate_in_child("abc", "[:upper:]", true, false, false);
+    TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, st);
+}
+
+/* Error: extending s2 that ends with a character class. */
+static void test_validate_error_extend_with_trailing_class(void)
+{
+    /* s1 two lower classes, s2 one lower class, so extension needed. */
+    int st = run_validate_in_child("[:lower:][:lower:]", "[:lower:]", true, false, false);
+    TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, st);
+}
+
+/* Error: complemented class translating must map all to one char (non-homogeneous s2). */
+static void test_validate_error_complement_class_nonhomogeneous(void)
+{
+    int st = run_validate_in_child("[:digit:]", "AB", true, true, false);
+    TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, st);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_validate_non_translating_basic);
+    RUN_TEST(test_validate_translating_equal_lengths);
+    RUN_TEST(test_validate_translating_extend_string2);
+    RUN_TEST(test_validate_translating_no_extend_when_truncate);
+    RUN_TEST(test_validate_case_class_alignment_success_and_length_adjust);
+    RUN_TEST(test_validate_complement_class_homogeneous_ok);
+    RUN_TEST(test_validate_error_s2_equiv_class);
+    RUN_TEST(test_validate_error_s2_empty_requires_non_truncate);
+    RUN_TEST(test_validate_error_multiple_indefinite_in_s2);
+    RUN_TEST(test_validate_error_indefinite_in_s1);
+    RUN_TEST(test_validate_error_s2_restricted_class);
+    RUN_TEST(test_validate_error_misaligned_case_classes);
+    RUN_TEST(test_validate_error_extend_with_trailing_class);
+    RUN_TEST(test_validate_error_complement_class_nonhomogeneous);
+    return UNITY_END();
+}

tests/tr/tests_for_validate_case_classes.c

@@ -0,0 +1,156 @@
+#include "../../unity/unity.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+/* Helper: build a Spec_list from a pattern string and compute stats. */
+static void build_spec_with_stats(const char *spec_str, struct Spec_list *s)
+{
+    spec_init(s);
+    TEST_ASSERT_TRUE_MESSAGE(parse_str(spec_str, s), "parse_str() failed");
+    get_spec_stats(s);
+}
+
+void setUp(void) {
+    /* Reset any global state that might affect validate_case_classes. */
+    /* Explicitly ensure complement is false by default. */
+    complement = false;
+}
+
+void tearDown(void) {
+    /* Ensure complement is reset for any subsequent tests. */
+    complement = false;
+}
+
+/* Test: Early return when complement is true. Nothing should change. */
+void test_validate_case_classes_noop_when_complement(void)
+{
+    complement = true;
+
+    struct Spec_list s1, s2;
+    build_spec_with_stats("[:upper:]", &s1);
+    build_spec_with_stats("[:lower:]", &s2);
+
+    uintmax_t len1_before = s1.length;
+    uintmax_t len2_before = s2.length;
+    struct List_element *t1_before = s1.tail;
+    struct List_element *t2_before = s2.tail;
+
+    validate_case_classes(&s1, &s2);
+
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)len1_before, (uint64_t)s1.length);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)len2_before, (uint64_t)s2.length);
+    TEST_ASSERT_TRUE(s1.tail == t1_before);
+    TEST_ASSERT_TRUE(s2.tail == t2_before);
+
+    complement = false; /* restore */
+}
+
+/* Test: Early return when s2 has no character class. Nothing should change. */
+void test_validate_case_classes_noop_when_s2_has_no_char_class(void)
+{
+    struct Spec_list s1, s2;
+    build_spec_with_stats("ABC", &s1);
+    build_spec_with_stats("xyz", &s2);
+
+    /* Ensure s2 has no char class according to computed stats. */
+    TEST_ASSERT_FALSE(s2.has_char_class);
+
+    uintmax_t len1_before = s1.length;
+    uintmax_t len2_before = s2.length;
+    struct List_element *t1_before = s1.tail;
+    struct List_element *t2_before = s2.tail;
+
+    validate_case_classes(&s1, &s2);
+
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)len1_before, (uint64_t)s1.length);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)len2_before, (uint64_t)s2.length);
+    TEST_ASSERT_TRUE(s1.tail == t1_before);
+    TEST_ASSERT_TRUE(s2.tail == t2_before);
+}
+
+/* Test: Lengths are adjusted for aligned case classes, with surrounding chars. */
+void test_validate_case_classes_adjusts_lengths_on_aligned_classes(void)
+{
+    /* s1: X [:upper:] Y; s2: x [:lower:] z */
+    struct Spec_list s1, s2;
+    build_spec_with_stats("X[:upper:]Y", &s1);
+    build_spec_with_stats("x[:lower:]z", &s2);
+
+    /* Precondition: s2 has char class so function will act. */
+    TEST_ASSERT_TRUE(s2.has_char_class);
+
+    struct List_element *t1_before = s1.tail;
+    struct List_element *t2_before = s2.tail;
+
+    validate_case_classes(&s1, &s2);
+
+    /* After adjustment, each class contributes 1, so total lengths should be 3. */
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)3, (uint64_t)s1.length);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)3, (uint64_t)s2.length);
+
+    /* Tail pointers must be restored. */
+    TEST_ASSERT_TRUE(s1.tail == t1_before);
+    TEST_ASSERT_TRUE(s2.tail == t2_before);
+}
+
+/* Test: Multiple aligned pairs adjust total length to number of constructs. */
+void test_validate_case_classes_multiple_pairs(void)
+{
+    struct Spec_list s1, s2;
+    build_spec_with_stats("[:upper:][:lower:]", &s1);
+    build_spec_with_stats("[:lower:][:upper:]", &s2);
+
+    TEST_ASSERT_TRUE(s2.has_char_class);
+
+    validate_case_classes(&s1, &s2);
+
+    /* Two constructs remain, each contributing 1 after adjustment. */
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)2, (uint64_t)s1.length);
+    TEST_ASSERT_EQUAL_UINT64((uint64_t)2, (uint64_t)s2.length);
+}
+
+/* Test: Misalignment triggers fatal error (process exits with EXIT_FAILURE). */
+void test_validate_case_classes_misaligned_triggers_exit(void)
+{
+    fflush(stdout);
+    fflush(stderr);
+    pid_t pid = fork();
+    TEST_ASSERT_TRUE_MESSAGE(pid >= 0, "fork failed");
+
+    if (pid == 0) {
+        /* Child process: set up misaligned specs and call the function. */
+        complement = false;
+        struct Spec_list s1, s2;
+        spec_init(&s1);
+        spec_init(&s2);
+        if (!parse_str("ABC", &s1) || !parse_str("[:lower:]", &s2)) {
+            _exit(200); /* setup failure */
+        }
+        get_spec_stats(&s1);
+        get_spec_stats(&s2);
+        /* This should call error(EXIT_FAILURE, ...), exiting the process. */
+        validate_case_classes(&s1, &s2);
+        _exit(201); /* Should not reach here. */
+    } else {
+        int status = 0;
+        pid_t w = waitpid(pid, &status, 0);
+        TEST_ASSERT_TRUE_MESSAGE(w == pid, "waitpid failed");
+        TEST_ASSERT_TRUE_MESSAGE(WIFEXITED(status), "child did not exit normally");
+        int ec = WEXITSTATUS(status);
+        TEST_ASSERT_EQUAL_INT(EXIT_FAILURE, ec);
+    }
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_validate_case_classes_noop_when_complement);
+    RUN_TEST(test_validate_case_classes_noop_when_s2_has_no_char_class);
+    RUN_TEST(test_validate_case_classes_adjusts_lengths_on_aligned_classes);
+    RUN_TEST(test_validate_case_classes_multiple_pairs);
+    RUN_TEST(test_validate_case_classes_misaligned_triggers_exit);
+    return UNITY_END();
+}

tests/tr/tr-case-class.sh

@@ -0,0 +1,116 @@
+#!/bin/sh
+# Test case conversion classes
+
+# Copyright (C) 2010-2025 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+. "${srcdir=.}/tests/init.sh"; path_prepend_ ./src
+print_ver_ tr
+
+# Ensure we support translation of case classes with extension
+echo '01234567899999999999999999' > exp
+echo 'abcdefghijklmnopqrstuvwxyz' |
+tr '[:lower:]' '0-9' > out || fail=1
+compare exp out || fail=1
+echo 'abcdefghijklmnopqrstuvwxyz' |
+tr '[:lower:][:lower:]' '[:upper:]0-9' > out || fail=1
+compare exp out || fail=1
+
+# Validate the alignment of case classes
+returns_ 1 tr 'A-Z[:lower:]' 'a-y[:upper:]' </dev/null || fail=1
+returns_ 1 tr '[:upper:][:lower:]' 'a-y[:upper:]' </dev/null || fail=1
+returns_ 1 tr 'A-Y[:lower:]' 'a-z[:upper:]' </dev/null || fail=1
+returns_ 1 tr 'A-Z[:lower:]' '[:lower:][:upper:]' </dev/null || fail=1
+returns_ 1 tr 'A-Z[:lower:]' '[:lower:]A-Z' </dev/null || fail=1
+tr '[:upper:][:lower:]' 'a-z[:upper:]' < /dev/null || fail=1
+tr '[:upper:][:lower:]' '[:upper:]a-z' < /dev/null || fail=1
+
+# Before coreutils 8.6 the trailing space in string1
+# caused the case class in string2 to be extended.
+# However that was not portable, dependent on locale
+# and in contravention of POSIX.
+tr '[:upper:] ' '[:lower:]' < /dev/null 2>out && fail=1
+echo 'tr: when translating with string1 longer than string2,
+the latter string must not end with a character class' > exp
+compare exp out || fail=1
+
+# Up to coreutils-6.9, tr rejected an unmatched [:lower:] or [:upper:] in SET1.
+echo '#$%123abcABC' | tr '[:lower:]' '[.*]' > out || fail=1
+echo '#$%123...ABC' > exp
+compare exp out || fail=1
+echo '#$%123abcABC' | tr '[:upper:]' '[.*]' > out || fail=1
+echo '#$%123abc...' > exp
+compare exp out || fail=1
+
+# When doing a case-converting translation with something after the
+# [:upper:] and [:lower:] elements, ensure that tr honors the following byte.
+echo 'abc.' | tr '[:lower:].' '[:upper:]x' > out || fail=1
+echo 'ABCx' > exp
+compare exp out || fail=1
+
+# Before coreutils 8.6 the disparate number of upper and lower
+# characters in some locales, triggered abort()s and invalid behavior
+export LC_ALL=en_US.ISO-8859-1
+
+if test "$(locale charmap 2>/dev/null)" = ISO-8859-1; then
+  # Up to coreutils-6.9.91, this would fail with the diagnostic:
+  # tr: misaligned [:upper:] and/or [:lower:] construct
+  # with LC_CTYPE=en_US.ISO-8859-1.
+  tr '[:upper:]' '[:lower:]' < /dev/null || fail=1
+
+  tr '[:upper:] ' '[:lower:]' < /dev/null 2>out && fail=1
+  echo 'tr: when translating with string1 longer than string2,
+the latter string must not end with a character class' > exp
+  compare exp out || fail=1
+
+  # Ensure when there are a different number of elements
+  # in each string, we validate the case mapping correctly
+  echo 'abc.xyz' |
+  tr 'ab[:lower:]' '0-1[:upper:]' > out || fail=1
+  echo 'ABC.XYZ' > exp
+  compare exp out || fail=1
+
+  # Ensure we extend string2 appropriately
+  echo 'ABC- XYZ' |
+  tr '[:upper:]- ' '[:lower:]_' > out || fail=1
+  echo 'abc__xyz' > exp
+  compare exp out || fail=1
+
+  # Ensure the size of the case classes are accounted
+  # for as a unit.
+  echo 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' |
+  tr '[:upper:]A-B' '[:lower:]0' >out || fail=1
+  echo '00cdefghijklmnopqrstuvwxyz' > exp
+  compare exp out || fail=1
+
+  # Ensure the size of the case classes are accounted
+  # for as a unit.
+  echo 'a' |
+  tr -t '[:lower:]a' '[:upper:]0' >out || fail=1
+  echo '0' > exp
+  compare exp out || fail=1
+
+  # Ensure the size of the case classes are accounted
+  # for as a unit.
+  echo 'a' |
+  tr -t '[:lower:][:lower:]a' '[:lower:][:upper:]0' >out || fail=1
+  echo '0' > exp
+  compare exp out || fail=1
+fi
+
+# coreutils 8.6 - 8.32 inclusive, would abort trying to validate the following
+returns_ 1 tr -c '[:upper:]\000-\370' '[:lower:]' < /dev/null || fail=1
+
+Exit $fail

tests/tr/tr.pl

@@ -0,0 +1,174 @@
+#!/usr/bin/perl
+
+# Copyright (C) 2008-2025 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use strict;
+
+my $prog = 'tr';
+
+# Turn off localization of executable's output.
+@ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3;
+
+my $map_all_to_1 =
+  "$prog: when translating with complemented character classes,\n"
+    . "string2 must map all characters in the domain to one\n";
+
+my @Tests =
+(
+  ['1', qw(abcd '[]*]'),   {IN=>'abcd'}, {OUT=>']]]]'}],
+  ['2', qw(abc '[%*]xyz'), {IN=>'abc'}, {OUT=>'xyz'}],
+  ['3', qw('' '[.*]'),     {IN=>'abc'}, {OUT=>'abc'}],
+
+  # Test --truncate-set1 behavior when string1 is longer than string2
+  ['4', qw(-t abcd xy), {IN=>'abcde'}, {OUT=>'xycde'}],
+  # Test bsd behavior (the default) when string1 is longer than string2
+  ['5', qw(abcd xy), {IN=>'abcde'}, {OUT=>'xyyye'}],
+  # Do it the posix way
+  ['6', qw(abcd 'x[y*]'), {IN=>'abcde'}, {OUT=>'xyyye'}],
+  ['7', qw(-s a-p '%[.*]$'), {IN=>'abcdefghijklmnop'}, {OUT=>'%.$'}],
+  ['8', qw(-s a-p '[.*]$'), {IN=>'abcdefghijklmnop'}, {OUT=>'.$'}],
+  ['9', qw(-s a-p '%[.*]'), {IN=>'abcdefghijklmnop'}, {OUT=>'%.'}],
+  ['a', qw(-s '[a-z]'), {IN=>'aabbcc'}, {OUT=>'abc'}],
+  ['b', qw(-s '[a-c]'), {IN=>'aabbcc'}, {OUT=>'abc'}],
+  ['c', qw(-s '[a-b]'), {IN=>'aabbcc'}, {OUT=>'abcc'}],
+  ['d', qw(-s '[b-c]'), {IN=>'aabbcc'}, {OUT=>'aabc'}],
+  ['e', qw(-s '[\0-\5]'),
+   {IN=>"\0\0a\1\1b\2\2\2c\3\3\3d\4\4\4\4e\5\5"}, {OUT=>"\0a\1b\2c\3d\4e\5"}],
+  # tests of delete
+  ['f', qw(-d '[=[=]'), {IN=>'[[[[[[[]]]]]]]]'}, {OUT=>']]]]]]]]'}],
+  ['g', qw(-d '[=]=]'), {IN=>'[[[[[[[]]]]]]]]'}, {OUT=>'[[[[[[['}],
+  ['h', qw(-d '[:xdigit:]'), {IN=>'0123456789acbdefABCDEF'}, {OUT=>''}],
+  ['i', qw(-d '[:xdigit:]'), {IN=>'w0x1y2z3456789acbdefABCDEFz'},
+   {OUT=>'wxyzz'}],
+  ['j', qw(-d '[:digit:]'), {IN=>'0123456789'}, {OUT=>''}],
+  ['k', qw(-d '[:digit:]'),
+   {IN=>'a0b1c2d3e4f5g6h7i8j9k'}, {OUT=>'abcdefghijk'}],
+  ['l', qw(-d '[:lower:]'), {IN=>'abcdefghijklmnopqrstuvwxyz'}, {OUT=>''}],
+  ['m', qw(-d '[:upper:]'), {IN=>'ABCDEFGHIJKLMNOPQRSTUVWXYZ'}, {OUT=>''}],
+  ['n', qw(-d '[:lower:][:upper:]'),
+   {IN=>'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'}, {OUT=>''}],
+  ['o', qw(-d '[:alpha:]'),
+   {IN=>'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'}, {OUT=>''}],
+  ['p', qw(-d '[:alnum:]'),
+   {IN=>'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'},
+   {OUT=>''}],
+  ['q', qw(-d '[:alnum:]'),
+   {IN=>'.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.'},
+   {OUT=>'..'}],
+  ['r', qw(-ds '[:alnum:]' .),
+   {IN=>'.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.'},
+   {OUT=>'.'}],
+
+  # The classic example, with string2 BSD-style
+  ['s', qw(-cs '[:alnum:]' '\n'),
+   {IN=>'The big black fox jumped over the fence.'},
+   {OUT=>"The\nbig\nblack\nfox\njumped\nover\nthe\nfence\n"}],
+
+  # The classic example, POSIX-style
+  ['t', qw(-cs '[:alnum:]' '[\n*]'),
+   {IN=>'The big black fox jumped over the fence.'},
+   {OUT=>"The\nbig\nblack\nfox\njumped\nover\nthe\nfence\n"}],
+  ['u', qw(-ds b a), {IN=>'aabbaa'}, {OUT=>'a'}],
+  ['v', qw(-ds '[:xdigit:]' Z), {IN=>'ZZ0123456789acbdefABCDEFZZ'}, {OUT=>'Z'}],
+
+  # Try some data with 8th bit set in case something is mistakenly
+  # sign-extended.
+  ['w', qw(-ds '\350' '\345'),
+   {IN=>"\300\301\377\345\345\350\345"},
+   {OUT=>"\300\301\377\345"}],
+  ['x', qw(-s abcdefghijklmn '[:*016]'),
+   {IN=>'abcdefghijklmnop'}, {OUT=>':op'}],
+  ['y', qw(-d a-z), {IN=>'abc $code'}, {OUT=>' $'}],
+  ['z', qw(-ds a-z '$.'), {IN=>'a.b.c $$$$code\\'}, {OUT=>'. $\\'}],
+
+  # Make sure that a-a is accepted.
+  ['range-a-a', qw(a-a z), {IN=>'abc'}, {OUT=>'zbc'}],
+  #
+  ['null', qw(a ''), {IN=>''}, {OUT=>''}, {EXIT=>1},
+   {ERR=>"$prog: when not truncating set1, string2 must be non-empty\n"}],
+  ['upcase', qw('[:lower:]' '[:upper:]'),
+   {IN=>'abcxyzABCXYZ'},
+   {OUT=>'ABCXYZABCXYZ'}],
+  ['dncase', qw('[:upper:]' '[:lower:]'),
+   {IN=>'abcxyzABCXYZ'},
+   {OUT=>'abcxyzabcxyz'}],
+  #
+  ['rep-cclass', qw('a[=*2][=c=]' xyyz), {IN=>'a=c'}, {OUT=>'xyz'}],
+  ['rep-1', qw('[:*3][:digit:]' a-m), {IN=>':1239'}, {OUT=>'cefgm'}],
+  ['rep-2', qw('a[b*512]c' '1[x*]2'), {IN=>'abc'}, {OUT=>'1x2'}],
+  ['rep-3', qw('a[b*513]c' '1[x*]2'), {IN=>'abc'}, {OUT=>'1x2'}],
+  # Another couple octal repeat count tests.
+  ['o-rep-1', qw('[b*08]' '[x*]'), {IN=>''}, {OUT=>''}, {EXIT=>1},
+   {ERR=>"$prog: invalid repeat count '08' in [c*n] construct\n"}],
+  ['o-rep-2', qw('[b*010]cd' '[a*7]BC[x*]'), {IN=>'bcd'}, {OUT=>'BCx'}],
+
+  ['esc', qw('a\-z' A-Z), {IN=>'abc-z'}, {OUT=>'AbcBC'}],
+  ['bs-055', qw('a\055b' def), {IN=>"a\055b"}, {OUT=>'def'}],
+  ['bs-at-end', qw('\\' x), {IN=>"\\"}, {OUT=>'x'},
+   {ERR=>"$prog: warning: an unescaped backslash at end of "
+    . "string is not portable\n"}],
+
+  #
+  # From Ross
+  ['ross-0a', qw(-cs '[:upper:]' 'X[Y*]'), {IN=>''}, {OUT=>''}, {EXIT=>1},
+   {ERR=>$map_all_to_1}],
+  ['ross-0b', qw(-cs '[:cntrl:]' 'X[Y*]'), {IN=>''}, {OUT=>''}, {EXIT=>1},
+   {ERR=>$map_all_to_1}],
+  ['ross-1a', qw(-cs '[:upper:]' '[X*]'),
+   {IN=>'AMZamz123.-+AMZ'}, {OUT=>'AMZXAMZ'}],
+  ['ross-1b', qw(-cs '[:upper:][:digit:]' '[Z*]'), {IN=>''}, {OUT=>''}],
+  ['ross-2', qw(-dcs '[:lower:]' n-rs-z),
+   {IN=>'amzAMZ123.-+amz'}, {OUT=>'amzamz'}],
+  ['ross-3', qw(-ds '[:xdigit:]' '[:alnum:]'),
+   {IN=>'.ZABCDEFGzabcdefg.0123456788899.GG'}, {OUT=>'.ZGzg..G'}],
+  ['ross-4', qw(-dcs '[:alnum:]' '[:digit:]'), {IN=>''}, {OUT=>''}],
+  ['ross-5', qw(-dc '[:lower:]'), {IN=>''}, {OUT=>''}],
+  ['ross-6', qw(-dc '[:upper:]'), {IN=>''}, {OUT=>''}],
+
+  # Ensure that these fail.
+  # Prior to 2.0.20, each would evoke a failed assertion.
+  ['empty-eq', qw('[==]' x), {IN=>''}, {OUT=>''}, {EXIT=>1},
+   {ERR=>"$prog: missing equivalence class character '[==]'\n"}],
+  ['empty-cc', qw('[::]' x), {IN=>''}, {OUT=>''}, {EXIT=>1},
+   {ERR=>"$prog: missing character class name '[::]'\n"}],
+
+  # Weird repeat counts.
+  ['repeat-bs-9', qw(abc '[b*\9]'), {IN=>'abcd'}, {OUT=>'[b*d'}],
+  ['repeat-0', qw(abc '[b*0]'), {IN=>'abcd'}, {OUT=>'bbbd'}],
+  ['repeat-zeros', qw(abc '[b*00000000000000000000]'),
+   {IN=>'abcd'}, {OUT=>'bbbd'}],
+  ['repeat-compl', qw(-c '[a*65536]\n' '[b*]'), {IN=>'abcd'}, {OUT=>'abbb'}],
+  ['repeat-xC', qw(-C '[a*65536]\n' '[b*]'), {IN=>'abcd'}, {OUT=>'abbb'}],
+
+  # From Glenn Fowler.
+  ['fowler-1', qw(ah -H), {IN=>'aha'}, {OUT=>'-H-'}],
+
+  # Up to coreutils-6.9, this would provoke a failed assertion.
+  ['no-abort-1', qw(-c a '[b*256]'), {IN=>'abc'}, {OUT=>'abb'}],
+);
+
+@Tests = triple_test \@Tests;
+
+# tr takes its input only from stdin, not from a file argument, so
+# remove the tests that provide file arguments and keep only the ones
+# generated by triple_test (identifiable by their .r and .p suffixes).
+@Tests = grep {$_->[0] =~ /\.[pr]$/} @Tests;
+
+my $save_temps = $ENV{DEBUG};
+my $verbose = $ENV{VERBOSE};
+
+my $fail = run_tests ($prog, $prog, \@Tests, $save_temps, $verbose);
+exit $fail;