/// <summary> /// Returns true iff <code>o</code> is equal to this. </summary> public override bool Equals(object o) { if (this == o) { return(true); } if (!(o is SpanNearQuery)) { return(false); } SpanNearQuery spanNearQuery = (SpanNearQuery)o; if (m_inOrder != spanNearQuery.m_inOrder) { return(false); } if (m_slop != spanNearQuery.m_slop) { return(false); } if (!Equatable.Wrap(m_clauses).Equals(spanNearQuery.m_clauses)) { return(false); } return(Boost == spanNearQuery.Boost); }
public void ShouldBeA_SuperType_FailsWithTypesNotEqualMessage() { object actual = new Equatable(1); MockFormatter.NotEqual(typeof(SubEquatable), typeof(Equatable), "foo").Returns("bar"); EasyAssertionException result = Assert.Throws<EasyAssertionException>(() => actual.ShouldBeA<SubEquatable>("foo")); Assert.AreEqual("bar", result.Message); }
/// <summary> /// Returns a hash code value for this object. </summary> public override int GetHashCode() { return(Number.SingleToInt32Bits(Boost) ^ Slop ^ Equatable.Wrap(GetTerms()).GetHashCode() ^ Equatable.Wrap(GetPositions()).GetHashCode() ^ n); }
public RegexGroup(Hash <string, IObject> passed) : this() { text = ""; index = 0; length = 0; this.passed = passed; internals = new Hash <string, IObject>(); equatable = new Equatable <RegexGroup>(this, "text", "index", "length"); }
public static EqualsData <Equatable> IEquatableData() { var one = new Equatable(1); return(new EqualsData <Equatable> { { one, one, true }, { one, new Equatable(1), true }, { new Equatable(int.MinValue + 1), new Equatable(1), false }, { new Equatable(-1), new Equatable(int.MaxValue), false } }); }
public int LastIndexOf(T item) { for (var index = list.Count - 1; index >= 0; index--) { if (Equatable.Equals(item, list[index])) { return(index); } } return(-1); }
public override bool Equals(object o) { if (this.GetType() != o.GetType()) { return(false); } var other = (MultiFunction)o; // LUCENENET specific: ensure our passed in list is equatable by // wrapping it in an EquatableList if it is not one already return(Equatable.Wrap(this.m_sources).Equals(other.m_sources)); }
public RegexMatch(Hash <string, IObject> passed) : this() { text = ""; index = 0; length = 0; groups = new RegexGroup[0]; nameToIndex = _ => none <int>(); this.passed = passed; internals = new Hash <string, IObject>(); equatable = new Equatable <RegexMatch>(this, "text", "index", "length", "groups"); }
public override bool Equals(object o) { if (object.ReferenceEquals(this, o)) { return(true); } if (!(o is Parent)) { return(false); } return(base.Equals(o) && Equatable.AreEqual(this.Children, (o as Parent).Children)); }
public override int GetHashCode() { int result; result = Equatable.Wrap(m_clauses).GetHashCode(); // Mix bits before folding in things like boost, since it could cancel the // last element of clauses. this particular mix also serves to // differentiate SpanNearQuery hashcodes from others. result ^= (result << 14) | ((int)((uint)result >> 19)); // reversible result += Number.SingleToRawInt32Bits(Boost); result += m_slop; result ^= (m_inOrder ? unchecked ((int)0x99AFD3BD) : 0); return(result); }
public virtual bool Equals(T other) { if ((object)other == null) { return(false); } Type t = GetType(); Type otherType = other.GetType(); if (t != otherType) { return(false); } FieldInfo[] fields = t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); foreach (FieldInfo field in fields) { object value1 = field.GetValue(other); object value2 = field.GetValue(this); if (value1 == null) { if (value2 != null) { return(false); } } else { if (t.IsArray) { if (!Equatable.ArraysAreEqual(value1 as IList, value2 as IList)) { return(false); } } if (!value1.Equals(value2)) { return(false); } } } return(true); }
public int IndexOf(T item) { var index = 0; foreach (var x in list) { if (Equatable.Equals(item, x)) { return(index); } index++; } return(-1); }
public override int GetHashCode() { const int prime = 31; int result = base.GetHashCode(); result = prime * result + ((analyzer == null) ? 0 : analyzer.GetHashCode()); result = prime * result + ((fieldName == null) ? 0 : fieldName.GetHashCode()); result = prime * result + ((likeText == null) ? 0 : likeText.GetHashCode()); result = prime * result + maxQueryTerms; result = prime * result + minDocFreq; result = prime * result + minTermFrequency; result = prime * result + Arrays.GetHashCode(moreLikeFields); result = prime * result + Number.SingleToInt32Bits(percentTermsToMatch); // LUCENENET: wrap in Equatable to compare set contents result = prime * result + ((stopWords == null) ? 0 : Equatable.Wrap(stopWords).GetHashCode()); return(result); }
public RegexGroup(Matcher.Group group) : this() { var(groupText, groupIndex, groupLength) = group; text = groupText; index = groupIndex; length = groupLength; passed = new Hash <string, IObject>(); internals = new Hash <string, IObject> { ["text"] = (String)text, ["index"] = (Int)index, ["length"] = (Int)length }; equatable = new Equatable <RegexGroup>(this, "text", "index", "length"); }
public override bool Equals(object o) { if (this == o) { return(true); } if (!(o is VectorValueSource)) { return(false); } var that = (VectorValueSource)o; // LUCENENET specific: ensure our passed in list is equatable by // wrapping it in an EquatableList if it is not one already return(Equatable.Wrap(m_sources).Equals(that.m_sources)); }
public int IndexOf(T item, int offset) { for (var index = 0; index < list.Count; index++) { if (index < offset) { continue; } if (Equatable.Equals(item, list[index])) { return(index); } } return(-1); }
public override int GetHashCode() { const int prime = 31; int result = base.GetHashCode(); result = prime * result + (m_disableCoord ? 1231 : 1237); result = prime * result + Number.SingleToInt32Bits(m_highFreqBoost); result = prime * result + /*((highFreqOccur == null) ? 0 :*/ m_highFreqOccur.GetHashCode() /*)*/; result = prime * result + Number.SingleToInt32Bits(m_lowFreqBoost); result = prime * result + /*((lowFreqOccur == null) ? 0 :*/ m_lowFreqOccur.GetHashCode() /*)*/; result = prime * result + Number.SingleToInt32Bits(m_maxTermFrequency); result = prime * result + Number.SingleToInt32Bits(m_lowFreqMinNrShouldMatch); result = prime * result + Number.SingleToInt32Bits(m_highFreqMinNrShouldMatch); // LUCENENET specific: wrap the m_terms to ensure the collection values are // compared for equalitly result = prime * result + ((m_terms == null) ? 0 : Equatable.Wrap(m_terms).GetHashCode()); return(result); }
public RegexMatch(Matcher.Match match, Func <string, IMaybe <int> > nameToIndex) : this() { text = match.Text; index = match.Index; length = match.Length; groups = match.Groups.Select(g => new RegexGroup(g)).ToArray(); this.nameToIndex = nameToIndex; passed = new Hash <string, IObject>(); internals = new Hash <string, IObject> { ["text"] = (String)text, ["index"] = (Int)index, ["length"] = (Int)length, ["groups"] = new Tuple(groups.Select(g => (IObject)g).ToArray()) }; equatable = new Equatable <RegexMatch>(this, "text", "index", "length", "groups"); }
public override bool Equals(object o) { if (ReferenceEquals(this, o)) { return(true); } if (!(o is EntityE)) { return(false); } var e = o as EntityE; if (!string.Equals(this.Name, e.Name)) { return(false); } return(Equatable.AreEqual(this.X, e.X) && Equatable.AreEqual(this.Y, e.Y) && (this.Y2 == null ? e.Y2 == null : this.Y2.Equals(e.Y2))); }
public override int GetHashCode() { // LUCENENET specific: ensure our passed in list is equatable by // wrapping it in an EquatableList if it is not one already return(Equatable.Wrap(m_sources).GetHashCode() + Name.GetHashCode()); }
public bool Equals(Equatable other) => throw new NotImplementedException();
public Mixin(string name) { this.name = name; equatable = new Equatable <Mixin>(this, "name"); }
public void ShouldNotBe_EqualValue_FailsWithObjectsEqualMessage() { Equatable actual = new Equatable(1); Equatable notExpected = new Equatable(1); MockFormatter.AreEqual(notExpected, actual, "foo").Returns("bar"); EasyAssertionException result = Assert.Throws<EasyAssertionException>(() => actual.ShouldNotBe(notExpected, "foo")); Assert.AreEqual("bar", result.Message); }
public void ShouldReferTo_DifferentObject_FailsWithObjectsNotSameMessage() { Equatable actual = new Equatable(1); Equatable expected = new Equatable(1); MockFormatter.NotSame(expected, actual, "foo").Returns("bar"); EasyAssertionException result = Assert.Throws<EasyAssertionException>(() => actual.ShouldReferTo(expected, "foo")); Assert.AreEqual("bar", result.Message); }
public void ShouldNotBe_DifferentValue_ReturnsActualValue() { Equatable actual = new Equatable(1); Actual<Equatable> result = actual.ShouldNotBe(new Equatable(2)); Assert.AreSame(actual, result.Value); }
public void ShouldBe_SameValueReturnsActualValue() { Equatable actual = new Equatable(1); Equatable expected = new Equatable(1); Actual<Equatable> result = actual.ShouldBe(expected); Assert.AreSame(actual, result.And); }
public override bool Equals(object obj) { if (this == obj) { return(true); } if (!base.Equals(obj)) { return(false); } if (this.GetType() != obj.GetType()) { return(false); } var other = (CommonTermsQuery)obj; if (m_disableCoord != other.m_disableCoord) { return(false); } if (Number.SingleToInt32Bits(m_highFreqBoost) != Number.SingleToInt32Bits(other.m_highFreqBoost)) { return(false); } if (m_highFreqOccur != other.m_highFreqOccur) { return(false); } if (Number.SingleToInt32Bits(m_lowFreqBoost) != Number.SingleToInt32Bits(other.m_lowFreqBoost)) { return(false); } if (m_lowFreqOccur != other.m_lowFreqOccur) { return(false); } if (Number.SingleToInt32Bits(m_maxTermFrequency) != Number.SingleToInt32Bits(other.m_maxTermFrequency)) { return(false); } if (m_lowFreqMinNrShouldMatch != other.m_lowFreqMinNrShouldMatch) { return(false); } if (m_highFreqMinNrShouldMatch != other.m_highFreqMinNrShouldMatch) { return(false); } if (m_terms == null) { if (other.m_terms != null) { return(false); } } // LUCENENET specific: wrap the m_terms to ensure the collection values are // compared for equalitly else if (!Equatable.Wrap(m_terms).Equals(other.m_terms)) { return(false); } return(true); }
public static bool operator ==(IdImpl obj1, IdImpl obj2) => Equatable.IsEqual(obj1, obj2, (o1, o2) => o1.id == o2.id);
public override bool Equals(object obj) { if (this == obj) { return(true); } if (!base.Equals(obj)) { return(false); } if (this.GetType() != obj.GetType()) { return(false); } var other = (MoreLikeThisQuery)obj; if (analyzer == null) { if (other.analyzer != null) { return(false); } } else if (!analyzer.Equals(other.analyzer)) { return(false); } if (fieldName == null) { if (other.fieldName != null) { return(false); } } else if (!fieldName.Equals(other.fieldName, StringComparison.Ordinal)) { return(false); } if (likeText == null) { if (other.likeText != null) { return(false); } } else if (!likeText.Equals(other.likeText, StringComparison.Ordinal)) { return(false); } if (maxQueryTerms != other.maxQueryTerms) { return(false); } if (minDocFreq != other.minDocFreq) { return(false); } if (minTermFrequency != other.minTermFrequency) { return(false); } if (!Arrays.Equals(moreLikeFields, other.moreLikeFields)) { return(false); } if (Number.SingleToInt32Bits(percentTermsToMatch) != Number.SingleToInt32Bits(other.percentTermsToMatch)) { return(false); } if (stopWords == null) { if (other.stopWords != null) { return(false); } } // LUCENENET: wrap in Equatable to compare set contents else if (!Equatable.Wrap(stopWords).Equals(other.stopWords)) { return(false); } return(true); }