← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/gopkg.in/check.v1/check.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gopkg.in/check.v1/check.go
335
335
                        if name == "Value.call" && strings.HasSuffix(path, valueGo) {
336
336
                                continue
337
337
                        }
338
 
                        if name == "call16" && strings.Contains(path, asmGo) {
 
338
                        if (name == "call16" || name == "call32") && strings.Contains(path, asmGo) {
339
339
                                continue
340
340
                        }
341
341
                        c.logf("%s:%d\n  in %s", nicePath(file), line, name)
871
871
                runner.output.WriteCallSuccess("MISS", c)
872
872
        }
873
873
}
874
 
 
875
 
// -----------------------------------------------------------------------
876
 
// Output writer manages atomic output writing according to settings.
877
 
 
878
 
type outputWriter struct {
879
 
        m                    sync.Mutex
880
 
        writer               io.Writer
881
 
        wroteCallProblemLast bool
882
 
        Stream               bool
883
 
        Verbose              bool
884
 
}
885
 
 
886
 
func newOutputWriter(writer io.Writer, stream, verbose bool) *outputWriter {
887
 
        return &outputWriter{writer: writer, Stream: stream, Verbose: verbose}
888
 
}
889
 
 
890
 
func (ow *outputWriter) Write(content []byte) (n int, err error) {
891
 
        ow.m.Lock()
892
 
        n, err = ow.writer.Write(content)
893
 
        ow.m.Unlock()
894
 
        return
895
 
}
896
 
 
897
 
func (ow *outputWriter) WriteCallStarted(label string, c *C) {
898
 
        if ow.Stream {
899
 
                header := renderCallHeader(label, c, "", "\n")
900
 
                ow.m.Lock()
901
 
                ow.writer.Write([]byte(header))
902
 
                ow.m.Unlock()
903
 
        }
904
 
}
905
 
 
906
 
func (ow *outputWriter) WriteCallProblem(label string, c *C) {
907
 
        var prefix string
908
 
        if !ow.Stream {
909
 
                prefix = "\n-----------------------------------" +
910
 
                        "-----------------------------------\n"
911
 
        }
912
 
        header := renderCallHeader(label, c, prefix, "\n\n")
913
 
        ow.m.Lock()
914
 
        ow.wroteCallProblemLast = true
915
 
        ow.writer.Write([]byte(header))
916
 
        if !ow.Stream {
917
 
                c.logb.WriteTo(ow.writer)
918
 
        }
919
 
        ow.m.Unlock()
920
 
}
921
 
 
922
 
func (ow *outputWriter) WriteCallSuccess(label string, c *C) {
923
 
        if ow.Stream || (ow.Verbose && c.kind == testKd) {
924
 
                // TODO Use a buffer here.
925
 
                var suffix string
926
 
                if c.reason != "" {
927
 
                        suffix = " (" + c.reason + ")"
928
 
                }
929
 
                if c.status() == succeededSt {
930
 
                        suffix += "\t" + c.timerString()
931
 
                }
932
 
                suffix += "\n"
933
 
                if ow.Stream {
934
 
                        suffix += "\n"
935
 
                }
936
 
                header := renderCallHeader(label, c, "", suffix)
937
 
                ow.m.Lock()
938
 
                // Resist temptation of using line as prefix above due to race.
939
 
                if !ow.Stream && ow.wroteCallProblemLast {
940
 
                        header = "\n-----------------------------------" +
941
 
                                "-----------------------------------\n" +
942
 
                                header
943
 
                }
944
 
                ow.wroteCallProblemLast = false
945
 
                ow.writer.Write([]byte(header))
946
 
                ow.m.Unlock()
947
 
        }
948
 
}
949
 
 
950
 
func renderCallHeader(label string, c *C, prefix, suffix string) string {
951
 
        pc := c.method.PC()
952
 
        return fmt.Sprintf("%s%s: %s: %s%s", prefix, label, niceFuncPath(pc),
953
 
                niceFuncName(pc), suffix)
954
 
}