How to use fail method of org.testng.Assert class

Best Testng code snippet using org.testng.Assert.fail

Source:Verify.java

...51     * Fails a test with the given message.52     *53     * @param message the assertion error message54     */55    public static void fail(String message) {56        LOGGER.error("<fail> - " + message);57        Snapshot.attachDriverSnapShot("Fail: - " + message);58        org.testng.Assert.fail(message);59    }60    /**61     * Fails a test with the given message.62     *63     * @param message the assertion error message64     */65    public static void fail(String message, Throwable ex) {66        LOGGER.error("<fail> - " + message, ex);67        Snapshot.attachDriverSnapShot("Fail: - " + message);68        org.testng.Assert.fail(message);69    }70    /**71     * Asserts that two objects are equal. If they are not, an AssertionError, with the given message,72     * is thrown.73     *74     * @param actual the actual value75     * @param expected the expected value76     * @param message the assertion error message77     */78    public static void assertEquals(Object actual, Object expected, String message) {79        try{80            org.testng.Assert.assertEquals(actual, expected, message);81            equalsPass(message);82        } catch (AssertionError error){...

Source:Assert.java

...45			pass(actual, expected, null);46		}47		catch(AssertionError e)48		{49			LogStatus.fail(e);50			e.printStackTrace();51			throw new AssertionError(e);52		}53	}54	55	public static void assertEquals(boolean actual, boolean expected, String message) throws Exception56	{57		try58		{59			org.testng.Assert.assertEquals(actual, expected,message);60			pass(actual, expected, message);61		}62		catch(AssertionError e)63		{64			LogStatus.fail(e);65			e.printStackTrace();66			throw new AssertionError(e);67		}68	}69	70	public static void assertEquals(byte[] actual, byte[] expected) throws Exception71	{72		try73		{74			org.testng.Assert.assertEquals(actual, expected);75			pass(actual,expected,null);76		}77		catch(AssertionError e)78		{79			LogStatus.fail(e);80			e.printStackTrace();81			throw new AssertionError(e);82		}83	}84	85	public static void assertEquals(byte[] actual, byte[] expected, String message) throws Exception86	{87		try88		{89			org.testng.Assert.assertEquals(actual, expected,message);90			pass(actual,expected,message);91		}92		catch(AssertionError e)93		{94			LogStatus.fail(e);95			e.printStackTrace();96			throw new AssertionError(e);97		}98	}99	100	public static void assertEquals(byte actual, byte expected) throws Exception101	{102		try103		{104			org.testng.Assert.assertEquals(actual, expected);105			pass(actual, expected, null);106		}107		catch(AssertionError e)108		{109			LogStatus.fail(e);110			e.printStackTrace();111			throw new AssertionError(e);112		}113	}114	115	public static void assertEquals(byte actual, byte expected, String message) throws Exception116	{117		try118		{119			org.testng.Assert.assertEquals(actual, expected,message);120			pass(actual, expected, message);121		}122		catch(AssertionError e)123		{124			LogStatus.fail(e);125			e.printStackTrace();126			throw new AssertionError(e);127		}128	}129	130	public static void assertEquals(char actual, char expected) throws Exception131	{132		try133		{134			org.testng.Assert.assertEquals(actual, expected);135			pass(actual, expected, null);136		}137		catch(AssertionError e)138		{139			LogStatus.fail(e);140			e.printStackTrace();141			throw new AssertionError(e);142		}143	}144	145	public static void assertEquals(char actual, char expected, String message) throws Exception146	{147		try148		{149			org.testng.Assert.assertEquals(actual, expected,message);150			pass(actual, expected, message);151		}152		catch(AssertionError e)153		{154			LogStatus.fail(e);155			e.printStackTrace();156			throw new AssertionError(e);157		}158	}159	160	public static void assertEquals(Collection<?> actual, Collection<?> expected) throws Exception161	{162		try163		{164			org.testng.Assert.assertEquals(actual, expected);165			pass(actual, expected, null);166		}167		catch(AssertionError e)168		{169			LogStatus.fail(e);170			e.printStackTrace();171			throw new AssertionError(e);172		}173	}174	175	public static void assertEquals(Collection<?> actual, Collection<?> expected, String message) throws Exception176	{177		try178		{179			org.testng.Assert.assertEquals(actual, expected,message);180			pass(actual, expected, message);181		}182		catch(AssertionError e)183		{184			LogStatus.fail(e);185			e.printStackTrace();186			throw new AssertionError(e);187		}188	}189	public static void assertEquals(Double[] actual, Double[] expected) throws Exception190	{191		try192		{193			org.testng.Assert.assertEquals(actual, expected);;194			pass(actual,expected,null);195		}196		catch(AssertionError e)197		{198			LogStatus.fail(e);199			e.printStackTrace();200			throw new AssertionError(e);201		}202	}203	204	public static void assertEquals(Double[] actual, Double[] expected, String message) throws Exception205	{206		try207		{208			org.testng.Assert.assertEquals(actual, expected, message);209			pass(actual,expected,message);210		}211		catch(AssertionError e)212		{213			LogStatus.fail(e);214			e.printStackTrace();215			throw new AssertionError(e);216		}217	}218	219	public static void assertEquals(Object actual, Object expected) throws Exception220	{221		try222		{223			org.testng.Assert.assertEquals(actual, expected);224			pass(actual, expected, null);225		}226		catch(AssertionError e)227		{228			LogStatus.fail(e);229			e.printStackTrace();230			throw new AssertionError(e);231		}232	}233	234	public static void assertEquals(Object actual, Object expected, String message) throws Exception235	{236		try237		{238			org.testng.Assert.assertEquals(actual, expected,message);239			pass(actual, expected, message);240		}241		catch(AssertionError e)242		{243			LogStatus.fail(e);244			e.printStackTrace();245			throw new AssertionError(e);246		}247	}248	249	250	public static void assertEquals(int actual, int expected) throws Exception251	{252		try253		{254			org.testng.Assert.assertEquals(actual, expected);255			pass(actual, expected, null);256		}257		catch(AssertionError e)258		{259			LogStatus.fail(e);260			e.printStackTrace();261			throw new AssertionError(e);262		}263	}264	265	public static void assertEquals(int actual, int expected, String message) throws Exception266	{267		try268		{269			org.testng.Assert.assertEquals(actual, expected,message);270			pass(actual, expected, message);271		}272		catch(AssertionError e)273		{274			LogStatus.fail(e);275			e.printStackTrace();276			throw new AssertionError(e);277		}278	}279	280	public static void assertEquals(Iterable<?> actual, Iterable<?> expected) throws Exception281	{282		try283		{284			org.testng.Assert.assertEquals(actual, expected);285			pass(actual, expected, null);286		}287		catch(AssertionError e)288		{289			LogStatus.fail(e);290			e.printStackTrace();291			throw new AssertionError(e);292		}293	}294	295	public static void assertEquals(Iterable<?> actual, Iterable<?> expected, String message) throws Exception296	{297		try298		{299			org.testng.Assert.assertEquals(actual, expected,message);300			pass(actual, expected, message);301		}302		catch(AssertionError e)303		{304			LogStatus.fail(e);305			e.printStackTrace();306			throw new AssertionError(e);307		}308	}309	310	public static void assertEquals(Iterator<?> actual, Iterator<?> expected) throws Exception311	{312		try313		{314			org.testng.Assert.assertEquals(actual, expected);315			pass(actual, expected, null);316		}317		catch(AssertionError e)318		{319			LogStatus.fail(e);320			e.printStackTrace();321			throw new AssertionError(e);322		}323	}324	325	public static void assertEquals(Iterator<?> actual, Iterator<?> expected, String message) throws Exception326	{327		try328		{329			org.testng.Assert.assertEquals(actual, expected,message);330			pass(actual, expected, message);331		}332		catch(AssertionError e)333		{334			LogStatus.fail(e);335			e.printStackTrace();336			throw new AssertionError(e);337		}338	}339	340	public static void assertEquals(long actual, long expected) throws Exception341	{342		try343		{344			org.testng.Assert.assertEquals(actual, expected);345			pass(actual, expected, null);346		}347		catch(AssertionError e)348		{349			LogStatus.fail(e);350			e.printStackTrace();351			throw new AssertionError(e);352		}353	}354	355	public static void assertEquals(long actual, long expected, String message) throws Exception356	{357		try358		{359			org.testng.Assert.assertEquals(actual, expected, message);360			pass(actual, expected, message);361		}362		catch(AssertionError e)363		{364			LogStatus.fail(e);365			e.printStackTrace();366			throw new AssertionError(e);367		}368	}369	370	public static void assertEquals(Map<?, ?> actual, Map<?, ?> expected) throws Exception371	{372		try373		{374			org.testng.Assert.assertEquals(actual, expected);375			pass(actual, expected, null);376		}377		catch(AssertionError e)378		{379			LogStatus.fail(e);380			e.printStackTrace();381			throw new AssertionError(e);382		}383	}384	385	public static void assertEquals(Map<?, ?> actual, Map<?, ?> expected, String message) throws Exception386	{387		try388		{389			org.testng.Assert.assertEquals(actual, expected, message);390			pass(actual, expected, message);391		}392		catch(AssertionError e)393		{394			LogStatus.fail(e);395			e.printStackTrace();396			throw new AssertionError(e);397		}398	}399	400	public static void assertEquals(Object[] actual, Object[] expected) throws Exception401	{402		try403		{404			org.testng.Assert.assertEquals(actual, expected);405			pass(actual,expected,null);406		}407		catch(AssertionError e)408		{409			LogStatus.fail(e);410			e.printStackTrace();411			throw new AssertionError(e);412		}413	}414	415	public static void assertEquals(Object[] actual, Object[] expected, String message) throws Exception416	{417		try418		{419			org.testng.Assert.assertEquals(actual, expected, message);420			pass(actual,expected,message);421		}422		catch(AssertionError e)423		{424			LogStatus.fail(e);425			e.printStackTrace();426			throw new AssertionError(e);427		}428	}429	public static void assertEquals(Short actual, Short expected) throws Exception430	{431		try432		{433			org.testng.Assert.assertEquals(actual, expected);434			pass(actual, expected, null);435		}436		catch(AssertionError e)437		{438			LogStatus.fail(e);439			e.printStackTrace();440			throw new AssertionError(e);441		}442	}443	444	public static void assertEquals(Short actual, Short expected, String message) throws Exception445	{446		try447		{448			org.testng.Assert.assertEquals(actual, expected, message);449			pass(actual, expected, message);450		}451		catch(AssertionError e)452		{453			LogStatus.fail(e);454			e.printStackTrace();455			throw new AssertionError(e);456		}457	}458	459	public static void assertEquals(String actual, String expected) throws Exception460	{461		try462		{463			org.testng.Assert.assertEquals(actual, expected);464			pass(actual, expected, null);465		}466		catch(AssertionError e)467		{468			LogStatus.fail(e);469			e.printStackTrace();470			throw new AssertionError(e);471		}472	}473	474	public static void assertEquals(String actual, String expected, String message) throws Exception475	{476		try477		{478			org.testng.Assert.assertEquals(actual, expected,message);479			pass(actual, expected, message);480		}481		catch(AssertionError e)482		{483			LogStatus.fail(e);484			e.printStackTrace();485			throw new AssertionError(e);486		}487	}488	489	public static void assertEqualsDeep(Map<?,?> actual, Map<?, ?> expected) throws Exception490	{491		try492		{493			org.testng.Assert.assertEqualsDeep(actual, expected);494			pass(actual, expected, null);495		}496		catch(AssertionError e)497		{498			LogStatus.fail(e);499			e.printStackTrace();500			throw new AssertionError(e);501		}502	}503	504	public static void assertEqualsDeep(Map<?,?> actual, Map<?, ?> expected, String message) throws Exception505	{506		try507		{508			org.testng.Assert.assertEqualsDeep(actual, expected,message);509			pass(actual, expected, message);510		}511		catch(AssertionError e)512		{513			LogStatus.fail(e);514			e.printStackTrace();515			throw new AssertionError(e);516		}517	}518	519	520	public static void assertEqualsDeep(Set<?> actual, Set<?> expected, String message) throws Exception521	{522		try523		{524			org.testng.Assert.assertEqualsDeep(actual, expected, message);525			pass(actual, expected, message);526		}527		catch(AssertionError e)528		{529			LogStatus.fail(e);530			e.printStackTrace();531			throw new AssertionError(e);532		}533	}534	535	public static void assertEqualsNoOrder(Object[] actual, Object[] expected) throws Exception536	{537		try538		{539			org.testng.Assert.assertEqualsNoOrder(actual, expected);540			pass(actual,expected,null);541		}542		catch(AssertionError e)543		{544			LogStatus.fail(e);545			e.printStackTrace();546			throw new AssertionError(e);547		}548	}549	550	551	public static void assertEqualsNoOrder(Object[] actual, Object[] expected, String message) throws Exception552	{553		try554		{555			org.testng.Assert.assertEqualsNoOrder(actual, expected, message);556			pass(actual,expected,message);557		}558		catch(AssertionError e)559		{560			LogStatus.fail(e);561			e.printStackTrace();562			throw new AssertionError(e);563		}564	}565	566	public static void 	assertFalse(boolean condition) throws Exception567	{568		try569		{570			org.testng.Assert.assertFalse(condition);571			boolean expected=false;572			LogStatus.pass("Expected result: "+expected+" actual result: "+condition);573		}574		catch(AssertionError e)575		{576			LogStatus.fail(e);577			e.printStackTrace();578			throw new AssertionError(e);579		}580	}581	582	public static void 	assertFalse(boolean condition, String message) throws Exception583	{584		try585		{586			org.testng.Assert.assertFalse(condition);587			boolean expected=false;588			LogStatus.pass(message+": Expected result: "+expected+" actual result: "+condition);589		}590		catch(AssertionError e)591		{592			LogStatus.fail(e);593			e.printStackTrace();594			throw new AssertionError(e);595		}596	}597	598	public static void 	assertNotEquals(Object actual, Object expected) throws Exception599	{600		try601		{602			org.testng.Assert.assertNotEquals(actual, actual);603			LogStatus.pass("Expected result: "+expected+"is not eqauals to actual result: "+actual);604		}605		catch(AssertionError e)606		{607			LogStatus.fail(e);608			e.printStackTrace();609			throw new AssertionError(e);610		}611	}612	613	public static void 	assertNotEquals(Object actual, Object expected, String message) throws Exception614	{615		try616		{617			org.testng.Assert.assertNotEquals(actual, actual,message);618			LogStatus.pass(message+" :Expected result: "+expected+"is not eqauals to actual result: "+actual);619		}620		catch(AssertionError e)621		{622			LogStatus.fail(e);623			e.printStackTrace();624			throw new AssertionError(e);625		}626	}627	628	public static void 	assertNotEquals(Map<?, ?> actual, Map<?, ?> expected) throws Exception629	{630		try631		{632			org.testng.Assert.assertNotEquals(actual, expected);633			LogStatus.pass("Expected result: "+expected+"is not eqauals to actual result: "+actual);634		}635		catch(AssertionError e)636		{637			LogStatus.fail(e);638			e.printStackTrace();639			throw new AssertionError(e);640		}641	}642	643	public static void 	assertNotEquals(Map<?, ?> actual, Map<?, ?> expected, String message) throws Exception644	{645		try646		{647			org.testng.Assert.assertNotEquals(actual, expected,message);648			LogStatus.pass(message+" :Expected result: "+expected+"is not eqauals to actual result: "+actual);649		}650		catch(AssertionError e)651		{652			LogStatus.fail(e);653			e.printStackTrace();654			throw new AssertionError(e);655		}656	}657	public static void 	assertNotEquals(Set actual, Set expected) throws Exception658	{659		try660		{661			org.testng.Assert.assertNotEquals(actual, expected);662			LogStatus.pass("Expected result: "+expected+"is not eqauals to actual result: "+actual);663		}664		catch(AssertionError e)665		{666			LogStatus.fail(e);667			e.printStackTrace();668			throw new AssertionError(e);669		}670	}671	672	public static void 	assertNotEquals(Set actual, Set expected, String message) throws Exception673	{674		try675		{676			org.testng.Assert.assertNotEquals(actual, expected,message);677			LogStatus.pass(message+" :Expected result: "+expected+"is not eqauals to actual result: "+actual);678		}679		catch(AssertionError e)680		{681			LogStatus.fail(e);682			e.printStackTrace();683			throw new AssertionError(e);684		}685	}686	687	public static void 	assertNotEqualsDeep(Set actual, Set expected) throws Exception688	{689		try690		{691			org.testng.Assert.assertNotEqualsDeep(actual, expected);692			LogStatus.pass("Expected result: "+expected+"is not eqauals to actual result: "+actual);693		}694		catch(AssertionError e)695		{696			LogStatus.fail(e);697			e.printStackTrace();698			throw new AssertionError(e);699		}700	}701	702	public static void 	assertNotEqualsDeep(Set actual, Set expected, String message) throws Exception703	{704		try705		{706			org.testng.Assert.assertNotEqualsDeep(actual, expected,message);707			LogStatus.pass(message+" :Expected result: "+expected+"is not eqauals to actual result: "+actual);708		}709		catch(AssertionError e)710		{711			LogStatus.fail(e);712			e.printStackTrace();713			throw new AssertionError(e);714		}715	}716	717	public static void 	assertNotEqualsDeep(Map<?, ?> actual, Map<?, ?> expected) throws Exception718	{719		try720		{721			org.testng.Assert.assertNotEqualsDeep(actual, expected);722			LogStatus.pass("Expected result: "+expected+"is not eqauals to actual result: "+actual);723		}724		catch(AssertionError e)725		{726			LogStatus.fail(e);727			e.printStackTrace();728			throw new AssertionError(e);729		}730	}731	732	public static void 	assertNotEqualsDeep(Map<?, ?> actual, Map<?, ?> expected, String message) throws Exception733	{734		try735		{736			org.testng.Assert.assertNotEqualsDeep(actual, expected, message);737			LogStatus.pass(message+" :Expected result: "+expected+"is not eqauals to actual result: "+actual);738		}739		catch(AssertionError e)740		{741			LogStatus.fail(e);742			e.printStackTrace();743			throw new AssertionError(e);744		}745	}746	747	public static void 	assertNotEqualsDeep(Object[] actual, Object[] expected) throws Exception748	{749		try750		{751			if(Arrays.deepEquals(actual, expected))752				LogStatus.pass("Expected result: "+Arrays.toString(expected)+"is not eqauals to actual result: "+Arrays.toString(actual));753			else754				throw new AssertionError ("Expected result: "+Arrays.toString(expected)+"is not eqauals to actual result: "+Arrays.toString(actual));755		}756		catch(AssertionError e)757		{758			LogStatus.fail(e);759			e.printStackTrace();760			throw new AssertionError(e);761		}762	}763	764	public static void 	assertNotEqualsDeep(Object[] actual, Object[] expected, String message) throws Exception765	{766		try767		{768			if(Arrays.deepEquals(actual, expected))769				LogStatus.pass(message+" :Expected result: "+Arrays.toString(expected)+"is not eqauals to actual result: "+Arrays.toString(actual));770			else771				throw new AssertionError (message+" :Expected result: "+Arrays.toString(expected)+"is not eqauals to actual result: "+Arrays.toString(actual));772		}773		catch(AssertionError e)774		{775			LogStatus.fail(e);776			e.printStackTrace();777			throw new AssertionError(e);778		}779	}780	781	public static void 	assertNotNull(Object object) throws Exception782	{783		try784		{785			org.testng.Assert.assertNotNull(object);786			LogStatus.pass(object+" is not null");787		}788		catch(AssertionError e)789		{790			LogStatus.fail(e);791			e.printStackTrace();792			throw new AssertionError(e);793		}794	}795	796	public static void 	assertNotNull(Object object, String message) throws Exception797	{798		try799		{800			org.testng.Assert.assertNotNull(object,message);801			LogStatus.pass(message+" : "+object+" is not null");802		}803		catch(AssertionError e)804		{805			LogStatus.fail(e);806			e.printStackTrace();807			throw new AssertionError(e);808		}809	}810	public static void 	assertNotSame(Object actual, Object expected) throws Exception811	{812		try813		{814			org.testng.Assert.assertNotSame(actual, expected);;815			LogStatus.pass(actual+" is not same as "+expected);816		}817		catch(AssertionError e)818		{819			LogStatus.fail(e);820			e.printStackTrace();821			throw new AssertionError(e);822		}823	}824	825	public static void 	assertNotSame(Object actual, Object expected, String message) throws Exception826	{827		try828		{829			org.testng.Assert.assertNotSame(actual, expected,message);;830			LogStatus.pass(message+" : "+actual+" is not same as "+expected);831		}832		catch(AssertionError e)833		{834			LogStatus.fail(e);835			e.printStackTrace();836			throw new AssertionError(e);837		}838	}839	840	public static void 	assertNull(Object object) throws Exception841	{842		try843		{844			org.testng.Assert.assertNull(object);845			LogStatus.pass(object+" is null as expected");846		}847		catch(AssertionError e)848		{849			LogStatus.fail(e);850			e.printStackTrace();851			throw new AssertionError(e);852		}853	}854	855	public static void 	assertNull(Object object, String message) throws Exception856	{857		try858		{859			org.testng.Assert.assertNull(object,message);860			LogStatus.pass(message+" : "+object+" is null as expected");861		}862		catch(AssertionError e)863		{864			LogStatus.fail(e);865			e.printStackTrace();866			throw new AssertionError(e);867		}868	}869	870	public static void 	assertSame(Object actual, Object expected) throws Exception871	{872		try873		{874			org.testng.Assert.assertSame(actual, expected);;875			LogStatus.pass(actual+" is same as "+expected);876		}877		catch(AssertionError e)878		{879			LogStatus.fail(e);880			e.printStackTrace();881			throw new AssertionError(e);882		}883	}884	885	public static void 	assertSame(Object actual, Object expected, String message) throws Exception886	{887		try888		{889			org.testng.Assert.assertSame(actual, expected, message);890			LogStatus.pass(message+" : "+actual+" is same as "+expected);891		}892		catch(AssertionError e)893		{894			LogStatus.fail(e);895			e.printStackTrace();896			throw new AssertionError(e);897		}898	}899	public static void 	assertTrue(boolean condition) throws Exception900	{901		try902		{903			org.testng.Assert.assertTrue(condition);904			LogStatus.pass(condition +" is same as expected");905		}906		catch(AssertionError e)907		{908			LogStatus.fail(e);909			e.printStackTrace();910			throw new AssertionError(e);911		}912	}913	914	public static void 	assertTrue(boolean condition, String message) throws Exception915	{916		try917		{918			org.testng.Assert.assertTrue(condition, message);919			LogStatus.pass(message+" : "+condition +" is same as expected");920		}921		catch(AssertionError e)922		{923			LogStatus.fail(e);924			e.printStackTrace();925			throw new AssertionError(e);926		}927	}928	929	public static void 	fail() throws Exception930	{931		try932		{933			org.testng.Assert.fail();934			935		}936		catch(AssertionError e)937		{938			LogStatus.fail(e);939			e.printStackTrace();940			throw new AssertionError(e);941		}942	}943	944	public static void 	fail(String message) throws Exception945	{946		try947		{948			org.testng.Assert.fail(message);949			950		}951		catch(AssertionError e)952		{953			LogStatus.fail(e);954			e.printStackTrace();955			throw new AssertionError(e);956		}957	}958	959	960	961	962}
...

