ant in - मैं एक चींटी कार्य के लिए एक तर्क कैसे पास करूं?




hindi ants (9)

मैं चींटी के साथ बहुत अच्छा नहीं हूं, लेकिन हम इसे एक निर्माण उपकरण के रूप में उपयोग कर रहे हैं। अभी, हम "चींटी परीक्षण" चला सकते हैं और यह सभी इकाई परीक्षणों के माध्यम से चलेगा।

हालाँकि, मैं ant test some_module तरह कुछ करने में सक्षम होना पसंद ant test some_module और यह पैरामीटर के रूप में some_module स्वीकार कर some_module , और केवल वही परीक्षण करेगा।

मैं कैसे कमांड लाइन पास करने के लिए नहीं मिल पा रहा है चींटी - किसी भी विचार?


Answers

आप एक समय में एक लक्ष्य तक पहुँचने के लिए यह कोशिश कर सकते हैं। इन बिल्ड को अपनी build.xml फ़ाइल में जोड़ें:

<project name="whatever" default="default">
    <input message="Please select module:" addproperty="mod" />
    <target name="default" depends="${mod}/>
...
</project>

यह आपको उस मॉड्यूल को दर्ज करने की अनुमति देता है जिसे आप निष्पादित और निष्पादित करना चाहते हैं जो पूरे बिल्ड.xml को चलाने के बजाय स्वयं को निष्पादित करता है

पूरी तरह से काम करने के लिए आपको अपने build.xml में कुछ और बदलाव करने की आवश्यकता हो सकती है।


ऐसा न हो कि आपके प्रोजेक्ट में दो मॉड्यूल हैं ModuleX और ModuleY जहां ModuleX को चलाने के लिए 2 Testcases हैं और 10 Testcases के साथ ModuleY हैं।

आप ऐसा कुछ कर सकते हैं:

ant runTestsOnModule -Dtestmodule="ModuleX" 
       OR to test all modules by calling 
ant tests

<target name="runTestsOnModule">
  <antCall target="testcase${testmodule}"/>
</target>'

<! -- run single module -->
<target name="runTestsOnModule">
  <antCall target="testcase${testmodule}"/>
</target>

<!--run all tests-->    
<target name="tests">
   <antcall target="testcaseModuleX">
   <antcall target="testCaseModuleY">
</target>

<target name="testcaseModuleX">
   ..run junit task to call 2 testcase
</target>

<target name="testcaseModuleY">
  ....run junit task to call 10 testcase
</target>

चींटी को आमंत्रित करते समय आप कमांडलाइन पर एक संपत्ति को परिभाषित कर सकते हैं:

ant -Dtest.module=mymodulename

तो आप इसे किसी भी अन्य चींटी संपत्ति के रूप में उपयोग कर सकते हैं:

...
    <fileset dir="${test.dir}" includes="**/${test.module}.class" />
...

एंट की नियमावली पर एक नजर।


अपने परीक्षण लक्ष्य में कुछ सशर्त का उपयोग करने और निर्दिष्ट करने के बारे में क्या -Dcondition=true ?

<target name="test" depends="_test, _test_if_true>
   ...
</target> 

<target name="_test_if_true" if="condition">
   ...
</target>

<target name="_test" unless="condition">
   ...
</target>

चींटी faq से थोड़ा अनुकूलित।


एक समाधान इस प्रकार हो सकता है। (मेरे पास एक परियोजना है जो ऐसा करती है।)

एक fileset साथ test करने के लिए एक अलग लक्ष्य है जो केवल एक कक्षा के लिए परीक्षण को प्रतिबंधित करता है। फिर चींटी कमांड लाइन पर उस क्लास का नाम -D पास करें:

ant -Dtest.module=MyClassUnderTest single_test

बिल्ड.xml (अत्यधिक कम) में:

<target name="single_test" depends="compile" description="Run one unit test">
    <junit>
        <batchtest>
            <fileset dir="${test.dir}" includes="**/${test.module}.class" />
        </batchtest>
    </junit>
