From a65e2bacf0c85b21b2bc1a525661fe122074e65e Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 2 Jul 2017 11:19:23 +1000 Subject: [PATCH] Add mimic tests. --- cmd/puffs-test-c/main.go | 50 +++++++++++++++---- cmd/puffs/main.go | 3 ++ cmd/puffs/test.go | 24 +++++---- test/c/mimiclib/gif.c | 59 ++++++++++++++++++++++ test/c/std/gif.c | 105 ++++++++++++++++++++++++++++++++++++++- 5 files changed, 220 insertions(+), 21 deletions(-) create mode 100644 test/c/mimiclib/gif.c diff --git a/cmd/puffs-test-c/main.go b/cmd/puffs-test-c/main.go index 5dc43256..238d3b9d 100644 --- a/cmd/puffs-test-c/main.go +++ b/cmd/puffs-test-c/main.go @@ -5,16 +5,19 @@ package main import ( + "bufio" "flag" "fmt" "io/ioutil" "os" "os/exec" "path/filepath" + "strings" ) var ( bench = flag.Bool("bench", false, "whether to run benchmarks instead of regular tests") + mimic = flag.Bool("mimic", false, "whether to compare Puffs' output with other libraries' output") ) func main() { @@ -47,18 +50,26 @@ func do(filename string) (failed bool, err error) { } defer os.RemoveAll(workDir) - for _, cc := range []string{"clang", "gcc"} { - in := filename + ".c" - out := filepath.Join(workDir, cc+".out") + in := filename + ".c" + out := filepath.Join(workDir, "a.out") - ccArgs := []string(nil) - if *bench { - ccArgs = append(ccArgs, "-O3") - } else { - // TODO: set these flags even if we pass -O3. - ccArgs = append(ccArgs, "-Wall", "-Werror") + ccArgs := []string(nil) + if *bench { + ccArgs = append(ccArgs, "-O3") + } else { + // TODO: set these flags even if we pass -O3. + ccArgs = append(ccArgs, "-Wall", "-Werror") + } + ccArgs = append(ccArgs, "-std=c99", "-o", out, in) + if *mimic { + extra, err := findPuffsMimicCflags(in) + if err != nil { + return false, err } - ccArgs = append(ccArgs, "-std=c99", "-o", out, in) + ccArgs = append(ccArgs, extra...) + } + + for _, cc := range []string{"clang", "gcc"} { ccCmd := exec.Command(cc, ccArgs...) ccCmd.Stdout = os.Stdout ccCmd.Stderr = os.Stderr @@ -84,3 +95,22 @@ func do(filename string) (failed bool, err error) { } return failed, nil } + +func findPuffsMimicCflags(filename string) ([]string, error) { + f, err := os.Open(filename) + if err != nil { + return nil, err + } + defer f.Close() + + s := bufio.NewScanner(f) + for s.Scan() { + t := s.Text() + const prefix = "// !! puffs mimic cflags:" + if strings.HasPrefix(t, prefix) { + t = strings.TrimSpace(t[len(prefix):]) + return strings.Split(t, " "), nil + } + } + return nil, s.Err() +} diff --git a/cmd/puffs/main.go b/cmd/puffs/main.go index da06a1ac..0a6726f9 100644 --- a/cmd/puffs/main.go +++ b/cmd/puffs/main.go @@ -107,6 +107,9 @@ func listDir(puffsRoot string, dirname string, returnSubdirs bool) (filenames [] const ( langsDefault = "c" langsUsage = `comma-separated list of target languages (file extensions), e.g. "c,go,rs"` + + mimicDefault = false + mimicUsage = `whether to compare Puffs' output with other libraries' output` ) func parseLangs(commaSeparated string) ([]string, error) { diff --git a/cmd/puffs/test.go b/cmd/puffs/test.go index 9e5c2600..9c9c5deb 100644 --- a/cmd/puffs/test.go +++ b/cmd/puffs/test.go @@ -19,6 +19,7 @@ func doTest(puffsRoot string, args []string) error { return doBenchTest(puffsRo func doBenchTest(puffsRoot string, args []string, bench bool) error { flags := flag.NewFlagSet("test", flag.ExitOnError) langsFlag := flags.String("langs", langsDefault, langsUsage) + mimicFlag := flags.Bool("mimic", mimicDefault, mimicUsage) if err := flags.Parse(args); err != nil { return err } @@ -31,6 +32,14 @@ func doBenchTest(puffsRoot string, args []string, bench bool) error { args = []string{"std/..."} } + cmdArgs := []string(nil) + if *mimicFlag { + cmdArgs = append(cmdArgs, "-mimic") + } + if bench { + cmdArgs = append(cmdArgs, "-bench") + } + failed := false for _, arg := range args { recursive := strings.HasSuffix(arg, "/...") @@ -44,7 +53,7 @@ func doBenchTest(puffsRoot string, args []string, bench bool) error { } // Proceed with benching / testing the generated code. - f, err := benchTest(puffsRoot, arg, langs, bench, recursive) + f, err := benchTest(puffsRoot, arg, langs, cmdArgs, recursive) if err != nil { return err } @@ -56,13 +65,13 @@ func doBenchTest(puffsRoot string, args []string, bench bool) error { return nil } -func benchTest(puffsRoot, dirname string, langs []string, bench bool, recursive bool) (failed bool, err error) { +func benchTest(puffsRoot, dirname string, langs []string, cmdArgs []string, recursive bool) (failed bool, err error) { filenames, dirnames, err := listDir(puffsRoot, dirname, recursive) if err != nil { return false, err } if len(filenames) > 0 { - f, err := benchTestDir(puffsRoot, dirname, langs, bench) + f, err := benchTestDir(puffsRoot, dirname, langs, cmdArgs) if err != nil { return false, err } @@ -70,7 +79,7 @@ func benchTest(puffsRoot, dirname string, langs []string, bench bool, recursive } if len(dirnames) > 0 { for _, d := range dirnames { - f, err := benchTest(puffsRoot, filepath.Join(dirname, d), langs, bench, recursive) + f, err := benchTest(puffsRoot, filepath.Join(dirname, d), langs, cmdArgs, recursive) if err != nil { return false, err } @@ -80,17 +89,14 @@ func benchTest(puffsRoot, dirname string, langs []string, bench bool, recursive return failed, nil } -func benchTestDir(puffsRoot string, dirname string, langs []string, bench bool) (failed bool, err error) { +func benchTestDir(puffsRoot string, dirname string, langs []string, cmdArgs []string) (failed bool, err error) { if packageName := filepath.Base(dirname); !validName(packageName) { return false, fmt.Errorf(`invalid package %q, not in [a-z0-9]+`, packageName) } for _, lang := range langs { command := "puffs-test-" + lang - args := []string(nil) - if bench { - args = append(args, "-bench") - } + args := append([]string(nil), cmdArgs...) args = append(args, filepath.Join(puffsRoot, "test", lang, filepath.FromSlash(dirname))) cmd := exec.Command(command, args...) cmd.Stdout = os.Stdout diff --git a/test/c/mimiclib/gif.c b/test/c/mimiclib/gif.c new file mode 100644 index 00000000..e8798d9e --- /dev/null +++ b/test/c/mimiclib/gif.c @@ -0,0 +1,59 @@ +// Use of this source code is governed by a BSD-style license that can be found +// in the LICENSE file. + +#include "gif_lib.h" + +int gif_mimic_read_func(GifFileType* f, GifByteType* ptr, int len) { + puffs_base_buf1* src = (puffs_base_buf1*)(f->UserData); + if (len < 0) { + return 0; + } + size_t n = (size_t)(len); + size_t num_src = src->wi - src->ri; + if (n > num_src) { + n = num_src; + } + memmove(ptr, src->ptr + src->ri, n); + src->ri += n; + return n; +} + +const char* gif_mimic_decode(puffs_base_buf1* dst, puffs_base_buf1* src) { + const char* ret = NULL; + + // TODO: update API calls for libgif version 5 vs version 4? + GifFileType* f = DGifOpen(src, gif_mimic_read_func); + if (!f) { + ret = "DGifOpenFileName failed"; + goto cleanup0; + } + if (DGifSlurp(f) != GIF_OK) { + ret = "DGifSlurp failed"; + goto cleanup1; + } + + // TODO: have Puffs accept multi-frame (animated) GIFs. + if (f->ImageCount != 1) { + ret = "GIF image has more than one frame"; + goto cleanup1; + } + + struct SavedImage* si = &f->SavedImages[0]; + size_t num_src = + (size_t)(si->ImageDesc.Width) * (size_t)(si->ImageDesc.Height); + size_t num_dst = dst->len - dst->wi; + if (num_dst < num_src) { + ret = "GIF image's pixel data won't fit in the dst buffer"; + goto cleanup1; + } + + memmove(dst->ptr + dst->wi, si->RasterBits, num_src); + dst->wi += num_src; + +cleanup1:; + if ((DGifCloseFile(f) != GIF_OK) && !ret) { + ret = "DGifCloseFile failed"; + } +cleanup0:; + return ret; +} diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 4b0fd983..7bd631a2 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -10,8 +10,13 @@ for cc in clang gcc; do done Each edition should print "PASS", amongst other information, and exit(0). + +Add the "puffs mimic cflags" below to the C compiler flags to test that Puff's +output matches other libraries' output. */ +// !! puffs mimic cflags: -DPUFFS_MIMIC -lgif + #include "../../../gen/c/std/gif.c" #include "../testlib/testlib.c" @@ -422,6 +427,91 @@ void test_gif_decode_input_is_a_png() { puffs_gif_error_bad_gif_header); } +// ---------------- Mimic Tests + +#ifdef PUFFS_MIMIC + +#include "../mimiclib/gif.c" + +const char* gif_puffs_decode(puffs_base_buf1* dst, puffs_base_buf1* src) { + puffs_gif_decoder dec; + puffs_gif_decoder_constructor(&dec, PUFFS_VERSION, 0); + puffs_base_writer1 dst_writer = {.buf = dst}; + puffs_base_reader1 src_reader = {.buf = src}; + puffs_gif_status s = puffs_gif_decoder_decode(&dec, dst_writer, src_reader); + puffs_gif_decoder_destructor(&dec); + if (s) { + return puffs_gif_status_string(s); + } + return NULL; +} + +void test_gif_mimic_decode_xxx(const char* filename) { + puffs_base_buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + if (!read_file(&src, filename)) { + return; + } + + src.ri = 0; + puffs_base_buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE}; + const char* got_msg = gif_puffs_decode(&got, &src); + if (got_msg) { + FAIL("%s", got_msg); + return; + } + + src.ri = 0; + puffs_base_buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE}; + const char* want_msg = gif_mimic_decode(&want, &src); + if (want_msg) { + FAIL("%s", want_msg); + return; + } + + if (!buf1s_equal("", &got, &want)) { + return; + } + + // TODO: check the palette RGB values, not just the palette indexes (pixels). +} + +void test_gif_mimic_decode_bricks_dither() { + proc_funcname = __func__; + test_gif_mimic_decode_xxx("../../testdata/bricks-dither.gif"); +} + +void test_gif_mimic_decode_bricks_gray() { + proc_funcname = __func__; + test_gif_mimic_decode_xxx("../../testdata/bricks-gray.gif"); +} + +void test_gif_mimic_decode_bricks_nodither() { + proc_funcname = __func__; + test_gif_mimic_decode_xxx("../../testdata/bricks-nodither.gif"); +} + +void test_gif_mimic_decode_harvesters() { + proc_funcname = __func__; + test_gif_mimic_decode_xxx("../../testdata/harvesters.gif"); +} + +void test_gif_mimic_decode_hat() { + proc_funcname = __func__; + test_gif_mimic_decode_xxx("../../testdata/hat.gif"); +} + +void test_gif_mimic_decode_hibiscus() { + proc_funcname = __func__; + test_gif_mimic_decode_xxx("../../testdata/hibiscus.gif"); +} + +void test_gif_mimic_decode_pjw_thumbnail() { + proc_funcname = __func__; + test_gif_mimic_decode_xxx("../../testdata/pjw-thumbnail.gif"); +} + +#endif // PUFFS_MIMIC + // ---------------- GIF Benches void bench_gif_decode_xxx(const char* filename, uint64_t reps) { @@ -498,7 +588,19 @@ proc tests[] = { test_gif_decode_input_is_a_gif, // test_gif_decode_input_is_a_png, // - // End +#ifdef PUFFS_MIMIC + + // Mimic Tests + test_gif_mimic_decode_bricks_dither, // + // test_gif_mimic_decode_bricks_gray, // TODO + test_gif_mimic_decode_bricks_nodither, // + test_gif_mimic_decode_harvesters, // + test_gif_mimic_decode_hat, // + test_gif_mimic_decode_hibiscus, // + test_gif_mimic_decode_pjw_thumbnail, // + +#endif // PUFFS_MIMIC + NULL, }; @@ -514,6 +616,5 @@ proc benches[] = { bench_gif_decode_100k, // bench_gif_decode_1000k, // - // End NULL, };