आप "परीक्षण" पैकेज का उपयोग करके एक गो परीक्षण में कैसे प्रिंट करते हैं?

129

मैं गो टू (स्टेटमेंट ऑफ डिबगिंग के लिए) को मुद्रित करने के लिए एक कथन के साथ एक परीक्षण चला रहा हूं, लेकिन यह कुछ भी नहीं छाप रहा है।

func TestPrintSomething(t *testing.T) {
    fmt.Println("Say hi")
}

जब मैं इस फाइल पर गो टेस्ट चलाता हूं, तो यह आउटपुट है:

ok      command-line-arguments  0.004s

वास्तव में इसे प्रिंट करने का एकमात्र तरीका, जहाँ तक मुझे पता है, इसे t.Error () के माध्यम से प्रिंट करना है, जैसे:

func TestPrintSomethingAgain(t *testing.T) {
    t.Error("Say hi")
}

जो इसे आउटपुट करता है:

Say hi
--- FAIL: TestPrintSomethingAgain (0.00 seconds)
    foo_test.go:35: Say hi
FAIL
FAIL    command-line-arguments  0.003s
gom:  exit status 1

मैंने Googled और मैनुअल के माध्यम से देखा लेकिन कुछ भी नहीं मिला।

testing go

— platwp
स्रोत

यह गो 1.14 (Q1 2010) के लिए संभव हो सकता है। देखें नीचे मेरा उत्तर ।

— VonC

@VonC s / b Q1 2020

— user2133814

@ user2133814 सहमत हैं, यह वास्तव में 2020 होना चाहिए, न कि 2010। नीचे दिए गए उत्तर में 2020 का उल्लेख है। मैंने उस नई सुविधा पर डेव चेनी के लेख के संदर्भ के साथ उत्तर कहा है।

— VonC

142

संरचनाएं testing.Tऔर testing.Bदोनों में एक .Logऔर .Logfविधि है जो आपको ढूंढने के लिए ध्वनि है। .Logऔर .Logfके समान हैं fmt.Printऔर fmt.Printfक्रमशः।

अधिक विवरण यहां देखें: http://golang.org/pkg/testing/#pkg-index

fmt.Xप्रिंट बयान कर परीक्षण के अंदर काम करते हैं, लेकिन आप पाएंगे अपने उत्पादन में शायद स्क्रीन जहाँ आप इसे खोजने के लिए और, इसलिए, तुम क्यों में प्रवेश तरीकों का उपयोग करना चाहिए उम्मीद पर नहीं है testing।

यदि, आपके मामले में, आप परीक्षणों के लिए लॉग देखना चाहते हैं जो विफल नहीं हो रहे हैं, तो आपको ध्वज प्रदान go testकरना होगा -v(क्रिया के लिए v)। परीक्षण झंडे के बारे में अधिक विवरण यहां पाया जा सकता है: https://golang.org/cmd/go/#hdr-Testing_flags

— voidlogic
स्रोत

15

t.og () परीक्षण पूरा होने के बाद तक दिखाई नहीं देगा, इसलिए यदि आप एक ऐसे परीक्षण को डिबग करने की कोशिश कर रहे हैं जो लटका हुआ है या बुरी तरह से प्रदर्शन कर रहा है तो ऐसा लगता है कि आपको fmt का उपयोग करने की आवश्यकता है। परीक्षण चलाने पर fmt.Println का आउटपुट दिखाने के लिए गो-टेस्ट का उपयोग करने के लिए पीटरो का उत्तर देखें।

— voutasaurus

142

उदाहरण के लिए,

package verbose

import (
    "fmt"
    "testing"
)

func TestPrintSomething(t *testing.T) {
    fmt.Println("Say hi")
    t.Log("Say bye")
}

go test -v
=== RUN TestPrintSomething
Say hi
--- PASS: TestPrintSomething (0.00 seconds)
    v_test.go:10: Say bye
PASS
ok      so/v    0.002s

आज्ञा जाओ

परीक्षण झंडे का विवरण
-v
Verbose output: log all tests as they are run. Also print all
text from Log and Logf calls even if the test succeeds.

पैकेज परीक्षण

func (* T) लॉग करें
func (c *T) Log(args ...interface{})
डिफ़ॉल्ट स्वरूपण, Println के अनुरूप, और त्रुटि लॉग में पाठ रिकॉर्ड करने के लिए तर्क का उपयोग करें। परीक्षणों के लिए, पाठ केवल तभी प्रिंट किया जाएगा जब परीक्षण विफल हो जाता है या -test.v ध्वज सेट हो जाता है। मानदंड के लिए, पाठ को हमेशा प्रदर्शन से बचने के लिए मुद्रित किया जाता है -test.v ध्वज के मूल्य पर निर्भर करता है।

