modernc.org/knuth@v0.0.4/mf/all_test.go

// Copyright 2023 The Knuth 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 mf // modernc.org/knuth/mf

import (
	"bytes"
	"encoding/hex"
	"io"
	"os"
	"path/filepath"
	"strings"
	"testing"
	gotime "time"

	"github.com/pmezard/go-difflib/difflib"
	"modernc.org/knuth/gftype"
	"modernc.org/knuth/mf/internal/trap"
	"modernc.org/knuth/tftopl"
)

const timeout = 10 * gotime.Minute

func TestMain(m *testing.M) {
	os.Exit(m.Run())
}

func Test(t *testing.T) {
	g, err := filepath.Glob(filepath.FromSlash("testdata/*"))
	if err != nil {
		t.Fatal(err)
	}

	testdata := map[string][]byte{}
	for _, v := range g {
		b, err := os.ReadFile(v)
		if err != nil {
			t.Fatal(err)
		}

		nm := filepath.Base(v)
		if _, ok := testdata[nm]; ok {
			t.Fatalf("internal error: %q", nm)
		}

		testdata[nm] = b
		t.Logf("%q: %v", nm, len(b))
	}

	wd, err := os.Getwd()
	if err != nil {
		t.Fatal(err)
	}

	wd, err = filepath.Abs(wd)
	if err != nil {
		t.Fatal(err)
	}

	defer func() {
		if err := os.Chdir(wd); err != nil {
			t.Fatal(err)
		}
	}()

	tmp := t.TempDir()
	if err := os.WriteFile(filepath.Join(tmp, "trap.mf"), testdata["trap.mf"], 0660); err != nil {
		t.Fatal(err)
	}

	if err := os.Chdir(tmp); err != nil {
		t.Fatal(err)
	}

	// trapman.pdf
	//
	// Appendix A: How to test METAFONT.

	// 0. Let’s assume that you have a tape containing TRAP.MF, TRAPIN.LOG,
	// TRAP.LOG, TRAP.TYP, TRAP.PL, and TRAP.FOT, as in Appendices B, C, D, E, F,

	///	^ In testdata/

	// and G. Furthermore, let’s suppose that you have a working WEB system, and
	// that you have working programs TFtoPL and GFtype, as described in the
	// TEXware and METAFONTware reports.

	///	^ The plan is to use our own packages in modernc.org knuth/{tftopl,gftype}

	// 1. Prepare a version of INIMF. (This means that your WEB change file should
	// have init and tini defined to be null.) The debug and gubed macros should be
	// null, in order to activate special printouts that occur when tracingedges >
	// 1.0. The stat and tats macros should also be null, so that statistics are
	// kept. Set mem top and mem max to 3000 (or to mem min plus 3000, if mem min
	// isn’t zero), for purposes of this test version. Also set error line = 64,
	// half error line = 32, max print line = 72, screen width = 100, and screen
	// depth = 200; these parameters affect many of the lines of the test output,
	// so your job will be much easier if you use the same settings that were used
	// to produce Appendix E. Also (if possible) set gf buf size = 8, since this
	// tests more parts of the program. You probably should also use the “normal”
	// settings of other parameters found in MF.WEB (e.g., max internal = 100, buf
	// size = 500, etc.), since these show up in a few lines of the test output.
	// Finally, change METAFONT’s screen-display routines by putting the following
	// simple lines in the change file:
	//
	// @x Screen routines:
	// begin init_screen:=false;
	// @y
	// begin init_screen:=true; {screen instructions will be logged}
	// @z
	//
	// None of the other screen routines (update screen , blank rectangle , paint
	// row ) should be changed in any way; the effect will be to have METAFONT’s
	// actions recorded in the transcript files instead of on the screen, in a
	// machine-independent way.

	///	^ See internal/trap/mf.ch

	test2(t, testdata)
	test3(t, testdata)
	test4(t, testdata)
	test5(t, testdata)
	test6(t, testdata)
}

