పారామితులతో మాక్ పద్ధతులను కాల్ చేస్తోంది

4.1 పద్ధతి పారామితులు

మునుపటి నియమాలు మాక్ ఆబ్జెక్ట్‌కు జోడించబడ్డాయి, పారామితులు లేకుండా పద్ధతులతో వ్యవహరించబడ్డాయి. మరియు పారామితులతో పద్ధతుల కోసం నియమాలను ఎలా సృష్టించాలి? అంతేకాకుండా, నేను నియమాలను సృష్టించాలనుకుంటున్నాను, తద్వారా కొన్ని పరామితి విలువలకు ఒక ఫలితం ఉంటుంది, మరియు ఇతరులకు - మరొకటి.

మీరు కూడా దీన్ని ఎలా చేయవచ్చు. నిర్దిష్ట పరామితితో నిర్దిష్టమైనదాన్ని తిరిగి ఇవ్వడానికి మీరు పద్ధతిని కోరుకుంటే, నియమాన్ని ఇలా వ్రాయవచ్చు:

Mockito.doReturn(result).when(an object).method name(parameter);

బాగా అర్థం చేసుకోవడానికి ఒక ఉదాహరణను పరిశీలిద్దాం. మా జాబితా 10వ మూలకాన్ని అభ్యర్థించేటప్పుడు ఇవాన్ పేరును మరియు 500వ అంశాన్ని అభ్యర్థించేటప్పుడు మరియా పేరును తిరిగి ఇవ్వనివ్వండి. ఇక చెప్పేదేం లేదు.

@ExtendWith(MockitoExtension.class)
class ParamsTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        //adding the first rule
        Mockito.doReturn("Ivan").when(mockList).get(10);
        //adding a second rule
        Mockito.doReturn("Maria").when(mockList).get(500);

        assertEquals("Ivan", mockList.get(10));
        assertEquals("Maria", mockList.get(500));

    }
}

4.2 పారామీటర్ టెంప్లేట్లు

మరియు వెంటనే మోసపూరిత సహోద్యోగులు నన్ను ప్రశ్న అడుగుతారు: “పద్ధతికి వాదనలు అవసరమైతే ఏమి చేయాలి, కానీ ఏదైనా విలువల కోసం అది అదే ఫలితాన్ని అందించాలి?”. మనం వ్రాయవద్దు:

Mockito.doReturn("Ivan").when(mockList).get(1);
Mockito.doReturn("Ivan").when(mockList).get(2);
Mockito.doReturn("Ivan").when(mockList).get(99);

లేదు, అలా రాయమని మిమ్మల్ని ఎవరూ బలవంతం చేయడం లేదు. మీరు ఏదైనా ఆర్గ్యుమెంట్‌లతో పద్ధతి కోసం పనిచేసే మాక్ ఆబ్జెక్ట్‌కు నియమాన్ని జోడించాలనుకుంటే, దీని కోసం ప్రత్యేక వస్తువు ఉంది:

Mockito.any()

దానితో మా ఉదాహరణ ఇలా వ్రాయబడుతుంది:

Mockito.doReturn("Ivan").when(mockList).get(any(int.class));

ఇక్కడ కొన్ని సూక్ష్మ నైపుణ్యాలు ఉన్నాయి. వస్తువు Mockito.any()రకాన్ని కలిగి ఉంది Object, కాబట్టి వివిధ రకాల పారామితుల కోసం అనలాగ్‌లు ఉన్నాయి:

మరింత సరిగ్గా, మా ఉదాహరణ ఇలా ఉంటుంది:

Mockito.doReturn("Ivan").when(mockList).get(anyInt());

4.3 doAnswer() పద్ధతి

మేము వర్చువల్ పద్ధతుల యొక్క సంక్లిష్ట ప్రవర్తనకు వచ్చాము. ఈ వర్చువల్ పద్ధతి సంక్లిష్టమైన ప్రవర్తనను కలిగి ఉండాలని మీరు కోరుకున్నప్పుడు ముందుగానే లేదా తరువాత పరిస్థితి ఉంటుంది. ఉదాహరణకు, ఇది పారామితులపై ఆధారపడి విలువలను తిరిగి ఇవ్వాలి, స్ట్రింగ్‌ను అప్పర్ కేస్‌గా మార్చండి.

దీని కోసం ఒక ప్రత్యేక పద్ధతి ఉంది - doAnswer(), ఇది మీకు అవసరమైనది చేసే ఫంక్షన్‌ను ఆమోదించింది:

Mockito.doAnswer(function).when(an object).method name(parameter);

get()క్లాస్ మెథడ్ Listదానికి పంపిన ఆర్గ్యుమెంట్ యొక్క వర్గాన్ని తిరిగి ఇచ్చేలా చేద్దాం . మరియు ఈ క్రింది ప్రోగ్రామ్‌ను వ్రాయండి:

@ExtendWith(MockitoExtension.class)
class DoAnswerTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        Mockito.doAnswer(invocation -> {
            int parameter = invocation.getArgument(0);
            return parameter * parameter;
        }).when(mockList).get(anyInt());

        assertEquals(100, mockList.get(10));
        assertEquals(25, mockList.get(5));
    }
}

మేము ఆన్సర్ క్లాస్ యొక్క ఆబ్జెక్ట్‌ని ఉపయోగించి ఫంక్షన్‌ని నిర్వచించాము.