Function TestCompress1XMustReuse

huff0/compress_test.go:272–359

(t *testing.T)

}

func TestCompress1XMustReuse(t *testing.T) {
	for _, test := range testfiles {
		t.Run(test.name, func(t *testing.T) {
			var s Scratch
			buf0, err := test.fn()
			if err != nil {
				t.Fatal(err)
			}
			if len(buf0) > BlockSizeMax {
				buf0 = buf0[:BlockSizeMax]
			}
			b, re, err := Compress1X(buf0, &s)
			if err != test.err1X {
				t.Errorf("want error %v (%T), got %v (%T)", test.err1X, test.err1X, err, err)
			}
			if err != nil {
				t.Log(test.name, err.Error())
				return
			}
			if b == nil {
				t.Error("got no output")
				return
			}

			min := s.minSize(len(buf0))
			if len(s.OutData) < min {
				t.Errorf("output data length (%d) below shannon limit (%d)", len(s.OutData), min)
			}
			if len(s.OutTable) == 0 {
				t.Error("got no table definition")
			}
			if re {
				t.Error("claimed to have re-used.")
			}
			if len(s.OutData) == 0 {
				t.Error("got no data output")
			}
			t.Logf("%s: %d -> %d bytes (%.2f:1) re:%t (table: %d bytes)", test.name, len(buf0), len(b), float64(len(buf0))/float64(len(b)), re, len(s.OutTable))
			table := s.OutTable
			prevTable := s.prevTable
			for i, v := range prevTable {
				// Clear unused sections for comparison
				if v.nBits == 0 {
					prevTable[i].val = 0
				}
			}
			b = s.OutData
			actl := s.actualTableLog

			// Use only the table data to recompress.
			s = Scratch{}
			s2 := &s
			s.Reuse = ReusePolicyMust
			s2, _, err = ReadTable(table, s2)
			if err != nil {
				t.Error("Could not read table", err)
				return
			}