/// <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);
}