Source:Assertion.java

...32  @Override33  public void onAssertSuccess(IAssert<?> assertCommand) {34  }35  /**36   * Invoked when an assert fails. Meant to be overridden by subclasses.37   * 38   * @deprecated use onAssertFailure(IAssert assertCommand, AssertionError ex) instead of.39   */40  @Deprecated41  @Override42  public void onAssertFailure(IAssert<?> assertCommand) {43  }44  45  @Override46  public void onAssertFailure(IAssert<?> assertCommand, AssertionError ex) {47      onAssertFailure(assertCommand);48  }49  /**50   * Invoked before an assert is run. Meant to be overridden by subclasses.51   */52  @Override53  public void onBeforeAssert(IAssert<?> assertCommand) {54  }55  /**56   * Invoked after an assert is run. Meant to be overridden by subclasses.57   */58  @Override59  public void onAfterAssert(IAssert<?> assertCommand) {60  }61  abstract private static class SimpleAssert<T> implements IAssert<T> {62    private final T actual;63    private final T expected;64    private final String m_message;65    public SimpleAssert(String message) {66      this(null, null, message);67    }68    public SimpleAssert(T actual, T expected) {69      this(actual, expected, null);70    }71    public SimpleAssert(T actual, T expected, String message) {72      this.actual = actual;73      this.expected = expected;74      m_message = message;75    }76    @Override77    public String getMessage() {78      return m_message;79    }80    @Override81    public T getActual() {82        return actual;83    }84    @Override85    public T getExpected() {86        return expected;87    }88    @Override89    abstract public void doAssert();90  }91  public void assertTrue(final boolean condition, final String message) {92    doAssert(new SimpleAssert<Boolean>(condition, Boolean.TRUE, message) {93      @Override94      public void doAssert() {95        org.testng.Assert.assertTrue(condition, message);96      }97    });98  }99  100	public void assertTrue(final boolean condition) {101		doAssert(new SimpleAssert<Boolean>(condition, Boolean.TRUE) {102			@Override103			public void doAssert() {104				org.testng.Assert.assertTrue(condition);105			}106		});107	}108  public void assertFalse(final boolean condition, final String message) {109    doAssert(new SimpleAssert<Boolean>(condition, Boolean.FALSE, message) {110      @Override111      public void doAssert() {112        org.testng.Assert.assertFalse(condition, message);113      }114    });115  }116  public void assertFalse(final boolean condition) {117    doAssert(new SimpleAssert<Boolean>(condition, Boolean.FALSE) {118      @Override119      public void doAssert() {120        org.testng.Assert.assertFalse(condition);121      }122    });123  }124  public void fail(final String message, final Throwable realCause) {125    doAssert(new SimpleAssert<Object>(message) {126      @Override127      public void doAssert() {128        org.testng.Assert.fail(message, realCause);129      }130    });131  }132  public void fail(final String message) {133    doAssert(new SimpleAssert<Object>(message) {134      @Override135      public void doAssert() {136        org.testng.Assert.fail(message);137      }138    });139  }140  public void fail() {141    doAssert(new SimpleAssert<Object>(null) {142      @Override143      public void doAssert() {144        org.testng.Assert.fail();145      }146    });147  }148  public <T> void assertEquals(final T actual, final T expected, final String message) {149    doAssert(new SimpleAssert<T>(actual, expected, message) {150      @Override151      public void doAssert() {152        org.testng.Assert.assertEquals(actual, expected, message);153      }154    });155  }156  public <T> void assertEquals(final T actual, final T expected) {157    doAssert(new SimpleAssert<T>(actual, expected) {158      @Override...

Source:FailingBeforeAndAfterMethodsTestNGTests.java

...33import static org.junit.Assert.*;34/**35 * Integration tests which verify that '<i>before</i>' and '<i>after</i>'36 * methods of {@link TestExecutionListener TestExecutionListeners} as well as37 * {@code @BeforeTransaction} and {@code @AfterTransaction} methods can fail38 * tests in a TestNG environment.39 *40 * <p>See: <a href="https://jira.spring.io/browse/SPR-3960" target="_blank">SPR-3960</a>.41 *42 * <p>Indirectly, this class also verifies that all {@code TestExecutionListener}43 * lifecycle callbacks are called.44 *45 * @author Sam Brannen46 * @since 2.547 */48@RunWith(Parameterized.class)49public class FailingBeforeAndAfterMethodsTestNGTests {50	protected final Class<?> clazz;51	protected final int expectedTestStartCount;52	protected final int expectedTestSuccessCount;53	protected final int expectedFailureCount;54	protected final int expectedFailedConfigurationsCount;55	@Parameters(name = "{0}")56	public static Object[][] testData() {57		// @formatter:off58		return new Object[][] {59			{ AlwaysFailingBeforeTestClassTestCase.class.getSimpleName(), 1, 0, 0, 1 },60			{ AlwaysFailingAfterTestClassTestCase.class.getSimpleName(), 1, 1, 0, 1 },61			{ AlwaysFailingPrepareTestInstanceTestCase.class.getSimpleName(), 1, 0, 0, 1 },62			{ AlwaysFailingBeforeTestMethodTestCase.class.getSimpleName(), 1, 0, 0, 1 },63			{ AlwaysFailingBeforeTestExecutionTestCase.class.getSimpleName(), 1, 0, 1, 0 },64			{ AlwaysFailingAfterTestExecutionTestCase.class.getSimpleName(), 1, 0, 1, 0 },65			{ AlwaysFailingAfterTestMethodTestCase.class.getSimpleName(), 1, 1, 0, 1 },66			{ FailingBeforeTransactionTestCase.class.getSimpleName(), 1, 0, 0, 1 },67			{ FailingAfterTransactionTestCase.class.getSimpleName(), 1, 1, 0, 1 }68		};69		// @formatter:on70	}71	public FailingBeforeAndAfterMethodsTestNGTests(String testClassName, int expectedTestStartCount,72			int expectedTestSuccessCount, int expectedFailureCount, int expectedFailedConfigurationsCount) throws Exception {73		this.clazz = ClassUtils.forName(getClass().getName() + "." + testClassName, getClass().getClassLoader());74		this.expectedTestStartCount = expectedTestStartCount;75		this.expectedTestSuccessCount = expectedTestSuccessCount;76		this.expectedFailureCount = expectedFailureCount;77		this.expectedFailedConfigurationsCount = expectedFailedConfigurationsCount;78	}79	@Test80	public void runTestAndAssertCounters() throws Exception {81		final TrackingTestNGTestListener listener = new TrackingTestNGTestListener();82		final TestNG testNG = new TestNG();83		testNG.addListener((ITestNGListener) listener);84		testNG.setTestClasses(new Class<?>[] { this.clazz });85		testNG.setVerbose(0);86		testNG.run();87		String name = this.clazz.getSimpleName();88		assertEquals("tests started for [" + name + "] ==> ", this.expectedTestStartCount, listener.testStartCount);89		assertEquals("successful tests for [" + name + "] ==> ", this.expectedTestSuccessCount,90			listener.testSuccessCount);91		assertEquals("failed tests for [" + name + "] ==> ", this.expectedFailureCount, listener.testFailureCount);92		assertEquals("failed configurations for [" + name + "] ==> ", this.expectedFailedConfigurationsCount,93			listener.failedConfigurationsCount);94	}95	// -------------------------------------------------------------------96	static class AlwaysFailingBeforeTestClassTestExecutionListener implements TestExecutionListener {97		@Override98		public void beforeTestClass(TestContext testContext) {99			org.testng.Assert.fail("always failing beforeTestClass()");100		}101	}102	static class AlwaysFailingAfterTestClassTestExecutionListener implements TestExecutionListener {103		@Override104		public void afterTestClass(TestContext testContext) {105			org.testng.Assert.fail("always failing afterTestClass()");106		}107	}108	static class AlwaysFailingPrepareTestInstanceTestExecutionListener implements TestExecutionListener {109		@Override110		public void prepareTestInstance(TestContext testContext) throws Exception {111			org.testng.Assert.fail("always failing prepareTestInstance()");112		}113	}114	static class AlwaysFailingBeforeTestMethodTestExecutionListener implements TestExecutionListener {115		@Override116		public void beforeTestMethod(TestContext testContext) {117			org.testng.Assert.fail("always failing beforeTestMethod()");118		}119	}120	static class AlwaysFailingBeforeTestExecutionTestExecutionListener implements TestExecutionListener {121		@Override122		public void beforeTestExecution(TestContext testContext) {123			org.testng.Assert.fail("always failing beforeTestExecution()");124		}125	}126	static class AlwaysFailingAfterTestExecutionTestExecutionListener implements TestExecutionListener {127		@Override128		public void afterTestExecution(TestContext testContext) {129			org.testng.Assert.fail("always failing afterTestExecution()");130		}131	}132	static class AlwaysFailingAfterTestMethodTestExecutionListener implements TestExecutionListener {133		@Override134		public void afterTestMethod(TestContext testContext) {135			org.testng.Assert.fail("always failing afterTestMethod()");136		}137	}138	// -------------------------------------------------------------------139	@TestExecutionListeners(inheritListeners = false)140	public static abstract class BaseTestCase extends AbstractTestNGSpringContextTests {141		@org.testng.annotations.Test142		public void testNothing() {143		}144	}145	@TestExecutionListeners(AlwaysFailingBeforeTestClassTestExecutionListener.class)146	public static class AlwaysFailingBeforeTestClassTestCase extends BaseTestCase {147	}148	@TestExecutionListeners(AlwaysFailingAfterTestClassTestExecutionListener.class)149	public static class AlwaysFailingAfterTestClassTestCase extends BaseTestCase {150	}151	@TestExecutionListeners(AlwaysFailingPrepareTestInstanceTestExecutionListener.class)152	public static class AlwaysFailingPrepareTestInstanceTestCase extends BaseTestCase {153	}154	@TestExecutionListeners(AlwaysFailingBeforeTestMethodTestExecutionListener.class)155	public static class AlwaysFailingBeforeTestMethodTestCase extends BaseTestCase {156	}157	@TestExecutionListeners(AlwaysFailingBeforeTestExecutionTestExecutionListener.class)158	public static class AlwaysFailingBeforeTestExecutionTestCase extends BaseTestCase {159	}160	@TestExecutionListeners(AlwaysFailingAfterTestExecutionTestExecutionListener.class)161	public static class AlwaysFailingAfterTestExecutionTestCase extends BaseTestCase {162	}163	@TestExecutionListeners(AlwaysFailingAfterTestMethodTestExecutionListener.class)164	public static class AlwaysFailingAfterTestMethodTestCase extends BaseTestCase {165	}166	@ContextConfiguration("FailingBeforeAndAfterMethodsTests-context.xml")167	public static class FailingBeforeTransactionTestCase extends AbstractTransactionalTestNGSpringContextTests {168		@org.testng.annotations.Test169		public void testNothing() {170		}171		@BeforeTransaction172		public void beforeTransaction() {173			org.testng.Assert.fail("always failing beforeTransaction()");174		}175	}176	@ContextConfiguration("FailingBeforeAndAfterMethodsTests-context.xml")177	public static class FailingAfterTransactionTestCase extends AbstractTransactionalTestNGSpringContextTests {178		@org.testng.annotations.Test179		public void testNothing() {180		}181		@AfterTransaction182		public void afterTransaction() {183			org.testng.Assert.fail("always failing afterTransaction()");184		}185	}186}...

Source:InvocationCountTest.java

1package test.retryAnalyzer;23import static org.testng.Assert.assertEquals;4import static org.testng.Assert.fail;56import java.util.concurrent.atomic.AtomicInteger;78import org.testng.IRetryAnalyzer;9import org.testng.ITestResult;10import org.testng.TestNG;11import org.testng.annotations.DataProvider;12import org.testng.annotations.Test;1314import com.google.common.collect.ConcurrentHashMultiset;15import com.google.common.collect.Multiset;1617/**18 * retryAnalyzer parameter unit tests.19 * @author tocman@gmail.com (Jeremie Lenfant-Engelmann)20 *21 */22public final class InvocationCountTest implements IRetryAnalyzer {23  static final Multiset<String> invocations = ConcurrentHashMultiset.create();24  private static final AtomicInteger retriesRemaining = new AtomicInteger(100);2526  private int r1 = 0;27  private int r2 = 0;28  private int r3 = 0;29  private int r7 = 0;30  private static int value = 42;3132  @Test(retryAnalyzer = InvocationCountTest.class)33  public void testAnnotationWithNoRetries() {34  }3536  @Test(retryAnalyzer = InvocationCountTest.class)37  public void testAnnotationWithOneRetry() {38    if (r1++ < 1) {39      fail();40    }41  }4243  @Test(retryAnalyzer = InvocationCountTest.class)44  public void testAnnotationWithSevenRetries() {45    if (r7++ < 7) {46      fail();47    }48  }4950  @Test(retryAnalyzer = ThreeRetries.class, successPercentage = 0)51  public void failAfterThreeRetries() {52    fail();53  }5455  @Test(dependsOnMethods = {56      "testAnnotationWithNoRetries",57      "testAnnotationWithOneRetry",58      "testAnnotationWithSevenRetries",59      "failAfterThreeRetries"60  }, alwaysRun = true)61  public void checkInvocationCounts() {62    assertEquals(invocations.count("testAnnotationWithNoRetries"), 0);63    assertEquals(invocations.count("testAnnotationWithOneRetry"), 1);64    assertEquals(invocations.count("testAnnotationWithSevenRetries"), 7);65    assertEquals(invocations.count("failAfterThreeRetries"), 4);66  }6768  @DataProvider(name="dataProvider")69  private Object[][] dataProvider() {70    return new Object[][] { { 1, false }, { 0, true }, { 0, true },71        { 1, false } };72  }7374  @DataProvider(name="dataProvider2")75  private Object[][] dataProvider2() {76    value = 42;7778    return new Object[][] { { true }, { true } };79  }8081  @Test(retryAnalyzer = InvocationCountTest.class, dataProvider = "dataProvider")82  public void testAnnotationWithDataProvider(int paf, boolean test) {83    if (paf == 1 && test == false) {84      if (r2 >= 1) {85        r2--;86        fail();87      }88    }89  }9091  @Test(retryAnalyzer = InvocationCountTest.class, dataProvider = "dataProvider2")92  public void testAnnotationWithDataProviderAndRecreateParameters(boolean dummy) {93    if (r3 == 1) {94      this.value = 0;95      r3--;96      fail();97    } else if (r3 == 0) {98      assertEquals(this.value, 42);99    }100  }101102  @Test103  public void withFactory() {104    TestNG tng = new TestNG();105    tng.setVerbose(0);106    tng.setTestClasses(new Class[] { MyFactory.class});107    FactoryTest.m_count = 0;108109    tng.run();110
...

Source:AssertTest.java

...35    }36    public void testRequireNonNullEntriesException() {37        try {38            Assert.requireNonNullEntries(Arrays.asList(), "message");39            org.testng.Assert.fail();40        } catch (Exception e) {41            org.testng.Assert.assertTrue(e instanceof NullPointerException);42        }43        try {44            Assert.requireNonNullEntries((List<? extends Object>) null, "message");45            org.testng.Assert.fail();46        } catch (Exception e) {47            org.testng.Assert.assertTrue(e instanceof NullPointerException);48        }49    }50    @Test51    public void testRequireNonBlank() {52        Assert.requireNonBlank("Hello", "message");53    }54    @Test55    public void testRequireNonBlankException() {56        try {57            Assert.requireNonBlank(null, "message");58            org.testng.Assert.fail();59        } catch (Exception e) {60            org.testng.Assert.assertTrue(e instanceof NullPointerException);61        }62        try {63            Assert.requireNonBlank("", "message");64            org.testng.Assert.fail();65        } catch (Exception e) {66            org.testng.Assert.assertTrue(e instanceof IllegalArgumentException);67        }68    }69    @Test70    public void testIsBlank() {71        org.testng.Assert.assertTrue(Assert.isBlank(""));72        org.testng.Assert.assertTrue(Assert.isBlank(null));73        org.testng.Assert.assertFalse(Assert.isBlank("a"));74    }75    @Test76    public void testRequireState() {77        Assert.requireState(true, "message");78        try {79            Assert.requireState(false, "message");80            org.testng.Assert.fail();81        } catch (Exception e) {82            org.testng.Assert.assertTrue(e instanceof IllegalStateException);83        }84    }85}...

Source:TestExtentReportsPart8.java

...12import java.io.IOException;13import java.util.Arrays;14public class TestExtentReportsPart8 {15    /*16    NO tearDown() to fail/pass using Listener17    Have tests with Assert but no test.pass/fail()18    Have tests with Assert & no test.pass/fail()19    Inference:20    test1 & test2 BOTH are marked PASS even when test2 fails assert condn; a test is created - status is set to PASS21    by default - no tearDown() to update Assert status.22    test3 & test4 are marked as pass & fail23     */24    public ExtentSparkReporter htmlReporter;25    public ExtentReports extent;26    public ExtentTest test;27    @BeforeTest28    public void setExtent() {29        // specify location of the report30        htmlReporter = new ExtentSparkReporter("./test-output/extent.html");31        htmlReporter.config().setDocumentTitle("Automation Report"); // Title of report32        htmlReporter.config().setReportName("Functional Testing"); // Name of the report33        htmlReporter.config().setTheme(Theme.DARK);34        extent = new ExtentReports();35        extent.attachReporter(htmlReporter);36        // Passing General information37        extent.setSystemInfo("Host name", "localhost");38        extent.setSystemInfo("Environment", "QA");39        extent.setSystemInfo("user", "Dipin");40    }41    @AfterTest42    public void endReport() {43        extent.flush();44    }45    @Test(description = "assert true")46    public void testCase1(){47        test = extent.createTest("test1");48        Assert.assertTrue(true);49    }50    @Test(description = "assert false")51    public void testCase2(){52        test = extent.createTest("test2");53        Assert.assertTrue(false);54    }55    @Test(description = "pass")56    public void testCase3(){57        test = extent.createTest("test3");58        test.pass("testcase3 passed yay!");59    }60    @Test(description = "fail")61    public void testCase4(){62        test = extent.createTest("test4");63        test.fail("testcase4 failed nooo!!!");64    }65}...

Source:TestNGTest.java

...11import static org.testng.Assert.assertNotSame;12import static org.testng.Assert.assertNull;13import static org.testng.Assert.assertSame;14import static org.testng.Assert.assertTrue;15import static org.testng.Assert.fail;16public class TestNGTest {17	@Test18	public void name0a() {19		assertTrue(true);20		assertTrue(true, "true");21		Assert.assertTrue(true, "true");22		assertFalse(false);23		assertFalse(false, "false");24		Assert.assertFalse(false, "false");25		assertEquals(new Object[][] {}, new Object[][] {}); //TODO26		assertEquals(new Object[] {}, new Object[] {}, "text");27		assertEquals(25, 28);28		assertEquals(25, 28, "text");29		assertNotEquals(25, 28);30		assertNotEquals(25, 28, "text");31		assertSame("text", 25);32		assertNotSame("text", 25);33		assertNull(this);34		assertNotNull(this);35		Assert.assertNotNull(this);36		assertNotNull(this, "text");37		fail();38		fail("message");39		fail("message", new NullPointerException());40		Assert.fail();41		Assert.fail("message");42		Assert.fail("message", new NullPointerException());43	}44	@Test()45	public void name1() {46	}47	@Test(timeOut = 20L)48	public void name2() {49		name21();50	}51	@Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = ".*invalid.*")52	public void name21() {53		name2();54	}55	@Test(enabled = false)56	public void name01() {...

fail

Using AI Code Generation

1import org.testng.Assert;2import org.testng.annotations.Test;3public class TestNG_FailMethod {4	public void test1() {5		System.out.println("Running test1");6		Assert.fail("Failing the test");7		System.out.println("After assertion");8	}9	public void test2() {10		System.out.println("Running test2");11		Assert.fail("Failing the test");12		System.out.println("After assertion");13	}14}15	at org.testng.Assert.fail(Assert.java:94)16	at com.test.TestNG_FailMethod.test1(TestNG_FailMethod.java:14)17	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)18	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)19	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)20	at java.lang.reflect.Method.invoke(Method.java:606)21	at org.testng.internal.MethodInvocationHelper.invokeMethod(MethodInvocationHelper.java:85)22	at org.testng.internal.Invoker.invokeMethod(Invoker.java:639)23	at org.testng.internal.Invoker.invokeTestMethod(Invoker.java:816)24	at org.testng.internal.Invoker.invokeTestMethods(Invoker.java:1124)25	at org.testng.internal.TestMethodWorker.invokeTestMethods(TestMethodWorker.java:125)26	at org.testng.internal.TestMethodWorker.run(TestMethodWorker.java:108)27	at org.testng.TestRunner.privateRun(TestRunner.java:774)28	at org.testng.TestRunner.run(TestRunner.java:624)29	at org.testng.SuiteRunner.runTest(SuiteRunner.java:359)30	at org.testng.SuiteRunner.runSequentially(SuiteRunner.java:354)31	at org.testng.SuiteRunner.privateRun(SuiteRunner.java:312)32	at org.testng.SuiteRunner.run(SuiteRunner.java:261)33	at org.testng.SuiteRunnerWorker.runSuite(SuiteRunnerWorker.java:52)34	at org.testng.SuiteRunnerWorker.run(SuiteRunnerWorker.java:86)35	at org.testng.TestNG.runSuitesSequentially(TestNG.java:1224)36	at org.testng.TestNG.runSuitesLocally(TestNG.java:1149)37	at org.testng.TestNG.run(TestNG.java

fail

Using AI Code Generation

1package com.example.tests;2import org.testng.annotations.Test;3import org.testng.Assert;4public class TestClass {5public void testMethod() {6int num = 5;7String temp = null;8String str = "Junit is working fine";9System.out.println("Junit is working fine");10Assert.assertEquals("Junit is working fine", str);11Assert.assertTrue(num > 6, "num is less than 6");12Assert.assertFalse(num > 6, "num is greater than 6");13Assert.assertNotNull(temp);14}15}

TestNG tutorial

TestNG is a Java-based open-source framework for test automation that includes various test types, such as unit testing, functional testing, E2E testing, etc. TestNG is in many ways similar to JUnit and NUnit. But in contrast to its competitors, its extensive features make it a lot more reliable framework. One of the major reasons for its popularity is its ability to structure tests and improve the scripts' readability and maintainability. Another reason can be the important characteristics like the convenience of using multiple annotations, reliance, and priority that make this framework popular among developers and testers for test design. You can refer to the TestNG tutorial to learn why you should choose the TestNG framework.

Chapters

JUnit 5 vs. TestNG: Compare and explore the core differences between JUnit 5 and TestNG from the Selenium WebDriver viewpoint.
Installing TestNG in Eclipse: Start installing the TestNG Plugin and learn how to set up TestNG in Eclipse to begin constructing a framework for your test project.
Create TestNG Project in Eclipse: Get started with creating a TestNG project and write your first TestNG test script.
Automation using TestNG: Dive into how to install TestNG in this Selenium TestNG tutorial, the fundamentals of developing an automation script for Selenium automation testing.
Parallel Test Execution in TestNG: Here are some essential elements of parallel testing with TestNG in this Selenium TestNG tutorial.
Creating TestNG XML File: Here is a step-by-step tutorial on creating a TestNG XML file to learn why and how it is created and discover how to run the TestNG XML file being executed in parallel.
Automation with Selenium, Cucumber & TestNG: Explore for an in-depth tutorial on automation using Selenium, Cucumber, and TestNG, as TestNG offers simpler settings and more features.
JUnit Selenium Tests using TestNG: Start running your regular and parallel tests by looking at how to run test cases in Selenium using JUnit and TestNG without having to rewrite the tests.
Group Test Cases in TestNG: Along with the explanation and demonstration using relevant TestNG group examples, learn how to group test cases in TestNG.
Prioritizing Tests in TestNG: Get started with how to prioritize test cases in TestNG for Selenium automation testing.
Assertions in TestNG: Examine what TestNG assertions are, the various types of TestNG assertions, and situations that relate to Selenium automated testing.
DataProviders in TestNG: Deep dive into learning more about TestNG's DataProvider and how to effectively use it in our test scripts for Selenium test automation.
Parameterization in TestNG: Here are the several parameterization strategies used in TestNG tests and how to apply them in Selenium automation scripts.
TestNG Listeners in Selenium WebDriver: Understand the various TestNG listeners to utilize them effectively for your next plan when working with TestNG and Selenium automation.
TestNG Annotations: Learn more about the execution order and annotation attributes, and refer to the prerequisites required to set up TestNG.
TestNG Reporter Log in Selenium: Find out how to use the TestNG Reporter Log and learn how to eliminate the need for external software with TestNG Reporter Class to boost productivity.
TestNG Reports in Jenkins: Discover how to generate TestNG reports in Jenkins if you want to know how to create, install, and share TestNG reports in Jenkins.

Certification

You can push your abilities to do automated testing using TestNG and advance your career by earning a TestNG certification. Check out our TestNG certification.