private bool IsFileLoaded(string /*!*/ path, string /*!*/ fullPath, IEnumerable <string> appendExtensions)
{
var toPath = _toStrStorage.GetSite(CompositeConversionAction.Make(_context, CompositeConversion.ToPathToStr));
var encodedPath = _context.EncodePath(path);
var encodedFullPath = (fullPath != null) ? _context.EncodePath(fullPath) : null;
foreach (object file in GetLoadedFiles())
{
if (file == null)
{
throw RubyExceptions.CreateTypeConversionError("nil", "String");
}
// use case sensitive comparison
MutableString loadedFile = Protocols.CastToPath(toPath, file);
if (loadedFile.Equals(encodedPath) || loadedFile.Equals(encodedFullPath))
{
return(true);
}
if (appendExtensions != null)
{
foreach (var extension in appendExtensions)
{
var pathWithExtension = _context.EncodePath(path + extension);
if (loadedFile.Equals(pathWithExtension) || loadedFile.Equals(encodedFullPath))
{
return(true);
}
}
}
}
return(false);
}
public void Equals(StringComparison type)
{
if (type == StringComparison.Ordinal)
{
Assert.AreEqual(s.Equals(s1, StringComparison.Ordinal), false);
Assert.AreEqual(s.Equals(s, StringComparison.Ordinal), true);
}
else if (type == StringComparison.OrdinalIgnoreCase)
{
Assert.AreEqual(s.Equals(s1, StringComparison.OrdinalIgnoreCase), true);
Assert.AreEqual(s.Equals(s, StringComparison.OrdinalIgnoreCase), true);
}
}
internal static MutableString ConvertToHostString(RubyContext /*!*/ context, object hostname)
{
if (hostname == null)
{
return(null);
}
if (hostname is MutableString)
{
MutableString strHostname = (MutableString)hostname;
// Special cases
if (strHostname.IsEmpty)
{
strHostname = ANY_IP_STRING;
}
else if (strHostname.Equals(BROADCAST_STRING))
{
strHostname = BROADCAST_IP_STRING;
}
return(strHostname);
}
int iHostname;
if (Protocols.IntegerAsFixnum(hostname, out iHostname))
{
// Ruby uses Little Endian whereas .NET uses Big Endian IP values
byte[] bytes = new byte[4];
for (int i = 3; i >= 0; --i)
{
bytes[i] = (byte)(iHostname & 0xff);
iHostname >>= 8;
}
return(MutableString.Create(new System.Net.IPAddress(bytes).ToString()));
}
return(Protocols.CastToString(context, hostname));
}
public void TestUpperAndLowerCaseMethod()
{
MutableString s1 = new MutableString("aza23523aza");
MutableString s2 = new MutableString("AzA23523Aza");
MutableString s3 = new MutableString("AZA23523AZA");
MutableString s4 = new MutableString();
s1.CopyTo(s4);
s4.Append("a");
Assert.IsTrue(s1.ToUpperCase().Equals(s2.ToUpperCase()));
Assert.IsTrue(s3.Equals(s2));
s1.Append("a");
s3.Append("A");
Assert.IsFalse(s1.Equals(s3));
Assert.IsTrue(s1.ToLowerCase().Equals(s3.ToLowerCase().ToUpperCase().ToLowerCase()));
Assert.IsTrue(s1.Equals(s4));
}
public static Node /*!*/ ToYaml(double self, [NotNull] RubyRepresenter /*!*/ rep)
{
MutableString str = RubySites.ToS(rep.Context, self);
if (str != null)
{
if (str.Equals("Infinity"))
{
str = MutableString.Create(".Inf");
}
else if (str.Equals("-Infinity"))
{
str = MutableString.Create("-.Inf");
}
else if (str.Equals("NaN"))
{
str = MutableString.Create(".NaN");
}
}
return(rep.Scalar(self, str));
}
internal static string /*!*/ ConvertToHostString(MutableString hostName)
{
if (hostName == null)
{
throw new SocketException((int)SocketError.HostNotFound);
}
if (hostName.IsEmpty)
{
return(IPAddress.Any.ToString());
}
else if (hostName.Equals(BROADCAST_STRING))
{
return(IPAddress.Broadcast.ToString());
}
return(hostName.ConvertToString());
}
private bool IsFileLoaded(MutableString /*!*/ path)
{
foreach (object file in GetLoadedFiles())
{
if (file == null)
{
throw RubyExceptions.CreateTypeConversionError("nil", "String");
}
// case sensitive comparison:
if (path.Equals(_toStrSite.Target(_toStrSite, _context.EmptyScope, file)))
{
return(true);
}
}
return(false);
}
private bool IsFileLoaded(MutableString /*!*/ path)
{
var toStr = _toStrStorage.GetSite(ConvertToStrAction.Make(_context));
foreach (object file in GetLoadedFiles())
{
if (file == null)
{
throw RubyExceptions.CreateTypeConversionError("nil", "String");
}
// case sensitive comparison:
if (path.Equals(toStr.Target(toStr, file)))
{
return(true);
}
}
return(false);
}
private bool AnyFileLoaded(IEnumerable <MutableString> /*!*/ paths)
{
var toPath = _toStrStorage.GetSite(CompositeConversionAction.Make(_context, CompositeConversion.ToPathToStr));
foreach (object file in GetLoadedFiles())
{
if (file == null)
{
throw RubyExceptions.CreateTypeConversionError("nil", "String");
}
// use case sensitive comparison
MutableString loadedPath = Protocols.CastToPath(toPath, file);
if (paths.Any((path) => loadedPath.Equals(path)))
{
return(true);
}
}
return(false);
}
private static MutableString/*!*/ InternalDeleteInPlace(MutableString/*!*/ self, MutableString[]/*!*/ ranges) {
MutableString result = InternalDelete(self, ranges);
if (self.Equals(result)) {
return null;
}
self.Clear();
self.Append(result);
return self;
}
private bool IsFileLoaded(MutableString/*!*/ path) {
foreach (object file in GetLoadedFiles()) {
if (file == null) {
throw RubyExceptions.CreateTypeConversionError("nil", "String");
}
// case sensitive comparison:
if (path.Equals(_toStrSite.Target(_toStrSite, _context.EmptyScope, file))) {
return true;
}
}
return false;
}
private bool IsFileLoaded(MutableString/*!*/ path) {
var toStr = _toStrStorage.GetSite(ConvertToStrAction.Make(_context));
foreach (object file in GetLoadedFiles()) {
if (file == null) {
throw RubyExceptions.CreateTypeConversionError("nil", "String");
}
// case sensitive comparison:
if (path.Equals(toStr.Target(toStr, file))) {
return true;
}
}
return false;
}
internal static string/*!*/ ConvertToHostString(MutableString hostName) {
if (hostName == null) {
throw new SocketException((int)SocketError.HostNotFound);
}
if (hostName.IsEmpty) {
return IPAddress.Any.ToString();
} else if (hostName.Equals(BROADCAST_STRING)) {
return IPAddress.Broadcast.ToString();
}
return hostName.ConvertToString();
}
public void op_Equals_objectSame()
{
var obj = new MutableString("One");
Assert.True(obj.Equals(obj as object));
}
public void IListTest(IListTestType type)
{
MutableString s = new MutableString();
MutableString s1 = new MutableString();
if (type == IListTestType.Contains)
{
s.Assign("qwertyui");
Assert.AreEqual(s.Contains('r'), true);
Assert.AreEqual(s.Contains('q'), true);
Assert.AreEqual(s.Contains('i'), true);
Assert.AreEqual(s.Contains('a'), false);
Assert.AreEqual(s.Contains('s'), false);
Assert.AreEqual(s.Contains('d'), false);
}
if (type == IListTestType.CopyTo)
{
s.Assign("sadfsf");
s1.Assign("r");
s1.CopyTo(s);
Assert.AreEqual(s1, "r");
Assert.AreEqual(s, "r");
s.Assign("sadfsf");
s1.Assign("r");
s.CopyTo(s1);
Assert.AreEqual(s1, "sadfsf");
Assert.AreEqual(s, "sadfsf");
s.Assign("qwer");
Array.Resize(ref ar1, 10);
s.CopyTo(ar1, 0);
Assert.AreEqual(ar1[0], 'q');
Assert.AreEqual(ar1[1], 'w');
Assert.AreEqual(ar1[2], 'e');
Assert.AreEqual(ar1[3], 'r');
}
if (type == IListTestType.IndexOf)
{
s.Assign("qwertyui");
Assert.AreEqual(s.IndexOf('r'), 3);
Assert.AreEqual(s.IndexOf('q'), 0);
Assert.AreEqual(s.IndexOf('i'), 7);
Assert.AreEqual(s.IndexOf('a'), -1);
Assert.AreEqual(s.IndexOf('s'), -1);
Assert.AreEqual(s.IndexOf('d'), -1);
}
if (type == IListTestType.Insert)
{
s.Assign("qazxcv");
s.Insert(0, '1');
Assert.AreEqual(s, "1qazxcv");
s.Insert(2, '2');
Assert.AreEqual(s, "1q2azxcv");
s.Insert(8, '8');
Assert.AreEqual(s, "1q2azxcv8");
}
if (type == IListTestType.Remove)
{
s.Assign("qwaedszf");
s.Remove('e');
Assert.AreEqual(s, "qwadszf");
s.Remove('q');
Assert.AreEqual(s, "wadszf");
s.Remove('f');
Assert.AreEqual(s, "wadsz");
}
if (type == IListTestType.RemoveAt)
{
s.Assign("qwaedszf");
s.RemoveAt(3);
Assert.AreEqual(s, "qwadszf");
s.RemoveAt(0);
Assert.AreEqual(s, "wadszf");
s.RemoveAt(5);
Assert.AreEqual(s, "wadsz");
}
if (type == IListTestType.Equals)
{
s.Assign("sd");
Assert.AreEqual(s.Equals(s), true);
Assert.AreEqual(MutableString.Equals(s, s), true);
s1.Assign("sd");
Assert.AreEqual(s.Equals(s1), true);
Assert.AreEqual(true, s.Equals((IReadOnlyString)s1));
s1.Assign("sdsd");
Assert.AreEqual(s.Equals(s1), false);
Assert.AreEqual(false, s.Equals((IReadOnlyString)s1));
Assert.AreEqual(s1.Equals("sdsd"), true);
Assert.AreEqual(s1.Equals("sdsd1"), false);
Assert.AreEqual(s1.Equals("sdsq"), false);
Assert.AreEqual(s1.Equals((MutableString)null), false);
Assert.AreEqual(MutableString.Equals(null, null), true);
Assert.AreEqual(MutableString.Equals(s, null), false);
Assert.AreEqual(MutableString.Equals(null, s), false);
Assert.AreEqual(MutableString.Equals(new MutableString(), new MutableString()), true);
}
if (type == IListTestType.Clone)
{
s.Assign("qwer");
MutableString s2 = s.Clone();
Assert.AreEqual(s2, "qwer");
Assert.AreEqual(s2, s);
}
if (type == IListTestType.CompareTo)
{
s.Assign("qwer");
s1.Assign("qwzz");
Assert.AreEqual(s.CompareTo(s1) < 0, true);
Assert.AreEqual(MutableString.Compare(s, s1) < 0, true);
Assert.AreEqual(s1.CompareTo(s) > 0, true);
Assert.AreEqual(MutableString.Compare(s1, s) > 0, true);
s1.Assign("qwer");
Assert.AreEqual(s.CompareTo(s1), 0);
Assert.AreEqual(s1.CompareTo(s), 0);
Assert.AreEqual(MutableString.Compare(s, s1), 0);
}
}
public static MutableString/*!*/ TrSqueezeInPlace(MutableString/*!*/ self,
[DefaultProtocol, NotNull]MutableString/*!*/ from, [DefaultProtocol, NotNull]MutableString/*!*/ to) {
MutableString result = TrInternal(self, from, to, true);
if (self.Equals(result)) {
return null;
}
self.Clear();
self.Append(result);
return self;
}
public static bool StringEquals(MutableString/*!*/ lhs, [NotNull]MutableString/*!*/ rhs) {
return lhs.Equals(rhs);
}
public void op_Equals_MutableString_whenSame()
{
var comparand1 = new MutableString("One");
var comparand2 = comparand1;
Assert.True(comparand1.Equals(comparand2));
}