refactor(codec): improve error handling best practices

Go: Add MustBuildFrequencies/MustBuildScaledFrequencies following
Go standard library conventions (e.g., regexp.MustCompile). Mark
original panic functions as Deprecated.

Rust: Replace unwrap() with expect() in test code to provide
meaningful error messages on failure.

Author: LessUp

algorithms/arithmetic/rust/src/lib.rs

@@ -240,8 +240,8 @@ mod tests {
 
     #[test]
     fn roundtrip_zero_byte_without_confusing_it_with_eof() {
-        let encoded = encode(&[0x00]).unwrap();
-        let decoded = decode(&encoded).unwrap();
+        let encoded = encode(&[0x00]).expect("encode 0x00 should succeed");
+        let decoded = decode(&encoded).expect("decode should succeed");
 
         assert_eq!(decoded, vec![0x00]);
     }

algorithms/range/rust/src/lib.rs

@@ -260,8 +260,8 @@ mod tests {
     #[test]
     fn roundtrip_empty() {
         let data: Vec<u8> = Vec::new();
-        let enc = encode(&data).unwrap();
-        let dec = decode(&enc).unwrap();
+        let enc = encode(&data).expect("encode empty should succeed");
+        let dec = decode(&enc).expect("decode empty should succeed");
         assert_eq!(dec, data);
     }
 
@@ -272,8 +272,8 @@ mod tests {
         let mut data = vec![0u8; 10000];
         let mut rng = rand::rngs::StdRng::seed_from_u64(1);
         rng.fill_bytes(&mut data);
-        let enc = encode(&data).unwrap();
-        let dec = decode(&enc).unwrap();
+        let enc = encode(&data).expect("encode random data should succeed");
+        let dec = decode(&enc).expect("decode random data should succeed");
         assert_eq!(dec, data);
     }
 

algorithms/shared/go/codec/frequency.go

@@ -175,17 +175,27 @@ func BuildCumulativeStrict(freq []uint32, zeroTableMessage string) ([]uint32, er
 	return nil, NewError(KindCorrupt, zeroTableMessage)
 }
 
-// BuildFrequencies counts byte frequencies in the input data.
+// MustBuildFrequencies counts byte frequencies in the input data.
 // The EOF symbol is always set to 1. It panics if a symbol count would exceed
 // math.MaxUint32; use BuildFrequenciesChecked to handle that error explicitly.
-func BuildFrequencies(data []byte) []uint32 {
+//
+// This is a convenience function for use in tests and initialization code where
+// the input is known to be safe. For production code, prefer BuildFrequenciesChecked.
+func MustBuildFrequencies(data []byte) []uint32 {
 	freq, err := BuildFrequenciesChecked(data)
 	if err != nil {
 		panic(err)
 	}
 	return freq
 }
 
+// BuildFrequencies counts byte frequencies in the input data.
+// Deprecated: Use BuildFrequenciesChecked for proper error handling, or MustBuildFrequencies
+// if panic behavior is explicitly desired.
+func BuildFrequencies(data []byte) []uint32 {
+	return MustBuildFrequencies(data)
+}
+
 // BuildFrequenciesChecked counts byte frequencies in the input data and
 // returns an error instead of overflowing if any symbol count would exceed
 // math.MaxUint32. The EOF symbol is always set to 1.
@@ -213,18 +223,29 @@ func BuildFrequenciesFromReader(r io.Reader) ([]uint32, error) {
 	return freq, nil
 }
 
-// BuildScaledFrequencies counts byte frequencies and scales them with the same
-// semantics as BuildFrequencies followed by ScaleFrequencies. It panics if a
+// MustBuildScaledFrequencies counts byte frequencies and scales them with the same
+// semantics as MustBuildFrequencies followed by ScaleFrequencies. It panics if a
 // symbol count would exceed math.MaxUint32; use BuildScaledFrequenciesChecked
 // to handle that error explicitly.
-func BuildScaledFrequencies(data []byte, maxTotal uint32) []uint32 {
+//
+// This is a convenience function for use in tests and initialization code where
+// the input is known to be safe. For production code, prefer BuildScaledFrequenciesChecked.
+func MustBuildScaledFrequencies(data []byte, maxTotal uint32) []uint32 {
 	freq, err := BuildScaledFrequenciesChecked(data, maxTotal)
 	if err != nil {
 		panic(err)
 	}
 	return freq
 }
 
+// BuildScaledFrequencies counts byte frequencies and scales them with the same
+// semantics as BuildFrequencies followed by ScaleFrequencies.
+// Deprecated: Use BuildScaledFrequenciesChecked for proper error handling, or
+// MustBuildScaledFrequencies if panic behavior is explicitly desired.
+func BuildScaledFrequencies(data []byte, maxTotal uint32) []uint32 {
+	return MustBuildScaledFrequencies(data, maxTotal)
+}
+
 // BuildScaledFrequenciesChecked counts byte frequencies and scales them with
 // the same semantics as BuildFrequenciesChecked followed by ScaleFrequencies.
 func BuildScaledFrequenciesChecked(data []byte, maxTotal uint32) ([]uint32, error) {

algorithms/shared/go/codec/frequency_test.go

@@ -43,7 +43,7 @@ func TestSymbolLimit(t *testing.T) {
 
 func TestBuildFrequencies(t *testing.T) {
 	data := []byte("aabbbc")
-	freq := BuildFrequencies(data)
+	freq := MustBuildFrequencies(data)
 
 	if freq['a'] != 2 {
 		t.Errorf("freq['a'] = %d, want 2", freq['a'])
@@ -60,7 +60,7 @@ func TestBuildFrequencies(t *testing.T) {
 }
 
 func TestBuildFrequencies_Empty(t *testing.T) {
-	freq := BuildFrequencies([]byte{})
+	freq := MustBuildFrequencies([]byte{})
 
 	// All byte frequencies should be 0
 	for i := 0; i < 256; i++ {
@@ -93,7 +93,7 @@ func TestAccumulateFrequencies_RejectsSymbolOverflow(t *testing.T) {
 func TestBuildScaledFrequencies_ClampsTotalAndPreservesEOF(t *testing.T) {
 	data := append(bytes.Repeat([]byte{'a'}, 12), bytes.Repeat([]byte{'b'}, 6)...)
 
-	freq := BuildScaledFrequencies(data, 8)
+	freq := MustBuildScaledFrequencies(data, 8)
 
 	var total uint32
 	for _, f := range freq {
@@ -113,10 +113,10 @@ func TestBuildScaledFrequencies_ClampsTotalAndPreservesEOF(t *testing.T) {
 func TestBuildScaledFrequencies_MatchesScaleFrequenciesSemantics(t *testing.T) {
 	data := []byte{'a', 'b', 'c', 'd'}
 
-	want := BuildFrequencies(data)
+	want := MustBuildFrequencies(data)
 	ScaleFrequencies(want, 4)
 
-	got := BuildScaledFrequencies(data, 4)
+	got := MustBuildScaledFrequencies(data, 4)
 
 	for i := range want {
 		if got[i] != want[i] {
@@ -171,7 +171,7 @@ func TestBuildFrequenciesFromReader_MatchesSliceHelper(t *testing.T) {
 		t.Fatalf("BuildFrequenciesFromReader failed: %v", err)
 	}
 
-	want := BuildFrequencies(data)
+	want := MustBuildFrequencies(data)
 	for i := range want {
 		if got[i] != want[i] {
 			t.Fatalf("got[%d] = %d, want %d", i, got[i], want[i])
@@ -188,7 +188,7 @@ func TestBuildScaledFrequenciesFromReader_MatchesSliceHelper(t *testing.T) {
 		t.Fatalf("BuildScaledFrequenciesFromReader failed: %v", err)
 	}
 
-	want := BuildScaledFrequencies(data, 4)
+	want := MustBuildScaledFrequencies(data, 4)
 	for i := range want {
 		if got[i] != want[i] {
 			t.Fatalf("got[%d] = %d, want %d", i, got[i], want[i])

algorithms/shared/rust/tests/buffer.rs

@@ -196,7 +196,7 @@ fn encode_buffer_retries_process_transactionally() {
         finish_calls: 0,
     };
 
-    let output = encode_buffer(&mut encoder, b"x").unwrap();
+    let output = encode_buffer(&mut encoder, b"x").expect("encode_buffer should succeed");
 
     assert_eq!(encoder.process_calls, 2);
     assert_eq!(encoder.process_output_lens.len(), 2);
@@ -213,7 +213,7 @@ fn decode_buffer_retries_process_transactionally() {
         finish_calls: 0,
     };
 
-    let output = decode_buffer(&mut decoder, b"x").unwrap();
+    let output = decode_buffer(&mut decoder, b"x").expect("decode_buffer should succeed");
 
     assert_eq!(decoder.process_calls, 2);
     assert_eq!(decoder.process_output_lens.len(), 2);
@@ -229,7 +229,7 @@ fn encode_buffer_retries_finish_transactionally() {
         finish_output_lens: Vec::new(),
     };
 
-    let output = encode_buffer(&mut encoder, b"x").unwrap();
+    let output = encode_buffer(&mut encoder, b"x").expect("encode_buffer should succeed");
 
     assert_eq!(encoder.finish_calls, 2);
     assert_eq!(encoder.finish_output_lens.len(), 2);
@@ -244,7 +244,7 @@ fn decode_buffer_retries_finish_transactionally() {
         finish_output_lens: Vec::new(),
     };
 
-    let output = decode_buffer(&mut decoder, b"x").unwrap();
+    let output = decode_buffer(&mut decoder, b"x").expect("decode_buffer should succeed");
 
     assert_eq!(decoder.finish_calls, 2);
     assert_eq!(decoder.finish_output_lens.len(), 2);

algorithms/shared/rust/tests/lifecycle.rs

@@ -62,15 +62,18 @@ fn test_lifecycle_basic() {
     assert_eq!(enc.state(), State::Ready);
 
     // Process should move to Streaming
-    enc.process(b"test", &mut []).unwrap();
+    enc.process(b"test", &mut [])
+        .expect("process should succeed in Ready state");
     assert_eq!(enc.state(), State::Streaming);
 
     // Flush should move to Flushing
-    enc.flush(&mut []).unwrap();
+    enc.flush(&mut [])
+        .expect("flush should succeed in Streaming state");
     assert_eq!(enc.state(), State::Flushing);
 
     // Finish should move to Finished
-    enc.finish(&mut []).unwrap();
+    enc.finish(&mut [])
+        .expect("finish should succeed in Flushing state");
     assert_eq!(enc.state(), State::Finished);
 
     // Post-finish calls should error and move to Error
@@ -123,13 +126,19 @@ fn test_huffman_roundtrip_via_traits() {
     let input = b"hello world";
     let mut enc = huffman::new_encoder();
     let mut output = vec![0u8; 4096];
-    enc.process(input, &mut output).unwrap();
-    let written = enc.finish(&mut output).unwrap();
+    enc.process(input, &mut output)
+        .expect("huffman process should succeed");
+    let written = enc
+        .finish(&mut output)
+        .expect("huffman finish should succeed");
 
     let mut dec = huffman::new_decoder();
     let mut decoded = vec![0u8; 4096];
-    dec.process(&output[..written], &mut decoded).unwrap();
-    let dec_written = dec.finish(&mut decoded).unwrap();
+    dec.process(&output[..written], &mut decoded)
+        .expect("huffman decode process should succeed");
+    let dec_written = dec
+        .finish(&mut decoded)
+        .expect("huffman decode finish should succeed");
 
     assert_eq!(&decoded[..dec_written], input);
 }
@@ -139,13 +148,19 @@ fn test_arithmetic_roundtrip_via_traits() {
     let input = b"test data";
     let mut enc = arithmetic::new_encoder();
     let mut output = vec![0u8; 4096];
-    enc.process(input, &mut output).unwrap();
-    let written = enc.finish(&mut output).unwrap();
+    enc.process(input, &mut output)
+        .expect("arithmetic process should succeed");
+    let written = enc
+        .finish(&mut output)
+        .expect("arithmetic finish should succeed");
 
     let mut dec = arithmetic::new_decoder();
     let mut decoded = vec![0u8; 4096];
-    dec.process(&output[..written], &mut decoded).unwrap();
-    let dec_written = dec.finish(&mut decoded).unwrap();
+    dec.process(&output[..written], &mut decoded)
+        .expect("arithmetic decode process should succeed");
+    let dec_written = dec
+        .finish(&mut decoded)
+        .expect("arithmetic decode finish should succeed");
 
     assert_eq!(&decoded[..dec_written], input);
 }
@@ -155,13 +170,19 @@ fn test_rle_roundtrip_via_traits() {
     let input = b"aaabbbccc";
     let mut enc = rle::new_encoder();
     let mut output = vec![0u8; 4096];
-    enc.process(input, &mut output).unwrap();
-    let written = enc.finish(&mut output).unwrap();
+    enc.process(input, &mut output)
+        .expect("rle process should succeed");
+    let written = enc
+        .finish(&mut output)
+        .expect("rle finish should succeed");
 
     let mut dec = rle::new_decoder();
     let mut decoded = vec![0u8; 4096];
-    dec.process(&output[..written], &mut decoded).unwrap();
-    let dec_written = dec.finish(&mut decoded).unwrap();
+    dec.process(&output[..written], &mut decoded)
+        .expect("rle decode process should succeed");
+    let dec_written = dec
+        .finish(&mut decoded)
+        .expect("rle decode finish should succeed");
 
     assert_eq!(&decoded[..dec_written], input);
 }