// 2. Run the INIMF prepared in step 1. In response to the first ‘**’ prompt,
// type carriage return (thus getting another ‘**’). Then type ‘\input trap’.
// You should get an output that matches the file TRAPIN.LOG (Appendix C).
// Don’t be alarmed by the error messages that you see, unless they are
// different from those in Appendix C.
func test2(t *testing.T, testdata map[string][]byte) {
	stdin := strings.NewReader("\\input trap\n")
	stdoutR, stdoutW := io.Pipe()
	stdout := bytes.NewBuffer(nil)
	stderr := bytes.NewBuffer(nil)
	done := make(chan error, 2)

	go func() {

		defer stdoutW.Close()

		done <- trap.Main(stdin, stdoutW, stderr, opener)
	}()

	must(t, stdoutR, "This is METAFONT, Version 2.71828182 (TRAP) (INIMF)\n**")

	go func() {
		b := make([]byte, 1000)
		for {
			n, err := stdoutR.Read(b)
			if n != 0 {
				stdout.Write(b[:n])
				continue
			}

			if err == io.EOF {
				err = nil
			}

			done <- err
		}
	}()

	to := gotime.After(timeout)
	for i := 0; i < 2; i++ {
		select {
		case err := <-done:
			if err != nil {
				t.Fatal(err)
			}
		case <-to:
			t.Fatal("timeout")
		}
	}

	got, err := os.ReadFile("trap.log")
	if err != nil {
		t.Fatal(err)
	}

	if g, e := noBanner(string(got)), noBanner(string(testdata["trapin.log"])); g != e {
		t.Logf("stderr:\n%s", stderr.Bytes())
		diff := difflib.UnifiedDiff{
			A:        difflib.SplitLines(e),
			B:        difflib.SplitLines(g),
			FromFile: "trapin.log",
			ToFile:   "trap.log",
			Context:  0,
		}
		s, _ := difflib.GetUnifiedDiffString(diff)
		t.Fatalf(
			"result differs\n%v\n--- expected\n%s\n\n--- got\n%s\n\n--- expected\n%s\n--- got\n%s",
			s, e, g, hex.Dump([]byte(e)), hex.Dump([]byte(g)),
		)
	}

	t.Logf("%v bytes matches trapin.log OK", len(got))
}

// 3. Run INIMF again. This time type ‘ &trap trap ’. (The spaces in this input
// help to check certain parts of METAFONT that aren’t otherwise used.) You
// should get outputs TRAP.LOG, TRAP.72270GF, and TRAP.TFM. Furthermore, your
// terminal should receive output that matches TRAP.FOT (Appendix G).  During
// the middle part of this test, however, the terminal will not be getting
// output, because batchmode is being tested; don’t worry if nothing seems to
// be happening for a while—nothing is supposed to.
func test3(t *testing.T, testdata map[string][]byte) {
	stdin := strings.NewReader(" &trap  trap\n")
	stdoutR, stdoutW := io.Pipe()
	stdout := bytes.NewBuffer(nil)
	stderr := bytes.NewBuffer(nil)
	done := make(chan error, 2)

	go func() {

		defer stdoutW.Close()

		done <- trap.Main(stdin, stdoutW, stderr, opener)
	}()

	must(t, stdoutR, "This is METAFONT, Version 2.71828182 (TRAP) (INIMF)\n**")

	go func() {
		b := make([]byte, 1000)
		for {
			n, err := stdoutR.Read(b)
			if n != 0 {
				stdout.Write(b[:n])
				continue
			}

			if err == io.EOF {
				err = nil
			}

			done <- err
		}
	}()

	to := gotime.After(timeout)
	for i := 0; i < 2; i++ {
		select {
		case err := <-done:
			if err != nil {
				t.Fatal(err)
			}
		case <-to:
			t.Fatal("timeout")
		}
	}

	got := stdout.String()
	exp := string(testdata["trap.fot"])
	exp = exp[strings.Index(exp, "(trap.mf"):]

	if g, e := got, exp; g != e {
		t.Logf("stderr:\n%s", stderr.Bytes())
		diff := difflib.UnifiedDiff{
			A:        difflib.SplitLines(e),
			B:        difflib.SplitLines(g),
			FromFile: "stdout",
			ToFile:   "trap.fot",
			Context:  0,
		}
		s, _ := difflib.GetUnifiedDiffString(diff)
		t.Fatalf(
			"result differs\n%v\n--- expected\n%s\n\n--- got\n%s\n\n--- expected\n%s\n--- got\n%s",
			s, e, g, hex.Dump([]byte(e)), hex.Dump([]byte(g)),
		)
	}

	t.Logf("%v bytes matches trap.fot OK", len(got))
}

func noBanner(s string) string {
	x := strings.Index(s, "This is ")
	x2 := strings.Index(s[x:], "\n")
	return s[:x] + s[x2+1:]
}

func must(t *testing.T, r io.Reader, expect string) {
	b := make([]byte, len(expect))
	if _, err := io.ReadFull(r, b); err != nil || string(b) != expect {
		t.Fatalf("got %q, expected %q, err %v", b, expect, err)
	}
}

