Esempio n. 1
0
func TestParseStdin(t *testing.T) {
	r, w, err := os.Pipe()
	if err != nil {
		t.Fatalf("pipe: %s", err)
	}
	fd, err := os.Open("example")
	if err != nil {
		t.Fatalf("ex: %s", err)
	}
	defer fd.Close()
	go func() {
		io.Copy(w, fd)
		w.Close()
	}()
	os.Stdin = r
	app.New()
	defer app.Exiting()
	ql := func() {
		c := app.AppCtx()
		c.Debug = testing.Verbose()
		app.SetIO(app.OSIn(), 0)
		Run()
	}
	x := app.Go(ql, "ql", "-n")
	<-x.Wait
	if x.Sts != nil {
		t.Fatalf("did fail")
	}
}
Esempio n. 2
0
func TestCmds(t *testing.T) {
	os.Args[0] = "ql.test"
	app.Debug = testing.Verbose() && false
	app.Verb = testing.Verbose() && false
	app.New()
	app.AppCtx().Debug = testing.Verbose()
	dbg.ExitDumpsStacks = testing.Verbose()
	defer app.Exiting()
	inc := make(chan interface{}, 3)
	inc <- []byte("hi\n")
	inc <- []byte("there\n")
	close(inc)
	app.SetIO(inc, 0)
	ql := func() {
		app.AppCtx().Debug = testing.Verbose()
		Run()
	}
	for _, c := range cmds {
		args := []string{"ql", "-c", c}
		if testing.Verbose() {
			args = []string{"ql", "-X", "-c", c}
		}
		x := app.Go(ql, args...)
		<-x.Wait
		if x.Sts != nil {
			t.Logf("did fail with sts %v", x.Sts)
		}
	}
}
Esempio n. 3
0
func newEnv(name string) *qEnv {
	e := &qEnv{
		name: name,
		vars: app.Env(),
		cmds: map[string]*qCmd{},
		runc: make(chan func()),
	}
	app.Go(e.run, "ctx")
	return e
}
Esempio n. 4
0
func TestParseCmd(t *testing.T) {
	app.New()
	defer app.Exiting()
	ql := func() {
		app.AppCtx().Debug = testing.Verbose()
		Run()
	}
	x := app.Go(ql, "ql", "-n", "-c", "pwd")
	<-x.Wait
	if x.Sts != nil {
		t.Fatalf("did fail")
	}
}
Esempio n. 5
0
func TestParseError(t *testing.T) {
	app.New()
	defer app.Exiting()
	ql := func() {
		app.AppCtx().Debug = testing.Verbose()
		Run()
	}
	x := app.Go(ql, "ql", "-n", "-c", "pw{d")
	<-x.Wait
	if x.Sts == nil {
		t.Logf("warn: ql didn't fail")
	}
}
Esempio n. 6
0
func (c *qCmd) start(txt string) error {
	c.Lock()
	if c.ctx != nil {
		c.Unlock()
		return fmt.Errorf("%s: one cmd is enough", c)
	}
	c.txt = txt
	var in chan interface{}
	if c.in.Len() > 0 {
		c.in.c = make(chan interface{}, len(c.in.msgs))
		for _, m := range c.in.msgs {
			c.in.c <- m
		}
		close(c.in.c)
		in = c.in.c
	}
	outfn := func(c *qCmd, io *qIO, outc chan interface{}) {
		for m := range outc {
			c.Lock()
			io.addOut(m)
			c.Unlock()
		}
		io.eof = true
		io.wakeup()
	}
	out := make(chan interface{})
	go outfn(c, c.out, out)
	err := make(chan interface{})
	go outfn(c, c.err, err)
	c.e.runc <- func() {
		c.ctx = app.Go(func() {
			c.Unlock()
			app.DupDot()
			app.DupEnv()
			app.NewIO(nil)
			app.SetIO(in, 0)
			app.SetIO(out, 1)
			app.SetIO(err, 2)
			ql.Run()
		}, "ql", "-c", c.txt)
	}
	return nil
}