— peterSO
स्रोत

21

verboseजिसकी मुझे तलाश थी वह है।

— केवार्इस

2

मुहोडोड में लॉग आउटपुट देखने के लिए anwa ही परीक्षण कर रहे हैं

— गंदी_विशाल

7

t.Log()परीक्षण पूरा होने तक नहीं दिखाएंगे, इसलिए यदि आप एक ऐसे परीक्षण को डिबग करने का प्रयास कर रहे हैं जो लटका हुआ है या बुरी तरह से प्रदर्शन कर रहा है तो ऐसा लगता है कि आपको उपयोग करने की आवश्यकता है fmt।

हां: यह गो 1.13 (अगस्त 2019) तक मामला था।

और इसके बाद अंक 24929 जारी किया गयाgolang.org

निम्नलिखित (मूर्खतापूर्ण) स्वचालित परीक्षणों पर विचार करें:
func TestFoo(t *testing.T) {
    t.Parallel()

  for i := 0; i < 15; i++ {
        t.Logf("%d", i)
        time.Sleep(3 * time.Second)
    }
}

func TestBar(t *testing.T) {
    t.Parallel()

  for i := 0; i < 15; i++ {
        t.Logf("%d", i)
        time.Sleep(2 * time.Second)
    }
}

func TestBaz(t *testing.T) {
    t.Parallel()

  for i := 0; i < 15; i++ {
        t.Logf("%d", i)
        time.Sleep(1 * time.Second)
    }
}
अगर मैं दौड़ता हूं go test -v, तो मुझे तब तक कोई लॉग आउटपुट नहीं मिलता हैTestFoo , जब तक कि सभी का काम नहीं हो जाता है , जब तक कि सभी का काम TestBarपूरा नहीं हो जाता है और तब तक कोई और आउटपुट नहीं मिलता TestBazहै।
यह ठीक है अगर परीक्षण काम कर रहे हैं, लेकिन अगर किसी प्रकार का बग है, तो कुछ मामले हैं जहां लॉग आउटपुट बफ़र करना समस्याग्रस्त है:

स्थानीय रूप से पुनरावृत्त होने पर, मैं एक बदलाव करने में सक्षम होना चाहता हूं, अपने परीक्षण चला रहा हूं, देखें कि क्या हो रहा है, यह समझने के लिए तुरंत लॉग में क्या हो रहा है, यदि आवश्यक हो तो परीक्षण को जल्दी बंद करने के लिए CTRL + C को हिट करें, एक और बदलाव करें, फिर से- परीक्षण चलाते हैं, और इसी तरह।
यदि TestFooधीमा है (उदाहरण के लिए, यह एक एकीकरण परीक्षण है), तो मुझे परीक्षण के बहुत अंत तक कोई लॉग आउटपुट नहीं मिलता है। यह महत्वपूर्ण रूप से चलना धीमा कर देता है।

अगर TestFooएक बग है जो इसे लटका देता है और कभी पूरा नहीं होता है, तो मुझे कोई लॉग आउटपुट नहीं मिलेगा। इन मामलों में, t.Logऔर t.Logfइसका कोई फायदा नहीं है।
इससे डिबगिंग बहुत मुश्किल हो जाता है।

इसके अलावा, न केवल मुझे कोई लॉग आउटपुट नहीं मिलता है, लेकिन यदि परीक्षण बहुत लंबा लटका रहता है, तो या तो गो परीक्षण टाइमआउट 10 मिनट के बाद परीक्षण को मारता है, या यदि मैं उस टाइमआउट को बढ़ाता हूं, तो कई सीआई सर्वर भी परीक्षण को मार देंगे यदि कोई नहीं है एक निश्चित समय (जैसे सर्किल में 10 मिनट) के बाद आउटपुट लॉग करें।
इसलिए अब मेरे परीक्षण मारे गए हैं और मुझे लॉग में कुछ भी नहीं है कि मुझे बताएं कि क्या हुआ।

लेकिन (संभवतः) के लिए 1.14 (Q1 2020) जाओ: सीएल 127120

परीक्षण: वर्बोज़ मोड में स्ट्रीम लॉग आउटपुट

अब आउटपुट है:

=== RUN   TestFoo
=== PAUSE TestFoo
=== RUN   TestBar
=== PAUSE TestBar
=== RUN   TestGaz
=== PAUSE TestGaz
=== CONT  TestFoo
    TestFoo: main_test.go:14: hello from foo