</target>

चींटी वास्तव में बिल्ड फ़ाइल के लिए पैरामीटर_ नहीं है। मैं ऐसा करने के लिए कुछ तरीके सोच सकता हूं:

परीक्षणों को निर्दिष्ट करने के लिए एक विशेष लक्ष्य का उपयोग करें। आप कई परीक्षणों को निर्दिष्ट करने की अनुमति देने के लिए AntContrib से <for/> कार्य का उपयोग कर सकते हैं। आपको Ant-Contrib jar फ़ाइल डाउनलोड करनी होगी। मैं `$ {अण्डरग्राउंड / एंटीलिब / एंटीकंट्रिब" ​​डायरेक्टरी के तहत इसे अपने प्रोजेक्ट के अंदर रखने की सलाह देता हूँ। इस तरह, जब दूसरे आपके प्रोजेक्ट को चेक करते हैं, तो उन्हें आवश्यक एंट-कंट्रीब जार फ़ाइल मिलती है।

<property name="antlib.dir"     value="${basedir}/antlib"/>
<property name="antcontrib.dir" value="${antlib}/antcontrib"/>

<!-- Set up the ant contrib tasks for your use -->
<taskdef resource="net/sf/antcontrib/antlib.xml">
    <classpath>
        <fileset dir="${antcontrib.dir}"/>
    </classpath>
</taskdef>

<target name="select-test"
    description="Select the tests to run"
    depends="test-compile"
    if="junit-tests">
       <for parameter="module" 
          list="${junit-tests}"
          delimiter=" ">
          <sequential>
              <junit
                 fork="true"
                 ...>
                 <batchtest todir="$target/unit-tests">
                 <fileset dir="${test.destdir}">
                    <include name="**/@{module}.class"/>
                 </fileset>
             </junit>
         </sequential>
      </for>
</target>

अब आप इस तरह कई परीक्षण चलाते हैं:

$ ant -D"test-one test-two test-three" select-test

आप एक वैकल्पिक डिफ़ॉल्ट मान वाली संपत्ति को भी परिभाषित कर सकते हैं जिसे कमांड लाइन के माध्यम से प्रतिस्थापित किया जा सकता है, जैसे

<target name="test">
  <property name="moduleName" value="default-module" />
  <echo message="Testing Module: ${moduleName}"/>
  ....
</target>

और इसे चलाएं:

ant test -DmoduleName=ModuleX

मैंने उसी मूल प्रश्न के लिए यहां पोस्ट किए गए समाधानों की कोशिश की। हां, बस ant -D<arg_name> उपयोग करें। TH -D एक "कीवर्ड" है जो मुझे लगता है। मैं कोई विशेषज्ञ नहीं हूं और मैंने मैनुअल को विस्तार से नहीं पढ़ा है। फिर चींटी XML फ़ाइलों की तरह पहुँचा जा सकता है: ${arg_name}

उदाहरण के लिए, आपके पास एक तर्क नाम हो सकता है जैसे: arg.myarg , इसलिए XML ${arg.myarg}


-p या -projecthelp विकल्प वास्तव में यह करता है, तो आप यह कर सकते हैं:

ant -p build.xml

आप इस तरह के आह्वान करने का लक्ष्य बना सकते हैं:

<target name="help">
    <java classname="org.apache.tools.ant.Main">
        <arg value="-projecthelp" />
        <arg value="-buildfile" />
        <arg value="${ant.file}" />
    </java>
</target>

जिसे आप डिफ़ॉल्ट के रूप में सेट कर सकते हैं, इसलिए केवल टाइपिंग चींटी उपलब्ध लक्ष्यों को सूचीबद्ध करेगी।

(@Grodriguez 'का मिश्रण और @ sschuberth की टिप्पणी - मैंने सोचा कि यह अपने आप से एक जवाब के लायक था)