// 4. Compare the TRAP.LOG file from step 3 with the “master” TRAP.LOG file of
// step 0. (Let’s hope you put that master file in a safe place so that it
// wouldn’t be clobbered.) There should be perfect agreement between these
// files except in the following respects:
//
// a) The dates and possibly the file names will naturally be different.
//
// b) If you had different values for stack size , buf size , etc., the
// corresponding capacity values will be different when they are printed out at
// the end.
//
// c) Help messages may be different; indeed, the author encourages non-English
// help messages in versions of METAFONT for people who don’t understand
// English as well as some other language.
//
// d) The total number and length of strings at the end and/or “still
// untouched” may well be different.
//
// e) If your METAFONT uses a different memory allocation or packing scheme,
// the memory usage statis- tics may change.
//
// f) If you use a different storage allocation scheme, the capsule numbers
// will probably be different, but the order of variables should be unchanged
// when dependent variables are shown. METAFONT should also choose the same
// variables to be dependent.
//
// g) If your computer handles integer division of negative operands in a
// nonstandard way, you may get results that are rounded differently. Although
// TEX is careful to be machine-independent in this regard, METAFONT is not,
// because integer divisions are present in so many places.
func test4(t *testing.T, testdata map[string][]byte) {
	b, err := os.ReadFile("trap.log")
	if err != nil {
		t.Fatal(err)
	}

	g, e := noBanner(string(b)), noBanner(string(testdata["trap.log"]))
	if g != e {
		diff := difflib.UnifiedDiff{
			A:        difflib.SplitLines(e),
			B:        difflib.SplitLines(g),
			FromFile: "trap.log.0",
			ToFile:   "trap.log.3",
			Context:  0,
		}
		s, _ := difflib.GetUnifiedDiffString(diff)
		t.Fatalf(
			"result differs\n%v\n--- expected\n%s\n\n--- got\n%s\n\n--- expected\n%s\n--- got\n%s",
			s, e, g, hex.Dump([]byte(e)), hex.Dump([]byte(g)),
		)
	}

	t.Logf("%v bytes matches trap.log.0 OK", len(g))
}

// 5. Use GFtype to convert your file TRAP.72270GF to a file TRAP.TYP. (Both of
// GFtype’s options, i.e., mnemonic output and image output, should be enabled
// so that you get the maximum amount of output.) The resulting file should
// agree with the master TRAP.TYP file of step 0, assuming that your GFtype has
// the “normal” values of compile-time constants (top pixel = 69, etc.).
func test5(t *testing.T, testdata map[string][]byte) {
	gfFile, err := os.Open("trap.72270gf")
	if err != nil {
		t.Fatal(err)
	}

	defer gfFile.Close()

	stdout := bytes.NewBuffer(nil)
	stderr := bytes.NewBuffer(nil)
	if err := gftype.Main(gfFile, stdout, stderr, true, true); err != nil {
		t.Fatal(err)
	}

	g, e := noBanner(stdout.String()), noBanner(string(testdata["trap.typ"]))
	if g != e {
		diff := difflib.UnifiedDiff{
			A:        difflib.SplitLines(e),
			B:        difflib.SplitLines(g),
			FromFile: "stdout",
			ToFile:   "trap.typ",
			Context:  0,
		}
		s, _ := difflib.GetUnifiedDiffString(diff)
		t.Fatalf(
			"result differs\n%v\n--- expected\n%s\n\n--- got\n%s\n\n--- expected\n%s\n--- got\n%s",
			s, e, g, hex.Dump([]byte(e)), hex.Dump([]byte(g)),
		)
	}

	t.Logf("%v bytes matches trap.typ OK", len(g))
}

// 6. Use TFtoPL to convert your file TRAP.TFM to a file TRAP.PL. The resulting
// file should agree with the master TRAP.PL file of step 0.
func test6(t *testing.T, testdata map[string][]byte) {
	tfmFile, err := os.Open("trap.tfm")
	if err != nil {
		t.Fatal(err)
	}

	defer tfmFile.Close()

	plFile := bytes.NewBuffer(nil)
	stdout := bytes.NewBuffer(nil)
	stderr := bytes.NewBuffer(nil)
	if err := tftopl.Main(tfmFile, plFile, stdout, stderr); err != nil {
		t.Fatal(err)
	}

	g, e := plFile.String(), string(testdata["trap.pl"])
	if g != e {
		diff := difflib.UnifiedDiff{
			A:        difflib.SplitLines(e),
			B:        difflib.SplitLines(g),
			FromFile: "plFile",
			ToFile:   "trap.pl",
			Context:  0,
		}
		s, _ := difflib.GetUnifiedDiffString(diff)
		t.Fatalf(
			"result differs\n%v\n--- expected\n%s\n\n--- got\n%s\n\n--- expected\n%s\n--- got\n%s",
			s, e, g, hex.Dump([]byte(e)), hex.Dump([]byte(g)),
		)
	}

	t.Logf("%v bytes matches trap.pl OK", len(g))
}