@parameters विधि @beforeclass विधि

Question

से पहले निष्पादित किया गया है मैं जूनिट 4 की "parametrized" सुविधा का उपयोग कर रहा हूं और मैंने देखा कि @parameters विधि @beforeclass विधि से पहले निष्पादित किया गया है। यह मेरे लिए एक समस्या पैदा कर रहा है क्योंकि पैरामीटर मैं @parameters के माध्यम से परीक्षण मामलों में जा रहा हूँ @beforeclass विधि में प्रारंभ कोड पर निर्भर करता है। उदाहरण के लिए

@RunWith(Parameterized.class) 
public class TestOtherClass { 

    String argument; 
    private static boolean initializeThis; 

    public TestOtherClass(String parameter) throws Exception { 
     argument=parameter; 
    } 

    @BeforeClass 
    public static void doSetup() { 
     System.out.println("Doing setup before class..."); 
     initializeThis=true; // true or false, based on some condition 
    } 

    @Test 
    public void otherTest() { 
     System.out.println("Other test: " + argument); 
    } 

    @Parameters 
    public static Collection<Object[]> getData(){ 
     System.out.println("Inside parameter"); 
     String addThis; 
     if(initializeThis) 
      addThis="adding true"; 
     else 
      addThis="adding false"; 

     Object[] para1 = new Object[]{"First parameter :: " + addThis}; 
     Object[] para2 = new Object[]{"Second parameter :: " + addThis}; 

     Collection<Object[]> classNames = new ArrayList<Object[]>(); 
     classNames.add(para1); 
     classNames.add(para2); 
     return classNames; 
    } 
} 

अब, मैं चर "initializeThis" @beforeclass विधि में आरंभ कर रहा हूँ सच है, लेकिन (आश्चर्यजनक) जब मैं परीक्षण का मामला निष्पादित यह

Other test: First parameter :: adding false 
Other test: Second parameter :: adding false 

की उम्मीद नहीं कुछ है कि प्रिंट करता है।
मेरा प्रश्न है; @parameters से पहले @beforeclass विधि को निष्पादित करने का कोई तरीका है, क्या हम यह जूनिट 4 में कर सकते हैं?

Answer 1

जुनीट पैरामीटर सूची में प्रत्येक आइटम के लिए Runner बनाता है, Runner परीक्षण विधि को समाहित करता है। तो @Parameters हमेशा @BeforeClass से पहले निष्पादित हो जाएगा।

हालांकि, आप Assume के साथ @ पैरामीटरेटेड को जोड़ सकते हैं। आप हमेशा अपनी सूची में सभी पैरामीटर शामिल करते हैं, भले ही आप इसे निष्पादित करना चाहते हैं या नहीं। फिर परीक्षण विधि में, assumeTrue() जोड़ें जो initializeThis मान के विरुद्ध परीक्षण करता है।

@RunWith(Parameterized.class) 
public class TestOtherClassAssume { 
    private final String argument; 
    private final boolean initializeThisTest; 
    private static boolean initializeThis; 

    @Parameters 
    public static Collection<Object[]> getData(){ 
    System.out.println("Inside parameter"); 

    return Arrays.asList(new Object[][] { 
     { false, "First" }, 
     { true, "Second" }, 
    }); 
    } 

    public TestOtherClassAssume(boolean initializeThisTest, String argument) { 
    this.initializeThisTest = initializeThisTest; 
    this.argument = argument; 
    } 

    @BeforeClass 
    public static void doSetup() { 
    System.out.println("Doing setup before class..."); 
    initializeThis = true; // true or false, based on some condition 
    } 

    @Test 
    public void otherTest() { 
    Assume.assumeTrue(initializeThis == initializeThisTest); 
    System.out.println("Other test: " + argument); 
    } 
} 

इस से उत्पादन होता है:

Inside parameter 
Doing setup before class... 
Other test: Second 

Answer 2

मैं सिर्फ सादे पुराने जावा स्थिर {} .. @BeforeClass के बजाय प्रारंभकर्ता, जैसे प्रयोग करेंगे:

@RunWith(Parameterized.class) 
public class TestOtherClass { 

    String argument; 
    private static boolean initializeThis; 

    public TestOtherClass(String parameter) throws Exception { 
     argument=parameter; 
    } 

    static { 
     doSetup(); 
    } 

    // @BeforeClass 
    public static void doSetup() { 
     System.out.println("Doing setup before class..."); 
     initializeThis=true; // true or false, based on some condition 
    } 

    @Test 
    public void otherTest() { 
     System.out.println("Other test: " + argument); 
    } 

