स्पॉक

Question

में ऐरे का दावा मेरे पास कुछ ऑब्जेक्ट्स की एक सूची है - आइए कंपनियां मान लें। अब मैं यह जांचना चाहता हूं कि इस सूची में कुछ नाम वाली कंपनियां हैं लेकिन ध्यान में विचार नहीं ले रही हैं।

companyList.name.sort() == ["First", "Second"]

वहाँ स्पॉक या ग्रूवी में किसी भी ऑपरेटर है कि मुझे के आदेश के बिना सरणियों की तुलना करने देता है: वर्तमान में मैं इस तरह के निर्माण का उपयोग कर रहा हूँ?

Answer 1

जहां तक ​​मुझे पता है ऐसे कोई ऑपरेटर नहीं है। सूची डुप्लीकेट निम्नलिखित धारणा इस्तेमाल किया जा सकता शामिल नहीं है:

companyList.name as Set == ["First", "Second"] as Set 

या ऐसा ही कुछ: @Opal जवाब के लिए

companyList.name.size() == ["First", "Second"].size() && companyList.name.containsAll(["First", "Second"]) 

Answer 2

upvoted, यह शायद सभी मामले में सबसे अच्छा है। एक जिज्ञासा के रूप में मैं केवल दो अवर्गीकृत सूचियों की तुलना करने के लिए माइनस ऑपरेटर के उपयोग का एक उदाहरण जोड़ना होगा:

import spock.lang.Specification 

class ComparingListsSpec extends Specification { 

    def "should contain all companies in two unsorted lists"() { 
     when: 
     def companies = ["Lorem", "ipsum", "dolor", "sit", "amet"] 
     def unsorted = ["ipsum", "sit", "Lorem", "dolor", "amet"] 

     then: 
     companies - unsorted == [] 

     and: 
     unsorted - companies == [] 

     and: 
     companies - unsorted in [[]] 
    } 
} 

यह भी काम करता है अगर सूचियों में से एक अनावश्यक डेटा शामिल हैं।

Answer 3

आप स्पॉक में हैमक्रिस्ट समर्थन का उपयोग कर सकते हैं और इस मामले के लिए स्पष्ट रूप से डिजाइन किए गए Matcher का उपयोग कर सकते हैं - containsInAnyOrder। आप नीचे दिए गए आयात की जरूरत है: इस प्रकार

import static org.hamcrest.Matchers.containsInAnyOrder 
import static spock.util.matcher.HamcrestSupport.that 

तो फिर आप अपने परीक्षण कोड लिख सकते हैं:

given: 
    def companyList = [ "Second", "First"] 
expect: 
    that companyList, containsInAnyOrder("First", "Second") 

इस सूची में है कि नकल तत्वों को सही ढंग से विचार किया जाएगा में .sort() का उपयोग करने पर लाभ है। निम्न परीक्षण Hamcrest का उपयोग कर असफल हो जायेगी लेकिन .sort()

given: 
    def companyList = [ "Second", "First", "Second"] 
expect: 
    that companyList, containsInAnyOrder("First", "Second") 

Condition not satisfied: 

that companyList, containsInAnyOrder("First", "Second") 
| | 
| [Second, First, Second] 
false 

Expected: iterable over ["First", "Second"] in any order 
    but: Not matched: "Second" 

का उपयोग कर उत्तीर्ण आप expect: के बजाय then: उपयोग कर रहे हैं आप पठनीयता के लिए that आयात की expect बजाय उपयोग कर सकते हैं।

then: 
    expect companyList, containsInAnyOrder("First", "Second")