Elixir 1.7

ExUnit.Assertions




elixir

ExUnit.Assertions

इस मॉड्यूल में मुखर फ़ंक्शन का एक सेट है जो आपके परीक्षण मामलों में डिफ़ॉल्ट रूप से आयात किया जाता है।

सामान्य तौर पर, एक डेवलपर परीक्षणों में सामान्य assert मैक्रो का उपयोग करना चाहेगा। यह मैक्रो आपके कोड को इंट्रोस्पेक्ट करता है और जब भी विफलता होती है तो अच्छी रिपोर्टिंग प्रदान करता है। उदाहरण के लिए, assert some_fun() == 10 को विफल करें ( some_fun() मानकर some_fun() 13 रिटर्न):

Comparison (using ==) failed in:
code:  some_fun() == 10
left:  13
right: 10

यह मॉड्यूल अन्य सुविधा कार्य भी प्रदान करता है जैसे कि assert_in_delta और assert_raise अन्य सामान्य मामलों को आसानी से संभालने के लिए जैसे कि फ्लोटिंग-पॉइंट नंबर की जाँच करना या अपवादों को संभालना।

सारांश

कार्य

assert(assertion)

इसका तर्क एक सत्य मूल्य है

मुखर (मूल्य, संदेश)

मुखर value true , अन्यथा दिए गए message प्रदर्शित करना

assert_in_delta (value1, value2, delta, message \\ nil)

value1 लेता है कि value1 और value2 delta से अधिक नहीं है

assert_raise (अपवाद, कार्य)

function निष्पादन के दौरान exception उठाया जाता है। बचाया अपवाद लौटाता है, अन्यथा विफल रहता है

assert_raise (अपवाद, संदेश, कार्य)

exception को अपेक्षित message साथ function निष्पादन के दौरान उठाया जाता है, जो Regex या सटीक String । बचाया अपवाद लौटाता है, अन्यथा विफल रहता है

assert_receive (पैटर्न, टाइमआउट \\ Application.fetch_env! (: ex_unit,: assert_receive_timeout), विफलता_message \\ nil)

संदेश देता है कि मिलिसेकंड में निर्दिष्ट timeout अवधि के भीतर एक संदेश मिलान pattern प्राप्त होने वाला था या मिलने वाला था

assert_received (पैटर्न, विफलता_मेज़ेज \\ nil)

एक संदेश मिलान pattern प्राप्त किया गया था और वर्तमान प्रक्रिया 'मेलबॉक्स में है

catch_error(expression)

expression त्रुटि का कारण होगा

catch_exit(expression)

मुखर expression बाहर निकल जाएगी

catch_throw(expression)

मुखर expression एक मूल्य फेंक देंगे

flunk (संदेश \\ "Flunked!")

एक संदेश के साथ विफल

refute(assertion)

एक नकारात्मक अभिकथन, अभिव्यक्ति के false या nil होने की उम्मीद करता है

खंडन (मान, संदेश)

value का value nil या false (अर्थात value सत्य नहीं है)

refute_in_delta (value1, value2, delta, message \\ nil)

value1 और value2 delta भीतर नहीं हैं

Refute_receive (पैटर्न, टाइमआउट \\ Application.fetch_env! (: ex_unit,: refute_receive_timeout), विफलता_मेसेज \\ nil)

यह दावा करता है कि एक संदेश मिलान pattern , मिलीसेकंड में निर्दिष्ट timeout अवधि के भीतर प्राप्त नहीं किया गया था (और प्राप्त नहीं होगा)

refute_received (पैटर्न, विफलता_मेज़ेज \\ nil)