    @Parameters 
    public static Collection<Object[]> getData(){ 
     System.out.println("Inside parameter"); 
     String addThis; 
     if(initializeThis) 
      addThis="adding true"; 
     else 
      addThis="adding false"; 

     Object[] para1 = new Object[]{"First parameter :: " + addThis}; 
     Object[] para2 = new Object[]{"Second parameter :: " + addThis}; 

     Collection<Object[]> classNames = new ArrayList<Object[]>(); 
     classNames.add(para1); 
     classNames.add(para2); 
     return classNames; 
    } 
} 

केवल मैं दोष पता है कि इससे वंचित वर्ग स्थिर प्रारंभकर्ता को ओवरराइड करने में सक्षम नहीं होंगे, जबकि @BeforeClass इस पहलू में कुछ स्वतंत्रता देता है;

Answer 3

हालांकि, यह TestSuites के साथ काम नहीं करता है। को देखते हुए

@RunWith(Parameterized.class) 
public class TogglableParameterizedTest { 
    static boolean useAllParameters = false; 

    int parameter; 

    public TogglableParameterizedTest(int parameter) { 
     super(); 
     this.parameter = parameter; 
    } 
    @Parameters 
    public static Collection<Object[]> getTestParameters() { 
     List<Object[]> parameters = new ArrayList<Object[]>(); 
     if(useAllParameters) { 
      parameters.add(new Object[] { 1 }); 
      parameters.add(new Object[] { 2 }); 
      parameters.add(new Object[] { 3 }); 
     } 
     else { 
      parameters.add(new Object[] { 1 }); 
     } 
     return parameters; 
    } 
    @Test 
    public void test() { 
     System.out.println("parameter=" + parameter); 
    } 
} 

यह काम नहीं करता है:

@RunWith(Suite.class) 
@SuiteClasses({ TogglableParameterizedTest.class }) 
public class NonWorkingTestSuite1 { 

    @BeforeClass 
    public static void toggle() { 
     System.out.println("sets flag to late!"); 
    } 

} 

उत्पादन

sets flag to late! 
parameter=1 

न ही वह यह है कि:

@RunWith(Suite.class) 
@SuiteClasses({ TogglableParameterizedTest.class }) 
public class NonWorkingTestSuite2 { 
    static { 
     System.out.println("sets flag still to late"); 
     TogglableParameterizedTest.useAllParameters = true; 
    } 
} 

उत्पादन "पैरामीटर = 1" है। तो स्थैतिक प्रारंभकर्ता बिल्कुल निष्पादित नहीं किया गया। मुझे निम्नलिखित कार्यवाही मिली। "सूट" का विस्तार और वहाँ स्थिर प्रारंभकर्ता सम्मिलित करें:

public class TogglingSuite extends Suite { 

    static { 
     System.out.println("sets flag early enough!"); 
     TogglableParameterizedTest.useAllParameters = true; 
    } 

    public TogglingSuite(Class<?> klass, Class<?>[] suiteClasses) 
     throws InitializationError { 
     super(klass, suiteClasses); 
    } 

    public TogglingSuite(Class<?> klass, List<Runner> runners) 
     throws InitializationError { 
     super(klass, runners); 
    } 

    public TogglingSuite(Class<?> klass, RunnerBuilder builder) 
      throws InitializationError { 
     super(klass, builder); 
    } 

    public TogglingSuite(RunnerBuilder builder, Class<?> klass, 
      Class<?>[] suiteClasses) throws InitializationError { 
     super(builder, klass, suiteClasses); 
    } 

    public TogglingSuite(RunnerBuilder builder, Class<?>[] classes) 
      throws InitializationError { 
     super(builder, classes); 
    } 
} 

और अपने परीक्षण सूट में इसका इस्तेमाल करते हैं:

@RunWith(TogglingSuite.class) 
@SuiteClasses({ TogglableParameterizedTest.class }) 
public class WorkingTestSuite { 

} 

उत्पादन

sets flag early enough! 
parameter=1 
parameter=2 
parameter=3 

अब यह काम करता है।

Answer 4

यह पुराना सवाल है लेकिन मुझे हाल ही में एक ही समस्या थी। यह मुझे मारता है कि किसी भी समाधान को सबसे स्पष्ट कामकाज के लिए जाना प्रतीत नहीं होता है - @Parameters विधि में @BeforeClass विधि को कॉल करना। उत्तरार्द्ध स्थैतिक है और केवल एक बार निष्पादित किया जाता है - किसी भी परीक्षण को चलाने से पहले। इसलिए, यह सभी उद्देश्यों और उद्देश्यों के लिए @BeforeClass विधि है, भले ही इसे इस तरह एनोटेट नहीं किया गया हो। अधिक जानकारी यहां पाया जा सकता है: http://feraldeveloper.blogspot.co.uk/2013/12/beforeclass-and-parametrized-junit-tests.html