private static EntityNamingLogic DefaultNamer() { var result = new EntityNamingLogic(); result.SetNameBuilder(() => "dynamic"); return(result); }
public void NotIsFalseMayThrowExceptions() { const bool tddSucks = false; EntityNamingLogic.ClearDefaultNameCache(); Check.ThatCode(() => Check.That(tddSucks).Not.IsFalse()) .IsAFailingCheckWithMessage(Environment.NewLine + "The checked boolean is false whereas it must be true." + Environment.NewLine + "The checked boolean:" + Environment.NewLine + "\t[False]"); }
/// <summary> /// Builds a new <see cref="FluentSut{T}"/> instance. /// </summary> /// <param name="value">Value to examine.</param> /// <param name="reporter">Error reporter to use</param> /// <param name="negated">true if the check logic must be negated.</param> public FluentSut(T value, IErrorReporter reporter, bool negated) { this.Reporter = reporter; this.value = value; this.Negated = negated; this.namingLogic = new EntityNamingLogic { EntityType = typeof(T) }; }
public void HowGivenValueWorks() { var namer = new EntityNamingLogic("date time"); var message = FluentMessage.BuildMessage("The {0} is before the {1} whereas it must not.") .For(namer) .On("portna") .And.WithGivenValue("ouaq").ToString(); Assert.AreEqual(NewLine + "The checked date time is before the given one whereas it must not." + NewLine + "The checked date time:" + NewLine + "\t[\"portna\"]" + NewLine + "The expected date time:" + NewLine + "\t[\"ouaq\"]", message); }
public void ShouldFailWithHashesWhenSimilar() { EntityNamingLogic.ClearDefaultNameCache(); Check.ThatCode(() => { Check.That(new Basic(1, 2)).IsEqualTo(new Basic(1, 3)); }) .IsAFailingCheckWithMessage("", "The checked struct is different from the expected one.", "The checked struct:", "\t[NFluent.Tests.EnumOrStructRelatedTests+Basic] with HashCode: [3]", "The expected struct:", "\t[NFluent.Tests.EnumOrStructRelatedTests+Basic] with HashCode: [4]"); }
public void NotIsInstanceOfThrows() { EntityNamingLogic.ClearDefaultNameCache(); Check.ThatCode(() => Check.That(FirstLetterLowerCase).Not.IsInstanceOf <char>()) .IsAFailingCheckWithMessage("", "The checked char is an instance of [char] whereas it must not.", "The checked char:", "\t['a'] of type: [char]", "The expected value: different from", "\tan instance of [char]"); }
public void BasicTest() { var message = FluentMessage.BuildMessage("The {0} is ok.").ToString(); var namer = new EntityNamingLogic("string"); Assert.AreEqual(NewLine + "The checked value is ok.", message); // override entity message = FluentMessage.BuildMessage("The {0} is ok.").For(namer).ToString(); Assert.AreEqual(NewLine + "The checked string is ok.", message); }
public void NotIsBeforeMayThrowException() { var christmas2013 = new DateTime(2013, 12, 25); var newYearsEve2014 = new DateTime(2013, 12, 31); EntityNamingLogic.ClearDefaultNameCache(); Check.ThatCode(() => { Check.That(christmas2013).Not.IsBefore(newYearsEve2014); }) .IsAFailingCheckWithMessage("", "The checked date time is before the given one whereas it must not.", "The checked date time:", "\t[2013-12-25T00:00:00.0000000, Kind = Unspecified]", "The expected date time: after or equal", "\t[2013-12-31T00:00:00.0000000, Kind = Unspecified]"); }
public static ICheckLink <ICheck <Nationality> > IsEuropean(this ICheck <Nationality> check) { var structChecker = ExtensibilityHelper.ExtractChecker(check); var namer = new EntityNamingLogic("Nationality"); return(structChecker.ExecuteCheck( () => { if (!structChecker.Value.Equals(Nationality.English) && !structChecker.Value.Equals(Nationality.German) && !structChecker.Value.Equals(Nationality.Serbian) && !structChecker.Value.Equals(Nationality.French)) { var message = FluentMessage.BuildMessage("The {0} is not part of Europe.").For(namer).On(structChecker.Value).ToString(); throw new FluentCheckException(message); } }, FluentMessage.BuildMessage("The {0} is part of Europe whereas it must not.").For(namer).On(structChecker.Value).ToString())); }
/// <summary> /// Initializes a new instance of the <see cref="FluentMessage"/> class. /// </summary> /// <param name="message"> /// The main message. /// </param> /// <remarks> /// You can use {x} as place holders for standard wordings: /// - {0}. /// </remarks> private FluentMessage(string message) { var format = message; format = format.Replace("{checked}", "{0}"); format = format.Replace("{expected}", "{1}"); format = format.Replace("{given}", "{1}"); this.message = format; this.dontRepeatExpected = NormalOrder.IsMatch(format); this.dontRepeatChecked = ReverseOrder.IsMatch(format); this.checkedNamingLogic = new EntityNamingLogic(); this.expectedNamingLogic = new EntityNamingLogic(); this.checkedLabel = GenericLabelBlock.BuildCheckedBlock(this.checkedNamingLogic); this.expectedLabel = GenericLabelBlock.BuildExpectedBlock(this.expectedNamingLogic); }
/// <summary> /// Builds a new <see cref="FluentSut{T}"/> instance. /// </summary> /// <param name="other">Value to examine.</param> /// <param name="negated">true if the check logic must be negated.</param> public FluentSut(FluentSut <T> other, bool negated) : this(other.Value, other.Reporter, negated) { this.namingLogic = other.namingLogic.Clone(); }
/// <summary> /// Specifies the attribute to use to describe entities. /// </summary> /// <param name="newEntityDescription">The new description for the Entity.</param> /// <returns>The same fluent message.</returns> public FluentMessage For(EntityNamingLogic newEntityDescription) { this.checkedNamingLogic.Merge(newEntityDescription); this.expectedNamingLogic.Merge(newEntityDescription); return(this); }
/// <summary> /// Builds a chainable check with a sub item. /// </summary> /// <param name="check">original check to link to</param> /// <param name="item">sub item that can be check with which</param> /// <param name="label">label for the sub item</param> /// <typeparam name="TU">type of the sut</typeparam> /// <typeparam name="T">type of the sub item</typeparam> /// <returns>A chainable link supporting Which</returns> public static ICheckLinkWhich <ICheck <TU>, ICheck <T> > BuildCheckLinkWhich <TU, T>(ICheck <TU> check, T item, EntityNamingLogic label) { var chk = new FluentCheck <T>(item); chk.SutName.Merge(label); return(new CheckLinkWhich <ICheck <TU>, ICheck <T> >(check, chk)); }
public static GenericLabelBlock BuildGivenBlock(EntityNamingLogic namer) { return(new GenericLabelBlock("expected", "given", namer)); }
public static GenericLabelBlock BuildCheckedBlock(EntityNamingLogic namer) { return(new GenericLabelBlock("checked", "checked", namer)); }
internal GenericLabelBlock(string adjective, string adjectiveMessage, EntityNamingLogic namer) { this.adjective = adjective; this.adjectiveForMessages = adjectiveMessage; this.EntityLogic = namer; }