संदेश से मेल खाने वाला pattern प्राप्त नहीं हुआ (यानी यह वर्तमान प्रक्रिया 'मेलबॉक्स में नहीं है)

कार्य

मुखर (अभिकथन) (स्थूल)

इसका तर्क एक सत्य मूल्य है।

assert अंतर्निहित अभिव्यक्ति को आत्मसात करता है और जब भी विफलता होती है तो अच्छी रिपोर्टिंग प्रदान करता है। उदाहरण के लिए, यदि अभिव्यक्ति तुलना ऑपरेटर का उपयोग करता है, तो संदेश दोनों पक्षों के मूल्यों को दिखाएगा। जोर लगाना

assert 1 + 2 + 3 + 4 > 15

संदेश के साथ विफल हो जाएगा:

Assertion with > failed
code:  1 + 2 + 3 + 4 > 15
left:  10
right: 15

इसी तरह, यदि एक मैच अभिव्यक्ति दी जाती है, तो यह उस मैच के संदर्भ में किसी भी विफलता की रिपोर्ट करेगी। दिया हुआ

assert [1] = [2]

तुम देखोगे:

match (=) failed
code:  [1] = [2]
right: [2]

ध्यान रखें कि assert अभिव्यक्ति के आधार पर अपने शब्दार्थ को नहीं बदलता है। दूसरे शब्दों में, सत्य मूल्य वापस करने के लिए अभिव्यक्ति की आवश्यकता है। उदाहरण के लिए, निम्नलिखित विफल हो जाएगा:

assert nil = some_function_that_returns_nil()

भले ही मैच काम करता है, लेकिन assert अभी भी एक सत्य मूल्य की उम्मीद करता है। ऐसे मामलों में, बस Kernel.==/2 उपयोग करें Kernel.==/2 या Kernel.==/2

मुखर (मूल्य, संदेश)

मुखर value true , अन्यथा दिए गए message प्रदर्शित करना।

उदाहरण

assert false, "it will never be true"

assert_in_delta (value1, value2, delta, message \\ nil)

value1 लेता है कि value1 और value2 delta से अधिक नहीं है।

यह अंतर समावेशी है, इसलिए यदि अंतर और delta बराबर हैं तो परीक्षण पास होगा।

उदाहरण

assert_in_delta 1.1, 1.5, 0.2
assert_in_delta 10, 15, 2
assert_in_delta 10, 15, 5

assert_raise (अपवाद, कार्य)

function निष्पादन के दौरान exception उठाया जाता है। बचाया अपवाद लौटाता है, अन्यथा विफल रहता है।

उदाहरण

assert_raise ArithmeticError, fn ->
  1 + "test"
end

assert_raise (अपवाद, संदेश, कार्य)

exception को अपेक्षित message साथ function निष्पादन के दौरान उठाया जाता है, जो Regex या सटीक String । बचाया अपवाद लौटाता है, अन्यथा विफल रहता है।

उदाहरण

assert_raise ArithmeticError, "bad argument in arithmetic expression", fn ->
  1 + "test"
end

assert_raise RuntimeError, ~r/^today's lucky number is 0.+!$/, fn ->
  raise "today's lucky number is 0.35798496614795583!"
end

assert_receive (पैटर्न, टाइमआउट \\ Application.fetch_env! (: ex_unit,: assert_receive_timeout), विफलता_message \\ nil) (मैक्रो)

संदेश देता है कि मिलिसेकंड में निर्दिष्ट timeout अवधि के भीतर एक संदेश मिलान pattern प्राप्त होने वाला था या मिलने वाला था।

assert_received विपरीत, इसमें 100 मिलीसेकंड का डिफ़ॉल्ट timeout है।

pattern तर्क एक मैच पैटर्न होना चाहिए। यदि संदेश से मेल खाने वाला pattern नहीं failure_message तो failure_message साथ failure_message

उदाहरण

assert_receive :hello

एक बड़े समय के खिलाफ जोर देता है:

assert_receive :hello, 20_000

आप विशिष्ट पैटर्न के खिलाफ भी मैच कर सकते हैं:

assert_receive {:hello, _}

x = 5
assert_receive {:count, ^x}

assert_received (पैटर्न, विफलता_मेज़ेज \\ nil) (मैक्रो)

एक संदेश मिलान pattern प्राप्त किया गया था और वर्तमान प्रक्रिया 'मेलबॉक्स में है।

pattern तर्क एक मैच पैटर्न होना चाहिए। यदि संदेश से मेल खाने वाला pattern प्राप्त नहीं हुआ, तो failure_message साथ failure_message

टाइमआउट 0 पर सेट है, इसलिए प्रतीक्षा समय नहीं है।

उदाहरण

send self(), :hello
assert_received :hello

send self(), :bye
assert_received :hello, "Oh No!"
** (ExUnit.AssertionError) Oh No!
Process mailbox:
  :bye

आप विशिष्ट पैटर्न के खिलाफ भी मैच कर सकते हैं:

send self(), {:hello, "world"}
assert_received {:hello, _}

catch_error (अभिव्यक्ति) (मैक्रो)

expression त्रुटि का कारण होगा।

त्रुटि देता है या अन्यथा विफल रहता है।

उदाहरण

assert catch_error(error 1) == 1

catch_exit (अभिव्यक्ति) (मैक्रो)

मुखर expression बाहर निकल जाएगी।

वर्तमान प्रक्रिया की निकास स्थिति / संदेश लौटाता है या अन्यथा विफल रहता है।

उदाहरण

assert catch_exit(exit 1) == 1

परीक्षण से शुरू की गई लिंक से बाहर निकलने का दावा करने के लिए, assert_received/2 . Process.flag/2 साथ बाहर निकलता है और assert_received/2 साथ बाहर निकलने का संदेश देता है।

Process.flag(:trap_exit, true)
pid = spawn_link(fn -> Process.exit(self(), :normal) end)
assert_receive {:EXIT, ^pid, :normal}

catch_throw (अभिव्यक्ति) (मैक्रो)

मुखर expression एक मूल्य फेंक देंगे।

फेंक दिया गया मान लौटाता है या अन्यथा विफल रहता है।

उदाहरण

assert catch_throw(throw 1) == 1

flunk (संदेश \\ "Flunked!")

flunk(String.t()) :: no_return()

एक संदेश के साथ विफल।

उदाहरण

flunk "This should raise an error"

खंडन (अभिकथन) (स्थूल)

एक नकारात्मक अभिकथन, अभिव्यक्ति के false या nil होने की उम्मीद करता है।

ध्यान रखें कि refute दी गई अभिव्यक्ति के शब्दार्थों को नहीं बदलता है। दूसरे शब्दों में, निम्नलिखित विफल हो जाएगा:

refute {:ok, _} = some_function_that_returns_error_tuple()

उपरोक्त कोड विफल हो जाएगा क्योंकि = ऑपरेटर हमेशा विफल रहता है जब पक्ष मेल नहीं खाते हैं और refute/2 इसे परिवर्तित नहीं करता है।

उपरोक्त Kernel.match?/2 लिखने का सही तरीका है कि Kernel.match?/2 का उपयोग Kernel.match?/2 :

refute match? {:ok, _}, some_function_that_returns_error_tuple()

उदाहरण

refute age < 0

खंडन (मान, संदेश)

आवेषण value nil या false (अर्थात, value सत्य नहीं है)।

उदाहरण

refute true, "This will obviously fail"

refute_in_delta (value1, value2, delta, message \\ nil)

value1 और value2 delta भीतर नहीं हैं।

यह अंतर अनन्य है, इसलिए यदि अंतर और डेल्टा बराबर हैं तो परीक्षण विफल हो जाएगा।

यदि आप message आपूर्ति करते हैं, तो मूल्यों के बारे में जानकारी स्वचालित रूप से इसके साथ जुड़ जाएगी।

उदाहरण

refute_in_delta 1.1, 1.2, 0.2
refute_in_delta 10, 11, 2

Refute_receive (पैटर्न, टाइमआउट \\ Application.fetch_env! (: ex_unit,: refute_receive_timeout), विफलता_message \\ nil) (मैक्रो)

यह दावा करता है कि एक संदेश मिलान pattern , मिलीसेकंड में निर्दिष्ट timeout अवधि के भीतर प्राप्त नहीं किया गया था (और प्राप्त नहीं होगा)।

pattern तर्क एक मैच पैटर्न होना चाहिए। यदि संदेश से मेल खाने वाला pattern failure_message तो failure_message साथ failure_message

उदाहरण

refute_receive :bye

स्पष्ट समयबाह्य के साथ प्राप्त किया गया रिफंड:

refute_receive :bye, 1000

refute_received (पैटर्न, विफलता_मेज़ेज \\ nil) (मैक्रो)

संदेश मिलान pattern प्राप्त नहीं हुआ था (यानी यह वर्तमान प्रक्रिया 'मेलबॉक्स में नहीं है)।

pattern तर्क एक मैच पैटर्न होना चाहिए। यदि संदेश से मेल खाने वाला pattern प्राप्त हुआ था, तो failure_message साथ failure_message

टाइमआउट 0 पर सेट है, इसलिए प्रतीक्षा समय नहीं है।

उदाहरण

send self(), :hello
refute_received :bye

send self(), :hello
refute_received :hello, "Oh No!"
** (ExUnit.AssertionError) Oh No!
Process mailbox:
  :bye