public void ValidaCuraFeitaPeloProprioPersonagemComErro() { string otherName = "OtherPerson"; var _otherCharacter = new Character() { Name = otherName }; var _newHealth = 1000; _character.UpHealth(_newHealth); var serviceCharacter = new ServiceCharacter(_character); try { serviceCharacter.BeCure(_otherCharacter); } catch (Exception ex) { Assert.IsNotNull(ex); AssertFailedException.Equals(ex.Message, "A character can only heal characters of his own faction."); _character.DownHealth(_newHealth); Assert.AreEqual(_character.Health, _originalHealt); Assert.AreEqual(_character.Level, _originalLevel); Assert.AreEqual(_character.Alive, true); Assert.AreNotEqual(_character.Alive, false); Assert.AreEqual(_character.KindOfFighter, TypeOfFighter.Melee); } }
public void Throws_WithActionThatThrowsAndDifferentTypeExpectedException() { AssertFailedException exception = Assert.ThrowsException <AssertFailedException>(() => AssertEx.Throws(() => { throw new ArgumentException("fake-message"); }, new PreConditionException("blah"))); Assert.IsNotNull(exception); Assert.AreEqual("Assert.AreEqual failed. Expected:<Pkgdef_CSharp.PreConditionException>. Actual:<System.ArgumentException>. Wrong exception type thrown.", exception.Message); }
public void Throws_WithActionThatThrowsAndDifferentMessageExpectedException() { AssertFailedException exception = Assert.ThrowsException <AssertFailedException>(() => AssertEx.Throws(() => { throw new ArgumentException("fake-message"); }, new ArgumentException("blah"))); Assert.IsNotNull(exception); Assert.AreEqual("Assert.AreEqual failed. Expected:<blah>. Actual:<fake-message>. Wrong exception message.", exception.Message); }
public void ValidaAtaqueFeitoPersonagemPorOutroPersonagemRangedForaAlcance() { string otherName = "OtherPerson"; var _potenciaAtaque = 10; var _otherCharacter = new Character(TypeOfFighter.Ranged) { Name = otherName, Position = 30 }; var _newHealth = 5000; _character.UpHealth(_newHealth); var serviceCharacter = new ServiceCharacter(_character); try { serviceCharacter.MakeAttack(_potenciaAtaque, _otherCharacter); } catch (Exception ex) { Assert.IsNotNull(ex); AssertFailedException.Equals(ex.Message, "Opponent out of reach."); Assert.AreEqual(_otherCharacter.Health, _originalHealt); Assert.AreEqual(_otherCharacter.Level, _originalLevel); Assert.AreEqual(_otherCharacter.Alive, true); Assert.AreNotEqual(_otherCharacter.Alive, false); Assert.AreEqual(_character.KindOfFighter, TypeOfFighter.Melee); } }
public void Fail_PropagatesErrorMessage() { AssertFailedException exception = Assert.ThrowsException <AssertFailedException>( () => NullableAssert.Fail(s_message, s_parameters)); StringAssert.Contains(exception.Message, s_expectedMessage); }
public void TestIfUpdateTaskFowViewThrowNullReferenceException() { Task actualTask = _persistance.UpdateTaskFowView(null, "", "", "", "", 0); NullReferenceException obj = new NullReferenceException(); AssertFailedException.ReferenceEquals(obj, actualTask); }
public void TestGetFileContents() { string fileName = @"C\Cities.txt"; BussionessLogic bussionessLogic = new BussionessLogic(); OpenWeatherMap openWeatherMap = bussionessLogic.GetFileContents(fileName); AssertFailedException.Equals(null, openWeatherMap); }
private static void logFail(AssertFailedException ex, string expressionAsserted, string description) { if (failedAssertions.Length == 0) { failedAssertions.AppendLine("TOTAL FAILED ASSERTIONS"); failedAssertions.AppendLine("---------------------------------------------------------------------------------------"); } failedAssertions.AppendLine(string.Format("{0} {1}", ex.Message, description + ": FAILED")); }
/// <summary> /// Asserts that the code under test given by the <paramref name="codeThatThrows"/> parameter /// throws an exception of a given type with a ParamName value given by the <paramref name="paramName"/> parameter. /// </summary> /// <param name="exceptionType">The <see cref="Type"/> of exception that the code under test should throw.</param> /// <param name="noExceptionMessage"> /// The message to include with the failed <see cref="Assert"/> if the code under test does not /// throw an exception. /// </param> /// <param name="paramName">The name of the null parameter that results in the <see cref="ArgumentNullException"/>.</param> /// <param name="codeThatThrows">The code under test that is expected to throw an <see cref="ArgumentNullException"/>.</param> public static void Throws(Type exceptionType, string noExceptionMessage, Action codeThatThrows, string paramName) { Exception actualException = null; AssertFailedException assertFailedException = null; try { codeThatThrows(); } catch (Exception exception) { actualException = exception; // Let assert failure in the callback escape these checks assertFailedException = exception as AssertFailedException; if (assertFailedException != null) { throw; } } finally { if (assertFailedException == null) { if (actualException == null) { Assert.Fail(noExceptionMessage); } Assert.IsInstanceOfType( actualException, exceptionType, string.Format( "Expected an exception of type '{0}' but encountered an exception of type '{1}' with the message: {2}.", exceptionType.FullName, actualException.GetType().FullName, actualException.Message)); if (paramName != null) { PropertyInfo propInfo = actualException.GetType().GetProperty("ParamName"); string actualParamName = propInfo == null ? "<not available>" : propInfo.GetValue(actualException, null) as string; Assert.AreEqual( paramName, actualParamName, string.Format( "Expected exception to have paramName='{0}' but found instead '{1}'", paramName, actualParamName)); } } } }
public void TesteValor_MenorQueZero() { try { string valorExtenso = ValorMonetario.Converte(-5); } catch (Exception ex) { AssertFailedException.Equals(MensagemValorInvalido, ex); } }
public void TesteValor_NaoNumero() { try { string valorExtenso = ValorMonetario.Converte("asdfasdfsa"); } catch (Exception ex) { AssertFailedException.Equals(MensagemValorInvalido, ex); } }
public void TesteValor_MaiorQueTresAlgarismos() { try { string valorExtenso = ValorMonetario.Converte(5000); } catch (Exception ex) { AssertFailedException.Equals(MensagemValorInvalido, ex); } }
public Task RunTransferJob(TransferJobBase job, Action <double, double> progressReport, CancellationToken cancellationToken) { try { return(runnerValidation(job)); } catch (AssertFailedException e) { this.assertException = e; throw new MockupException("AssertFailed"); } }
public void Update() { SqlConnection con = new SqlConnection(@"Data Source=DESKTOP-0PBRBDG;Initial Catalog=Dolars;Integrated Security=True"); //con.Open(); con.Open(); string a = @"Update Pracownik Set DataZwolnienia = null"; SqlCommand cmd = new SqlCommand(a, con); // cmd.ExecuteNonQuery(); AssertFailedException.Equals(true, cmd.ExecuteNonQuery()); }
public void Delete() { SqlConnection con = new SqlConnection(@"Data Source=DESKTOP-0PBRBDG;Initial Catalog=Dolars;Integrated Security=True"); //con.Open(); con.Open(); string a = @"Delete from Pracownik where Nazwisko='Stachnik'"; SqlCommand cmd = new SqlCommand(a, con); // cmd.ExecuteNonQuery(); AssertFailedException.Equals(true, cmd.ExecuteNonQuery()); }
/// <summary> /// Asserts that an exception of type <typeparamref name="TException"/> is thrown /// and calls the caller back to do more fine-grained checking. /// </summary> /// <typeparam name="TException">The type of exception that must be thrown.</typeparam> /// <param name="noExceptionMessage">The message to assert if no exception is thrown.</param> /// <param name="codeThatThrows">Code that is expected to trigger the exception. Should not be <c>null</c>.</param> /// <param name="codeThatChecks">Code called after the exception is caught to do finer-grained checking. Should not be <c>null</c>.</param> public static void Throws <TException>( string noExceptionMessage, Action codeThatThrows, Action <TException> codeThatChecks) where TException : Exception { Assert.IsNotNull(codeThatThrows, "The 'codeThatThrows' parameter should not be null."); Assert.IsNotNull(codeThatChecks, "The 'codeThatChecks' parameter should not be null."); Exception actualException = null; AssertFailedException assertFailedException = null; try { codeThatThrows(); } catch (Exception exception) { actualException = exception; // Let assert failure in the callback escape these checks assertFailedException = exception as AssertFailedException; if (assertFailedException != null) { throw; } } finally { if (assertFailedException == null) { if (actualException == null) { string message = string.IsNullOrWhiteSpace(noExceptionMessage) ? string.Format("Expected an exception of type '{0}' but no exception was thrown.", typeof(TException).FullName) : noExceptionMessage; Assert.Fail(message); } Assert.IsInstanceOfType( actualException, typeof(TException), string.Format( "Expected an exception of type '{0}' but encountered an exception of type '{1}' with the message: {2}.", typeof(TException).FullName, actualException.GetType().FullName, actualException.Message)); codeThatChecks((TException)actualException); } } }
public void Insert() { SqlConnection con = new SqlConnection(@"Data Source=DESKTOP-0PBRBDG;Initial Catalog=Dolars;Integrated Security=True"); //con.Open(); con.Open(); string a = @"INSERT INTO Pracownik Values('11' ,'Paulina' , 'Stachnik', '2000.01.01' , null , '50' , 'o prace' , '8')"; SqlCommand cmd = new SqlCommand(a, con); // cmd.ExecuteNonQuery(); AssertFailedException.Equals(true, cmd.ExecuteNonQuery()); }
public void Save(AssertFailedException afe) { string methodName = Get_Executing_Method_Name(afe); string getDate = Get_Date_Now(); string content = getDate + Environment.NewLine + "Where: " + methodName + Environment.NewLine + "What: " + afe.Message + Environment.NewLine + Environment.NewLine; //File.WriteAllText("failed_tests.txt", content); TextWriter tw = new StreamWriter("failed_tests.txt", true); tw.Write(content); tw.Close(); }
private static void ExecuteCodeUnderTest(Type type, object obj, string messageOnFail, Action <Type, object> codeUnderTest) { Exception actualException = null; AssertFailedException assertFailedException = null; try { codeUnderTest(type, obj); } catch (Exception exception) { actualException = exception; // Let assert failure in the callback escape these checks assertFailedException = exception as AssertFailedException; if (assertFailedException != null) { throw; } } finally { if (assertFailedException == null && actualException != null) { string failureMessage = null; if (type.IsValueType) { failureMessage = string.Format("Executing with an instance of type '{0}' and value '{1}' failed.", type.FullName, obj.ToString()); } else { failureMessage = string.Format("Executing with an instance of type '{0}' failed.", type.FullName); } failureMessage = string.Format("{0}: {1}.", failureMessage, actualException.Message); if (!string.IsNullOrWhiteSpace(messageOnFail)) { failureMessage = string.Format(" {0}", failureMessage); } throw new AssertFailedException(failureMessage, actualException); } } }
private AssertFailedException GetDifference(string expected, string actual, AssertFailedException originalException) { var expectedParts = UrlUtilities.CrackUrl(expected); var actualParts = UrlUtilities.CrackUrl(actual); foreach (var part in actualParts.AllKeys) { var expectedVal = expectedParts[part]; var actualVal = actualParts[part]; if (expectedVal != actualVal) { Assert.Fail($"{part} was different. Expected: {expectedVal}. Actual: {actualVal}.{Environment.NewLine}{Environment.NewLine}{originalException.Message}"); } } return(originalException); }
private AssertFailedException GetDifference(string expected, string actual, AssertFailedException originalException) { var expectedParts = PrtgAPI.Helpers.UrlHelpers.CrackUrl(expected); var actualParts = PrtgAPI.Helpers.UrlHelpers.CrackUrl(actual); foreach (var part in actualParts.AllKeys) { var expectedVal = expectedParts[part]; var actualVal = actualParts[part]; if (expectedVal != actualVal) { Assert.Fail($"{part} was different. Expected: {expectedVal}. Actual: {actualVal}.\r\n\r\n{originalException.Message}"); } } return(originalException); }
[TestMethod]//Test to check if DoConnection throws an exception if accountnumber is not passed public void HomepageController_DoConnectionMethod_ThrowsExceptionTest() { //Arrange string resultstr = tpaController.Post(input); string key = resultstr.Substring(38); key = key.Replace(Constants.APPLICATION_URL_DUMMY_TEXT, "/"); accInfo = AvaTaxProfileAssistantHelper.GetAccountInfoBySecureKey(key); accInfo.AccountNumber = ""; Exception e = new Exception(); //Act homeController.DoConnection(ref IsConnected, ref IsChoseCompany, ref WhereToCollectTax, ref NexusWarning, null); //Assert AssertFailedException.Equals("Object reference not set to an instance of an object.", e); }
public void RetryAssert(Action action, int timeoutMilliseconds, int retryIntervalMilliseconds = 50) { AssertFailedException ex = new AssertFailedException("Timeout exceeded before positive check"); var timeout = DateTime.Now.AddMilliseconds(timeoutMilliseconds); while (timeout.Subtract(DateTime.Now).TotalMilliseconds > 0) { try { action(); //no error - return successfully: return; } catch (AssertFailedException aEx) { ex = aEx; Thread.Sleep(retryIntervalMilliseconds); } } throw ex; }
public void ValidaCuraFeitaPersonagemParaOutroSemSucesso() { string _nameFaction = "Warriors"; string _otherNameFaction = "Raptors"; _character.JoinFaction(new AbsFaction(_nameFaction)); string otherName = "OtherPerson"; var _otherCharacter = new Character() { Name = otherName }; _otherCharacter.JoinFaction(new AbsFaction(_otherNameFaction)); var serviceCharacter = new ServiceCharacter(_character); var _newHealth = 1000; _character.UpHealth(_newHealth); try { serviceCharacter.BeCure(_otherCharacter); } catch (Exception ex) { Assert.IsNotNull(ex); AssertFailedException.Equals(ex.Message, "A character can only heal characters of his own faction."); _character.DownHealth(_newHealth); Assert.AreEqual(_character.Health, _originalHealt); Assert.AreEqual(_character.Level, _originalLevel); Assert.AreEqual(_character.Alive, true); Assert.AreNotEqual(_character.Alive, false); Assert.AreEqual(_character.KindOfFighter, TypeOfFighter.Melee); } }
internal static Exception BuildThrowsException(Exception ex, string message) { PreserveStackTrace(ex); Exception result = new AssertFailedException("Assert.Throws() failure: " + message + "\r\n" + ex.Message); FieldInfo remoteStackTraceString = typeof(Exception) .GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic); string currentMethod = MethodBase.GetCurrentMethod().Name; string stackTrace = String.Join(Environment.NewLine, ex.StackTrace .Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries) .Distinct() .Where(frame => !frame.Contains(currentMethod)) .ToArray()); remoteStackTraceString.SetValue( result, stackTrace + Environment.NewLine); // Roundtrip via serialization to cause the full exception data to be persisted, // and to cause the remote stacktrace to be cleaned-up. var selector = new ExceptionSurrogateSelector(); var formatter = new BinaryFormatter(selector, new StreamingContext(StreamingContextStates.All)); using (var mem = new MemoryStream()) { formatter.Serialize(mem, result); mem.Position = 0; result = (Exception)formatter.Deserialize(mem); PreserveStackTrace(result); } return(result); }
public void ValidaAtaqueFeitoAUmObjetoSemSucesso() { var _potenciaAtaque = 10; var _object = new Objects(_originalHealt); _object.DownHealth(_originalHealt); var serviceCharacter = new ServiceCharacter(_character); try { serviceCharacter.MakeAttack(_potenciaAtaque, _object); } catch (Exception ex) { Assert.IsNotNull(ex); AssertFailedException.Equals(ex.Message, "Object is already destroyed."); Assert.AreEqual(_object.Destroyed, true); } }
public void ValidaAtaqueSofridoPersonagemPeloMesmoPersonagem() { var _potenciaAtaque = 10; var serviceCharacter = new ServiceCharacter(_character); try { serviceCharacter.GetAttack(_potenciaAtaque, _character); } catch (Exception ex) { Assert.IsNotNull(ex); AssertFailedException.Equals(ex.Message, "You cant attack yourself."); Assert.AreEqual(_character.Health, _originalHealt); Assert.AreEqual(_character.Level, _originalLevel); Assert.AreEqual(_character.Alive, true); Assert.AreNotEqual(_character.Alive, false); Assert.AreEqual(_character.KindOfFighter, TypeOfFighter.Melee); } }
public void ValidaAtaqueFeitoPersonagemContraOutroPersonagemDiferenteFacao() { string _nameFaction = "Warriors"; string _otherNameFaction = "Raptors"; _character.JoinFaction(new AbsFaction(_nameFaction)); string otherName = "OtherPerson"; var _potenciaAtaque = 10; var _otherCharacter = new Character() { Name = otherName }; _otherCharacter.JoinFaction(new AbsFaction(_nameFaction)); _otherCharacter.JoinFaction(new AbsFaction(_otherNameFaction)); _otherCharacter.LeaveFaction(new AbsFaction(_otherNameFaction)); var serviceCharacter = new ServiceCharacter(_character); try { serviceCharacter.MakeAttack(_potenciaAtaque, _otherCharacter); } catch (Exception ex) { Assert.IsNotNull(ex); AssertFailedException.Equals(ex.Message, "You cant attack yours allies."); Assert.AreEqual(_otherCharacter.Health, _originalHealt); Assert.AreEqual(_otherCharacter.Level, _originalLevel); Assert.AreEqual(_otherCharacter.Alive, true); Assert.AreNotEqual(_otherCharacter.Alive, false); Assert.AreEqual(_character.KindOfFighter, TypeOfFighter.Melee); Assert.AreEqual(_otherCharacter.KindOfFighter, TypeOfFighter.Melee); } }
public void ValidaAtaqueFeitoPersonagemContraOMesmoPersonagem() { var _otherCharacter = new Character(); var serviceCharacter = new ServiceCharacter(_character); var _potenciaAtaque = 10; try { serviceCharacter.MakeAttack(_potenciaAtaque, _character); } catch (Exception ex) { Assert.IsNotNull(ex); AssertFailedException.Equals(ex.Message, "You cant attack yourself."); Assert.AreEqual(_character.Health, 1000); Assert.AreEqual(_character.Level, 1); Assert.AreEqual(_character.Alive, true); Assert.AreNotEqual(_character.Alive, false); Assert.AreEqual(_character.KindOfFighter, TypeOfFighter.Melee); } }
public void ValidaCuraFeitaPeloProprioPersonagemQueEstaMortoComErro() { var _newHealth = 1000; _character.DownHealth(_newHealth); var serviceCharacter = new ServiceCharacter(_character); try { serviceCharacter.BeCure(_character); } catch (Exception ex) { Assert.IsNotNull(ex); AssertFailedException.Equals(ex.Message, "We cant cure a dead character."); Assert.AreEqual(_character.Health, 0); Assert.AreEqual(_character.Level, 0); Assert.AreEqual(_character.Alive, false); Assert.AreNotEqual(_character.Alive, true); Assert.AreEqual(_character.KindOfFighter, TypeOfFighter.Melee); } }