public void TestConstants(string s)
{
var fs = FiniteString.Constant(s);
var f = Function(() => fs);
Assert.IsTrue(f.Assert(x => x == s));
}
public void TestSuffixOfRandom()
{
RandomStrings(s =>
{
var f = Function <FiniteString, bool>(fs => FiniteString.Constant(s).EndsWith(fs));
var ex = f.Find((fs, b) => b).Value.ToString();
Assert.IsTrue(s.EndsWith(ex));
});
}
public void TestEqualityAndHashing(string s1, string s2, bool equal)
{
FiniteString fs1 = s1;
FiniteString fs2 = s2;
Assert.IsFalse(fs1.Equals(new object()));
Assert.IsFalse(fs2.Equals(new object()));
Assert.AreEqual(equal, fs1.Equals(fs2));
Assert.AreEqual(equal, fs1 == fs2);
Assert.AreEqual(!equal, fs1 != fs2);
Assert.AreEqual(equal, fs1.GetHashCode() == fs2.GetHashCode());
}
/// <summary>
/// Convert an input to the Zen string type.
/// </summary>
/// <param name="s">The string.</param>
/// <returns></returns>
private static Zen <TZen> ConvertStringConstant <TZen>(string s)
{
var type = typeof(TZen);
if (type == ReflectionUtilities.StringType)
{
return((Zen <TZen>)(object) Language.String(s));
}
if (type == ReflectionUtilities.FiniteStringType)
{
return((Zen <TZen>)(object) FiniteString.Constant(s));
}
throw new ZenException($"Invalid implicit conversion from string to type: {type}");
}
public void TestConversions(string s)
{
FiniteString fs = s;
Assert.AreEqual(fs.ToString(), s);
}
