Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package zlib

import (

        "bytes"

        "fmt"

        "io"

        "io/ioutil"

        "os"

        "testing"

)

var filenames = []string{

        "../testdata/e.txt",

        "../testdata/pi.txt",

}

var data = []string{

        "test a reasonable sized string that can be compressed",

}

// Tests that compressing and then decompressing the given file at the given compression level and dictionary

// yields equivalent bytes to the original file.

func testFileLevelDict(t *testing.T, fn string, level int, d string) {

        // Read the file, as golden output.

        golden, err := os.Open(fn)

        if err != nil {

                t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err)

                return

        }

        defer golden.Close()

        b0, err0 := ioutil.ReadAll(golden)

        if err0 != nil {

                t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err0)

                return

        }

        testLevelDict(t, fn, b0, level, d)

}

func testLevelDict(t *testing.T, fn string, b0 []byte, level int, d string) {

        // Make dictionary, if given.

        var dict []byte

        if d != "" {

                dict = []byte(d)

        }

        // Push data through a pipe that compresses at the write end, and decompresses at the read end.

        piper, pipew := io.Pipe()

        defer piper.Close()

        go func() {

                defer pipew.Close()

                zlibw, err := NewWriterDict(pipew, level, dict)

                if err != nil {

                        t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err)

                        return

                }

                defer zlibw.Close()

                _, err = zlibw.Write(b0)

                if err != nil {

                        t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err)

                        return

                }

        }()

        zlibr, err := NewReaderDict(piper, dict)

        if err != nil {

                t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err)

                return

        }

        defer zlibr.Close()

        // Compare the decompressed data.

        b1, err1 := ioutil.ReadAll(zlibr)

        if err1 != nil {

                t.Errorf("%s (level=%d, dict=%q): %v", fn, level, d, err1)

                return

        }

        if len(b0) != len(b1) {

                t.Errorf("%s (level=%d, dict=%q): length mismatch %d versus %d", fn, level, d, len(b0), len(b1))

                return

        }

        for i := 0; i < len(b0); i++ {

                if b0[i] != b1[i] {

                        t.Errorf("%s (level=%d, dict=%q): mismatch at %d, 0x%02x versus 0x%02x\n", fn, level, d, i, b0[i], b1[i])

                        return

                }

        }

}

func TestWriter(t *testing.T) {

        for i, s := range data {

                b := []byte(s)

                tag := fmt.Sprintf("#%d", i)

                testLevelDict(t, tag, b, DefaultCompression, "")

                testLevelDict(t, tag, b, NoCompression, "")

                for level := BestSpeed; level <= BestCompression; level++ {

                        testLevelDict(t, tag, b, level, "")

                }

        }

}

func TestWriterBig(t *testing.T) {

        for _, fn := range filenames {

                testFileLevelDict(t, fn, DefaultCompression, "")

                testFileLevelDict(t, fn, NoCompression, "")

                for level := BestSpeed; level <= BestCompression; level++ {

                        testFileLevelDict(t, fn, level, "")

                }

        }

}

func TestWriterDict(t *testing.T) {

        const dictionary = "0123456789."

        for _, fn := range filenames {

                testFileLevelDict(t, fn, DefaultCompression, dictionary)

                testFileLevelDict(t, fn, NoCompression, dictionary)

                for level := BestSpeed; level <= BestCompression; level++ {

                        testFileLevelDict(t, fn, level, dictionary)

                }

        }

}

func TestWriterDictIsUsed(t *testing.T) {

        var input = []byte("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")

        var buf bytes.Buffer

        compressor, err := NewWriterDict(&buf, BestCompression, input)

        if err != nil {

                t.Errorf("error in NewWriterDict: %s", err)

                return

        }

        compressor.Write(input)

        compressor.Close()

        const expectedMaxSize = 25

        output := buf.Bytes()

        if len(output) > expectedMaxSize {

                t.Errorf("result too large (got %d, want <= %d bytes). Is the dictionary being used?", len(output), expectedMaxSize)

        }

}