=== CONT  TestGaz
=== CONT  TestBar
    TestGaz: main_test.go:38: hello from gaz
    TestBar: main_test.go:26: hello from bar
    TestFoo: main_test.go:14: hello from foo
    TestBar: main_test.go:26: hello from bar
    TestGaz: main_test.go:38: hello from gaz
    TestFoo: main_test.go:14: hello from foo
    TestGaz: main_test.go:38: hello from gaz
    TestBar: main_test.go:26: hello from bar
    TestFoo: main_test.go:14: hello from foo
    TestGaz: main_test.go:38: hello from gaz
    TestBar: main_test.go:26: hello from bar
    TestGaz: main_test.go:38: hello from gaz
    TestFoo: main_test.go:14: hello from foo
    TestBar: main_test.go:26: hello from bar
--- PASS: TestFoo (1.00s)
--- PASS: TestGaz (1.00s)
--- PASS: TestBar (1.00s)
PASS
ok      dummy/streaming-test    1.022s

यह वास्तव में गो 1.14 में है, क्योंकि डेव चेनी " go test -vस्ट्रीमिंग आउटपुट " में शामिल हैं:

1.14 में, आउटपुट कोgo test -v स्ट्रीम करेगा जैसा कि होता है, होर्डिंग के बजाय यह टेस्ट रन के अंत को झुकाता है ।t.Log

गो १.१४ के तहत fmt.Printlnऔर t.Logलाइनों को इंटरलेय किया जाता है , बजाय परीक्षण के पूरा होने के इंतजार के, यह दिखाते हुए कि परीक्षण आउटपुट go test -vका उपयोग किए जाने पर स्ट्रीम किया जाता है।

डेव के अनुसार, लाभ:

यह एकीकरण शैली परीक्षणों के लिए जीवन सुधार का एक बड़ा गुण है जो अक्सर परीक्षण विफल होने पर लंबे समय तक पुन: प्रयास करते हैं।
स्ट्रीमिंग t.Logआउटपुट गोफ़र्स को उन परीक्षण विफलताओं को डिबग करने में मदद करेगा, जब तक कि उनके आउटपुट प्राप्त करने के लिए पूरे परीक्षण समय तक इंतजार न करना पड़े।

— VonC
स्रोत

5

कभी-कभी परीक्षण के लिए मैं करता हूं

fmt.Fprintln(os.Stdout, "hello")

इसके अलावा, आप इसके लिए प्रिंट कर सकते हैं:

fmt.Fprintln(os.Stderr, "hello)

— एड्डी हर्नांडेज़
स्रोत

उनमें से पहला बस हो सकता है fmt.Println("hello")।

— डंकन जोन्स

2

t.Logऔर t.Logfअपने परीक्षण में प्रिंट आउट लें, लेकिन अक्सर याद किया जा सकता है क्योंकि यह आपके परीक्षण के समान लाइन पर प्रिंट करता है। जो मैं करता हूं वह उन्हें इस तरह से लॉग इन करता है जिससे उन्हें बाहर खड़ा होना पड़ता है, अर्थात

t.Run("FindIntercomUserAndReturnID should find an intercom user", func(t *testing.T) {

    id, err := ic.FindIntercomUserAndReturnID("test3@test.com")
    assert.Nil(t, err)
    assert.NotNil(t, id)

    t.Logf("\n\nid: %v\n\n", *id)
})

जो इसे टर्मिनल पर प्रिंट करता है,

=== RUN   TestIntercom
=== RUN   TestIntercom/FindIntercomUserAndReturnID_should_find_an_intercom_user
    TestIntercom/FindIntercomUserAndReturnID_should_find_an_intercom_user: intercom_test.go:34:

        id: 5ea8caed05a4862c0d712008

--- PASS: TestIntercom (1.45s)
    --- PASS: TestIntercom/FindIntercomUserAndReturnID_should_find_an_intercom_user (1.45s)
PASS
ok      github.com/RuNpiXelruN/third-party-delete-service   1.470s

— RuNpiXelruN
स्रोत

-2

*_test.goफ़ाइल दूसरों की तरह एक जाओ स्रोत, यदि आप जटिल डेटा संरचना, यहां एक उदाहरण डंप करने की जरूरत है एक नया लकड़हारा हर बार प्रारंभ कर सकते हैं:

// initZapLog is delegated to initialize a new 'log manager'
func initZapLog() *zap.Logger {
    config := zap.NewDevelopmentConfig()
    config.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
    config.EncoderConfig.TimeKey = "timestamp"
    config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    logger, _ := config.Build()
    return logger
}

फिर, हर बार, हर परीक्षा में:

func TestCreateDB(t *testing.T) {
    loggerMgr := initZapLog()
    // Make logger avaible everywhere
    zap.ReplaceGlobals(loggerMgr)
    defer loggerMgr.Sync() // flushes buffer, if any
    logger := loggerMgr.Sugar()
    logger.Debug("START")
    conf := initConf()
    /* Your test here
    if false {
        t.Fail()
    }*/
}

— alessiosavi
स्रोत