public static object Load(RubyScope/*!*/ scope, RubyModule/*!*/ self, MutableString/*!*/ libraryName)
 {
     object loaded;
     scope.RubyContext.Loader.LoadFile(null, self, libraryName, LoadFlags.ResolveLoaded | LoadFlags.AnyLanguage, out loaded);
     Debug.Assert(loaded != null);
     return loaded;
 }

 static RubyFileOps()
 {
     ALT_SEPARATOR = MutableString.CreateAscii(AltDirectorySeparatorChar.ToString()).Freeze();
     SEPARATOR = MutableString.CreateAscii(DirectorySeparatorChar.ToString()).Freeze();
     Separator = SEPARATOR;
     PATH_SEPARATOR = MutableString.CreateAscii(PathSeparatorChar.ToString()).Freeze();
 }

 /// <summary>
 /// Inflates the compressed string using Ruby's Zlib module
 /// </summary>
 /// <param name="data">The Ruby string to decompress</param>
 /// <returns>The decompressed Ruby string as a System.String</returns>
 public static string ZlibInflate(MutableString data)
 {
     _rubyScope.SetVariable("data", data);
       MutableString result = _rubyEngine.Execute(@"Zlib::Inflate.inflate(data)", _rubyScope);
       _rubyScope.RemoveVariable("data");
       return ConvertString(result);
 }

 internal CharArrayContent(char[]/*!*/ data, int count, MutableString owner) 
     : base(owner) {
     Assert.NotNull(data);
     Debug.Assert(count >= 0 && count <= data.Length);
     _data = data;
     _count = count;
 }

 public Subclass(RubyClass/*!*/ rubyClass, MutableString begin, MutableString end, bool excludeEnd)
     : base(begin, end, excludeEnd)
 {
     Assert.NotNull(rubyClass);
     Debug.Assert(!rubyClass.IsSingletonClass);
     ImmediateClass = rubyClass;
 }

 private JsonWriter()
 {
     Nesting = new Stack<JsonWriterState>();
     Nesting.Push(new JsonWriterState(JsonNodeType.None));
     Indent = new MutableString();
     Settings = Settings ?? JsonWriterSettings.Terse;
 }

 /*!*/
 public static IEnumerable<MutableString> GetMatches(RubyContext/*!*/ context, MutableString/*!*/ pattern, int flags)
 {
     string strPattern = context.DecodePath(pattern);
     foreach (string strFileName in GetMatches(context.Platform, strPattern, flags)) {
         yield return context.EncodePath(strFileName).TaintBy(pattern);
     }
 }

 public Range(MutableString/*!*/ begin, MutableString/*!*/ end, bool excludeEnd)
 {
     _begin = begin;
     _end = end;
     _excludeEnd = excludeEnd;
     _initialized = true;
 }

        public static RubyFile/*!*/ CreateFile(RubyClass/*!*/ self, MutableString/*!*/ path, int mode) {
            if (path.IsEmpty) {
                throw new Errno.InvalidError();
            }

            return new RubyFile(self.Context, path.ConvertToString(), (RubyFileMode)mode);
        }

        public void IComparableOfMutableString_op_CompareTo_objectNull()
        {
            IComparable<MutableString> obj = new MutableString("a");

            var expected = string.CompareOrdinal("a", null);

            Assert.Equal(expected, obj.CompareTo(null));
        }

        public void ICloneable_op_Clone()
        {
            ICloneable expected = new MutableString("One");
            var actual = expected.Clone();

            Assert.Equal(expected, actual);
            Assert.NotSame(expected, actual);
        }

 public static MutableString FastXs(RubyContext/*!*/ context, MutableString/*!*/ self)
 {
     //TODO: we are assuming that every string is UTF8, but this is wrong
     String utf8String = Encoding.UTF8.GetString(self.ToByteArray());
     StringBuilder builder = new StringBuilder((int)(utf8String.Length * 1.5));
     Entities.XML.Escape(builder, utf8String);
     return MutableString.CreateAscii(builder.ToString());
 }

            public static RubyArray Execute(RhoDatabase/*!*/ self, MutableString/*!*/ sqlStatement, Boolean isBatch, RubyArray args)
            {
                try
                {
                    RubyArray retArr = new RubyArray();

                    if (isBatch)
                    {
                        self.m_db.executeBatchSQL(sqlStatement.ToString());
                    }
                    else
                    {
                        Object[] values = null;
                        if (args != null && args.Count > 0)
                        {
                            if (args[0] != null && args[0] is RubyArray)
                                values = ((RubyArray)args[0]).ToArray();
                            else
                                values = args.ToArray();
                        }

                        try
                        {
                            self.m_db.Lock();
                            using (IDBResult rows = self.m_db.executeSQL(sqlStatement.ToString(), values, true))
                            {
                                if (rows != null)
                                {
                                    MutableString[] colNames = null;
                                    for (; !rows.isEnd(); rows.next())
                                    {
                                        IDictionary<object, object> map = new Dictionary<object, object>();
                                        Hash row = new Hash(map);
                                        for (int nCol = 0; nCol < rows.getColCount(); nCol++)
                                        {
                                            if (colNames == null)
                                                colNames = getOrigColNames(rows);

                                            row.Add(colNames[nCol], rows.getRubyValueByIdx(nCol));
                                        }
                                        retArr.Add(row);
                                    }
                                }
                            }
                        }
                        finally
                        {
                            self.m_db.Unlock();
                        }
                    }

                    return retArr;
                }catch (Exception exc)
                {
                    //TODO: throw ruby exception
                    throw exc;
                }
            }

        public void IComparableOfMutableString_op_CompareTo_MutableString(string comparand1,
                                                                          string comparand2)
        {
            IComparable<MutableString> obj = new MutableString(comparand1);
            var expected = string.CompareOrdinal(comparand1, comparand2);
            var actual = obj.CompareTo(comparand2);

            Assert.Equal(expected, actual);
        }

 public static unsafe IntPtr GetBytePtr(MutableString str)
 {
     IntPtr pp;
       fixed (byte* bp = str.ToByteArray())
       {
     pp = (IntPtr)bp;
       }
       return pp;
 }

 internal Node Scalar(MutableString taguri, MutableString value, SymbolId style) {
     return Scalar(
         taguri != null ? taguri.ConvertToString() : "",
         value != null ? value.ConvertToString() : "",
         //It's not clear what style argument really means, it seems to be always :plain
         //for now we are ignoring it, defaulting to \0 (see Representer class)
         '\0'
     );
 }

        public static string Decode(string value)
        {
            var result = new MutableString(WebUtility.HtmlDecode(value));
            foreach (var entity in _entities)
            {
                result.Replace(entity.Key, entity.Value);
            }

            return result;
        }

        private static MutableString/*!*/ CheckContent(MutableString/*!*/ content, IOMode mode) {
            if (content.IsFrozen && mode.CanWrite()) {
                throw Errno.CreateEACCES("Permission denied");
            }

            if ((mode & IOMode.Truncate) != 0) {
                content.Clear();
            }
            return content;
        }

        public static object/*!*/ Require(RubyScope/*!*/ scope, RubyModule/*!*/ self, MutableString/*!*/ libraryName) {
            object loaded;
            
            scope.RubyContext.Loader.LoadFile(
                null, self, libraryName, LoadFlags.LoadOnce | LoadFlags.AppendExtensions | LoadFlags.ResolveLoaded, out loaded
            );

            Debug.Assert(loaded != null);
            return loaded;
        }

 public RubyDir([NotNull]MutableString/*!*/ dirname) {
     string strName = dirname.ConvertToString();
     try {
         _rawEntries = Directory.GetFileSystemEntries(strName);
     } catch (Exception ex) {
         throw ToRubyException(ex, strName, DirectoryOperation.Open);
     }
     _dirName = MutableString.Create(RubyUtils.CanonicalizePath(strName), RubyEncoding.Path);
     _closed = false;
     _pos = -2;
 }