Maximize test coverage to 100%

- Add tests for WordsByClass
- Add tests for NewClassifierTfIdf edge cases (not unique, too few classes)
- Add tests for TF-IDF panics (ProbScores, SafeProbScores, Learn after convert)
- Add tests for file operation error paths
- Remove unused getWordsProb function (dead code)

Coverage improved from 91.9% to 100%.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: jbrukh

bayesian.go

@@ -80,20 +80,6 @@ func (d *classData) getWordProb(word string) float64 {
 	return float64(value) / float64(d.Total)
 }
 
-// getWordsProb returns P(D|C_j) -- the probability of seeing
-// this set of words in a document of this class.
-//
-// Note that words should not be empty, and this method of
-// calculation is prone to underflow if there are many words
-// and their individual probabilities are small.
-func (d *classData) getWordsProb(words []string) (prob float64) {
-	prob = 1
-	for _, word := range words {
-		prob *= d.getWordProb(word)
-	}
-	return
-}
-
 // NewClassifierTfIdf returns a new classifier. The classes provided
 // should be at least 2 in number and unique, or this method will
 // panic.

bayesian_test.go

@@ -392,3 +392,106 @@ func TestTfIdClassifier_LogScore(t *testing.T) {
 	fmt.Printf("%#v", score)
 
 }
+
+func TestWordsByClass(t *testing.T) {
+	c := NewClassifier(Good, Bad)
+	c.Learn([]string{"tall", "handsome", "rich"}, Good)
+	c.Learn([]string{"bald", "poor", "ugly"}, Bad)
+
+	goodWords := c.WordsByClass(Good)
+	Assert(t, len(goodWords) == 3, "should have 3 words")
+	Assert(t, goodWords["tall"] == float64(1)/float64(3), "tall frequency")
+	Assert(t, goodWords["handsome"] == float64(1)/float64(3), "handsome frequency")
+	Assert(t, goodWords["rich"] == float64(1)/float64(3), "rich frequency")
+
+	badWords := c.WordsByClass(Bad)
+	Assert(t, len(badWords) == 3, "should have 3 words")
+	Assert(t, badWords["bald"] == float64(1)/float64(3), "bald frequency")
+}
+
+func TestNewClassifierTfIdfNotUnique(t *testing.T) {
+	defer func() {
+		if err := recover(); err != nil {
+			// we are good
+		}
+	}()
+	c := NewClassifierTfIdf(Good, Good, Bad)
+	Assert(t, false, "should have panicked:", c)
+}
+
+func TestNewClassifierTfIdfTooFew(t *testing.T) {
+	defer func() {
+		if err := recover(); err != nil {
+			// we are good
+		}
+	}()
+	c := NewClassifierTfIdf(Good)
+	Assert(t, false, "should have panicked:", c)
+}
+
+func TestTfIdfProbScoresPanic(t *testing.T) {
+	c := NewClassifierTfIdf(Good, Bad)
+	c.Learn([]string{"tall", "handsome"}, Good)
+
+	defer func() {
+		if err := recover(); err != nil {
+			// we are good - should panic without ConvertTermsFreqToTfIdf
+		}
+	}()
+	c.ProbScores([]string{"tall"})
+	Assert(t, false, "should have panicked")
+}
+
+func TestTfIdfSafeProbScoresPanic(t *testing.T) {
+	c := NewClassifierTfIdf(Good, Bad)
+	c.Learn([]string{"tall", "handsome"}, Good)
+
+	defer func() {
+		if err := recover(); err != nil {
+			// we are good - should panic without ConvertTermsFreqToTfIdf
+		}
+	}()
+	c.SafeProbScores([]string{"tall"})
+	Assert(t, false, "should have panicked")
+}
+
+func TestTfIdfLearnAfterConvertPanic(t *testing.T) {
+	c := NewClassifierTfIdf(Good, Bad)
+	c.Learn([]string{"tall", "handsome"}, Good)
+	c.ConvertTermsFreqToTfIdf()
+
+	defer func() {
+		if err := recover(); err != nil {
+			// we are good - should panic when learning after conversion
+		}
+	}()
+	c.Learn([]string{"more", "words"}, Good)
+	Assert(t, false, "should have panicked")
+}
+
+func TestNewClassifierFromFileError(t *testing.T) {
+	_, err := NewClassifierFromFile("nonexistent_file.ser")
+	Assert(t, err != nil, "should return error for nonexistent file")
+}
+
+func TestWriteToFileError(t *testing.T) {
+	c := NewClassifier(Good, Bad)
+	c.Learn([]string{"test"}, Good)
+	// Try to write to an invalid path
+	err := c.WriteToFile("/nonexistent_directory/test.ser")
+	Assert(t, err != nil, "should return error for invalid path")
+}
+
+func TestWriteClassToFileError(t *testing.T) {
+	c := NewClassifier(Good, Bad)
+	c.Learn([]string{"test"}, Good)
+	// Try to write to an invalid path
+	err := c.WriteClassToFile(Good, "/nonexistent_directory")
+	Assert(t, err != nil, "should return error for invalid path")
+}
+
+func TestReadClassFromFileError(t *testing.T) {
+	c := NewClassifier(Good, Bad)
+	err := c.ReadClassFromFile(Good, "/nonexistent_directory")
+	Assert(t, err != nil, "should return error for nonexistent file")
+}