/// <summary> /// Remove a source-target/variant from the specDAG. /// </summary> /// private void RemoveSTV(String source, String target, String variant) { // assert(source.length() > 0); // assert(target.length() > 0); CaseInsensitiveString cisrc = new CaseInsensitiveString(source); CaseInsensitiveString citrg = new CaseInsensitiveString(target); CaseInsensitiveString civar = new CaseInsensitiveString(variant); Hashtable targets = (Hashtable)specDAG[cisrc]; if (targets == null) { return; // should never happen for valid s-t/v } ArrayList variants = (ArrayList)targets[citrg]; if (variants == null) { return; // should never happen for valid s-t/v } ILOG.J2CsMapping.Collections.Collections.Remove(variants, civar); if (variants.Count == 0) { ILOG.J2CsMapping.Collections.Collections.Remove(targets, citrg); // should delete variants if (targets.Count == 0) { ILOG.J2CsMapping.Collections.Collections.Remove(specDAG, cisrc); // should delete targets } } }
public void ToStringReturnOriginalValue() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); Assert.Equal(value, sut.ToString()); }
public void DBFiles_CIString_Test_03_Less() { CaseInsensitiveString S = "ABC"; Assert.IsFalse(S < "a"); Assert.IsTrue(S < "b"); }
/// <summary> /// Register an entry object (adopted) with the given ID, source, target, and /// variant strings. /// </summary> /// private void RegisterEntry(String ID_0, String source, String target, String variant, Object entry, bool visible) { CaseInsensitiveString ciID = new CaseInsensitiveString(ID_0); // Store the entry within an array so it can be modified later if (!(entry is Object[])) { entry = new Object[] { entry }; } ILOG.J2CsMapping.Collections.Collections.Put(registry, ciID, entry); if (visible) { RegisterSTV(source, target, variant); if (!availableIDs.Contains(ciID)) { availableIDs.Add(ciID); } } else { RemoveSTV(source, target, variant); ILOG.J2CsMapping.Collections.Collections.Remove(availableIDs, ciID); } }
/// <summary> /// Register a source-target/variant in the specDAG. Variant may be /// empty, but <paramref name="source"/> and <paramref name="target"/> must not be. If variant is empty then /// the special variant <see cref="NO_VARIANT"/> is stored in slot zero of the /// UVector of variants. /// </summary> private void RegisterSTV(string source, string target, string variant) { // assert(source.length() > 0); // assert(target.length() > 0); CaseInsensitiveString cisrc = new CaseInsensitiveString(source); CaseInsensitiveString citrg = new CaseInsensitiveString(target); CaseInsensitiveString civar = new CaseInsensitiveString(variant); if (!specDAG.TryGetValue(cisrc, out IDictionary <CaseInsensitiveString, IList <CaseInsensitiveString> > targets) || targets == null) { targets = new ConcurrentDictionary <CaseInsensitiveString, IList <CaseInsensitiveString> >(); specDAG[cisrc] = targets; } if (!targets.TryGetValue(citrg, out IList <CaseInsensitiveString> variants) || variants == null) { variants = new List <CaseInsensitiveString>(); targets[citrg] = variants; } // assert(NO_VARIANT == ""); // We add the variant string. If it is the special "no variant" // string, that is, the empty string, we add it at position zero. if (!variants.Contains(civar)) { if (variant.Length > 0) { variants.Add(civar); } else { variants.Insert(0, civar); } } }
public void ToUpperReturnValueInAllCaps() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); Assert.Equal(value.ToUpper(), sut.ToUpper()); }
public void ReplaceString() { CaseInsensitiveString value = "AbcDEf"; Assert.AreEqual("AbEf", value.Replace("Cd", string.Empty).Value); Assert.AreEqual("AbXyEf", value.Replace("Cd", "Xy").Value); }
/// <summary> /// Remove a source-target/variant from the specDAG. /// </summary> private void RemoveSTV(string source, string target, string variant) { // assert(source.length() > 0); // assert(target.length() > 0); CaseInsensitiveString cisrc = new CaseInsensitiveString(source); CaseInsensitiveString citrg = new CaseInsensitiveString(target); CaseInsensitiveString civar = new CaseInsensitiveString(variant); if (!specDAG.TryGetValue(cisrc, out IDictionary <CaseInsensitiveString, IList <CaseInsensitiveString> > targets) || targets == null) { return; // should never happen for valid s-t/v } if (!targets.TryGetValue(citrg, out IList <CaseInsensitiveString> variants) || variants == null) { return; // should never happen for valid s-t/v } variants.Remove(civar); if (variants.Count == 0) { targets.Remove(citrg); // should delete variants if (targets.Count == 0) { specDAG.Remove(cisrc); // should delete targets } } }
public void KeepOriginalValueUnchanged() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); Assert.Equal(value, sut.OriginalValue); }
public void DBFiles_CIString_Test_04_Greater() { CaseInsensitiveString S = "ABC"; Assert.IsTrue(S > "a"); Assert.IsFalse(S > "b"); }
public void DBFiles_CIString_Test_07_IndexOfAny() { CaseInsensitiveString S = "Hello World!"; Assert.AreEqual(1, S.IndexOfAny(new CaseInsensitiveString[] { "LO", "EL" })); Assert.AreEqual(1, S.IndexOfAny(new CaseInsensitiveString[] { "EL", "LO" })); }
/// <summary> /// Remove a source-target/variant from the specDAG. /// </summary> private void RemoveSTV(string source, string target, string variant) { // assert(source.length() > 0); // assert(target.length() > 0); CaseInsensitiveString cisrc = new CaseInsensitiveString(source); CaseInsensitiveString citrg = new CaseInsensitiveString(target); CaseInsensitiveString civar = new CaseInsensitiveString(variant); var targets = specDAG.Get(cisrc); if (targets == null) { return; // should never happen for valid s-t/v } var variants = targets.Get(citrg); if (variants == null) { return; // should never happen for valid s-t/v } variants.Remove(civar); if (variants.Count == 0) { targets.Remove(citrg); // should delete variants if (targets.Count == 0) { specDAG.Remove(cisrc); // should delete targets } } }
/// <summary> /// Increments <paramref name="Value"/> to the smallest value greater than <paramref name="Value"/>. /// </summary> /// <param name="Value">Value</param> /// <returns>If operation was successful.</returns> public static bool Increment(ref CaseInsensitiveString Value) { string s = Value.Value; Increment(ref s); Value = new CaseInsensitiveString(s); return(true); }
public void DBFiles_CIString_Test_02_NonEquality() { CaseInsensitiveString S = "Hello"; Assert.IsFalse(S != "hello"); Assert.IsFalse(S != "Hello"); Assert.IsFalse(S != "HELLO"); }
protected override IEnumerable <object> GetEqualityComponents() { yield return(Number); yield return(CaseInsensitiveString.ToLower()); yield return(CaseSensitiveString); }
public void EqualsShouldReturnFalseWhenComparedToNonCaseSenstiveObject() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); var result = sut.Equals(value); Assert.False(result); }
public void ContainReturnTrueWhenFindsPartOfStringInDifferentCase() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); var result = sut.Contains("somev"); Assert.True(result); }
public void ContainsReturnFalseWhenSearchingForNonExistingPart() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); var result = sut.Contains("other"); Assert.False(result); }
public void ContainsReturnFalseWhenSearchingEmpty() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); var result = sut.Contains(string.Empty); Assert.False(result); }
public void EqualsShouldReturnFalseWhenComparedToNullCaseInsensitiveString() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); CaseInsensitiveString comparer = null; var result = sut.Equals(comparer); Assert.False(result); }
public void EqualityComparer() { CaseInsensitiveString value1 = "AbcDEf"; CaseInsensitiveString value2 = "AbcDEf"; var defaultComparer = EqualityComparer <CaseInsensitiveString> .Default; Assert.AreEqual(defaultComparer.GetHashCode(value1), defaultComparer.GetHashCode(value2)); Assert.IsTrue(defaultComparer.Equals(value1, value2)); }
public void DBFiles_CIString_Test_06_GreaterOrEqual() { CaseInsensitiveString S = "ABC"; Assert.IsTrue(S >= "a"); Assert.IsFalse(S >= "b"); Assert.IsTrue(S >= "abc"); Assert.IsTrue(S >= "Abc"); Assert.IsTrue(S >= "ABC"); }
public void EqualsShouldReturnFalseWhenComparedToDifferentValue() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); var comparer = new CaseInsensitiveString("OtherValue"); var result = sut.Equals(comparer); Assert.False(result); }
public void ContainsReturnFalseWhenSearchingNullCaseInsensitiveObject() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); CaseInsensitiveString partToSearch = null; var result = sut.Contains(partToSearch); Assert.False(result); }
public void EqualsShouldReturnTrueWhenComparedToSameValueWithSameCase() { const string value = "SomeValue"; var sut = new CaseInsensitiveString(value); var comparer = new CaseInsensitiveString(value); var result = sut.Equals(comparer); Assert.True(result); }
public void TestCaseInsensitiveString() { CaseInsensitiveString str1 = new CaseInsensitiveString("ThIs is A tEst"); CaseInsensitiveString str2 = new CaseInsensitiveString("This IS a test"); if (!str1.Equals(str2) || !str1.ToString().Equals(str1.GetString()) || str1.ToString().Equals(str2.ToString())) { Errln("FAIL: str1(" + str1 + ") != str2(" + str2 + ")"); } }
public void DBFiles_CIString_Test_01_Equality() { CaseInsensitiveString S = "Hello"; Assert.IsTrue(S == "hello"); Assert.IsTrue(S == "Hello"); Assert.IsTrue(S == "HELLO"); Assert.AreEqual(S, "hello"); Assert.AreEqual(S, "Hello"); Assert.AreEqual(S, "HELLO"); }
/// <summary> /// Returns an enumeration over visible target names for the given source. /// </summary> /// /// <returns>An <c>Enumeration</c> over <c>String</c> objects</returns> public IIterator GetAvailableTargets(String source) { CaseInsensitiveString cisrc = new CaseInsensitiveString(source); Hashtable targets = (Hashtable)specDAG[cisrc]; if (targets == null) { return(new TransliteratorRegistry.IDEnumeration(null)); } return(new TransliteratorRegistry.IDEnumeration(new ILOG.J2CsMapping.Collections.IteratorAdapter(targets.Keys.GetEnumerator()))); }
/// <summary> /// Returns an enumerable over visible target names for the given /// <paramref name="source"/>. /// </summary> /// <returns>An <see cref="IEnumerable{String}"/>.</returns> public virtual IEnumerable <string> GetAvailableTargets(string source) { CaseInsensitiveString cisrc = new CaseInsensitiveString(source); if (specDAG.TryGetValue(cisrc, out IDictionary <CaseInsensitiveString, IList <CaseInsensitiveString> > targets) && targets != null) { foreach (var id in targets.Keys) { yield return(id.String); } } }
/// <summary> /// Decrements <paramref name="Value"/> to the largest value smaller than <paramref name="Value"/>. /// </summary> /// <param name="Value">Value</param> /// <returns>If operation was successful.</returns> public static bool Decrement(ref CaseInsensitiveString Value) { string s = Value.Value; if (!Decrement(ref s)) { return(false); } Value = new CaseInsensitiveString(s); return(true); }