Example #1
0
        private int CommitTestSource(AutoEvaluation eval, IExternalSource zone)
        {
            FileSystem fs = new FileSystem(m_ident);

            //Make sure toplevel zone directory exists
            CFile zonedir = fs.GetFile(@"c:\zones");

            if (null == zonedir)
            {
                zonedir = fs.CreateDirectory(@"c:\zones", true, null);
            }

            //Build file perms
            CFilePermission.FilePermissionList perms = new CFilePermission.FilePermissionList();
            CourseRole.CourseRoleList          staff = new Courses(m_ident).GetTypedRoles(eval.CourseID, true, null);
            foreach (CourseRole role in staff)
            {
                perms.AddRange(CFilePermission.CreateFullAccess(role.PrincipalID));
            }

            //Create zone directory
            string zpath = @"c:\zones\" + eval.ID;
            CFile  ezonedir;

            if (null == (ezonedir = fs.GetFile(zpath)))
            {
                ezonedir       = fs.CreateDirectory(zpath, false, perms);
                ezonedir.Alias = eval.Name; ezonedir.SpecType = CFile.SpecialType.TEST;
                fs.UpdateFileInfo(ezonedir, false);
            }
            fs.ImportData(zpath, zone, false, true);             //Import the data

            return(ezonedir.ID);
        }
Example #2
0
        public void Save(String fileName)
        {
            Stream s = CSerialization.SerializeBinary(m_Traffic);

            s.Position = 0;
            CFile.WriteStream(fileName, (MemoryStream)s);
        }
Example #3
0
        /// <summary>
        /// Set permissions for a given file
        /// </summary>
        public void SetPermissions(CFile file, CFilePermission perm)
        {
            CFilePermission.FilePermissionList perms = new CFilePermission.FilePermissionList();
            perms.Add(perm);

            SetPermissions(file, perms);
        }
Example #4
0
 /// <summary>
 /// Private functionality to override admin security check
 /// </summary>
 private void SetPermissionsInt(CFile file, CFilePermission.FilePermissionList perms)
 {
     foreach (CFilePermission perm in perms)
     {
         m_dp.UpdateFilePermission(file, perm);
     }
 }
Example #5
0
        private string GetExportPath(CFile file)
        {
            string path = file.FullPath.Substring(3, file.FullPath.Length - 3);

            string[] dirs   = path.Split(@"\".ToCharArray());
            string   aggdir = "";
            int      i;

            path = "";
            for (i = 0; i < dirs.Length - 1; i++)
            {
                aggdir = Path.Combine(aggdir, dirs[i]);
                CFile fdir = GetFile(@"c:\" + aggdir);

                if (fdir == null)
                {
                    path += dirs[i] + @"\";
                }
                else
                {
                    path += fdir.Alias + @"\";
                }
            }
            path += file.Alias;

            path = Globals.PurifyString(path);

            return(path);
        }
Example #6
0
        /// <summary>
        /// Save changes to file data
        /// </summary>
        public bool Save(CFile file)
        {
            CFileLock flock;

            //Release the lock
            if (null == (flock = m_dp.GetLockByFileID(file.ID)))
            {
                throw new FileOperationException("File was never locked, cannot save");
            }

            //Authorize
            if (!Authorize(file, FileAction.WRITE))
            {
                throw new FileOperationException("Permission denied on action: WRITE");
            }

            //Write the data
            CommitData(file);

            //Update mod times
            file.FileModified = DateTime.Now; file.Size = file.RawData.Length;
            m_dp.SyncFile(file);
            PercolateModified(file, file.FileModified);

            m_dp.ReleaseLock(flock);

            return(true);
        }
Example #7
0
        /// <summary>
        /// Authorize a user on a file for an action
        /// </summary>
        protected bool Authorize(int principalID, CFile file, FileAction action, User hint)
        {
            //Hack for system path
            if (file.Path.StartsWith(@"c:\system"))
            {
                return(true);
            }
            else if (hint != null)
            {
                if (hint.Admin)
                {
                    return(true);
                }
                else
                {
                    return(m_dp.AuthorizeFile(principalID, file, action));
                }
            }
            else
            {
                //Check for a user
                Principal prin = new Principals(m_ident).GetInfo(principalID);
                if (prin.Type == Principal.USER)
                {
                    User user = new Users(m_ident).GetInfo(prin.Name, null);
                    if (user.Admin)
                    {
                        return(true);
                    }
                }

                return(m_dp.AuthorizeFile(principalID, file, action));
            }
        }
Example #8
0
        public void Load(String fileName)
        {
            try
            {
                List <T_ChsNameWordTraffic> newWords = new List <T_ChsNameWordTraffic>();

                if (!File.Exists(fileName))
                {
                    //字典文件不存在
                    return;
                }

                MemoryStream s = CFile.ReadFileToStream(fileName);
                s.Position = 0;
                object obj;
                CSerialization.DeserializeBinary(s, out obj);
                m_Traffic = (T_ChsNameTraffic)obj;

                m_Traffic.AfterCount      = 0;
                m_Traffic.AfterWordCount  = 0;
                m_Traffic.BeforeCount     = 0;
                m_Traffic.BeforeWordCount = 0;

                //整理姓名前缀后缀表
                foreach (T_ChsNameWordTraffic wordTraffic in m_Traffic.Words)
                {
                    if (wordTraffic.Word.Length > 1)
                    {
                        if (wordTraffic.Word[0] >= 0x4e00 && wordTraffic.Word[0] <= 0x9fa5)
                        {
                            //是汉字,且长度大于2,才作为有效前后缀
                            newWords.Add(wordTraffic);

                            if (wordTraffic.After > 0)
                            {
                                m_Traffic.AfterCount += wordTraffic.After;
                                m_Traffic.AfterWordCount++;
                            }

                            if (wordTraffic.Before > 0)
                            {
                                m_Traffic.BeforeCount += wordTraffic.After;
                                m_Traffic.BeforeWordCount++;
                            }
                        }
                    }
                }

                m_Traffic.Words = newWords;
            }
            catch
            {
                m_Traffic = new T_ChsNameTraffic();
            }

            foreach (T_ChsNameWordTraffic wordTraffic in m_Traffic.Words)
            {
                m_Table[wordTraffic.Word] = wordTraffic;
            }
        }
Example #9
0
        private void f_BeforeFileCopy(object sender, CBeforeFileCopyEventArgs e)
        {
            FileInfo fiSrc  = new FileInfo(e.FullPathSrc);
            FileInfo fiDest = (File.Exists(e.FullPathDest) ? new FileInfo(e.FullPathDest) : null);

            if (fiDest != null)
            {
                //Remove ReadOnly attribute from destination to block error when copying.
                if ((fiDest.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                {
                    FileAttributes AttrRemoved = CFile.RemoveAttribute(fiDest.Attributes, FileAttributes.ReadOnly);
                    fiDest.Attributes = AttrRemoved;
                }
            }

            string FullPathSrcNewIs;

            if (!IsValidForSync(fiSrc, fiDest, false, out FullPathSrcNewIs))
            {
                e.Cancel = true;
            }

            if (!string.IsNullOrEmpty(FullPathSrcNewIs))
            {
                e.FullPathSrcNew = FullPathSrcNewIs;
            }
        }
Example #10
0
 public void LoadIncompletedFiles()
 {
     foreach (string folder in CKernel.Preferences.GetStringArray("TempFolders"))
     {
         try
         {
             string [] files = Directory.GetFiles(folder);
             foreach (string strfile in files)
             {
                 if (Path.GetExtension(strfile).Equals(".part"))
                 {
                     CFile file = new CFile(Path.GetDirectoryName(strfile), Path.GetFileName(strfile));
                     if (file.FileHash != null)
                     {
                         AddFile(file);                                                  //file loaded properly
                     }
                 }
             }
         }
         catch (IOException e)
         {
             // any temp directory don't exist
             Debug.Write(e.ToString());
         }
     }
 }
Example #11
0
 public string GetFileImage(CFile file)
 {
     if (file.IsDirectory())
     {
         return("../../" + GetFolderIcon(file));
     }
     else
     {
         ;
         string imgpath;
         try {
             imgpath = FileBrowserImageFactory.GetInstance().GetExtensionImage(
                 Path.GetExtension(file.Name));
         } catch (Exception) {
             imgpath = null;
         }
         if (imgpath == null)
         {
             return("../../attributes/filebrowser/misc.gif");
         }
         else
         {
             return("../../attributes/filebrowser/" + imgpath);
         }
     }
 }
Example #12
0
        public HttpResponseMessage DeleteFile(Guid fileId)
        {
            try
            {
                HttpResponseMessage response = new HttpResponseMessage();

                CFile file = _fileContext.GetByFileId(fileId);

                // if file exist - delete it, if not continue to delete DB record cuz user wanted to delete real file anyway
                if (File.Exists(file.Path + file.Name))
                {
                    File.Delete(file.Path + file.Name);
                }

                // delete record from DB
                if (_fileContext.Delete(fileId) > 0)
                {
                    Request.CreateResponse(HttpStatusCode.OK, $"File {file.Name} has been deleted!");
                    return(response);
                }

                Request.CreateResponse(HttpStatusCode.BadRequest, $"Error: File {file.Name} has not been deleted!");
                return(response);
            }
            catch (ContextException e)
            {
                HttpContext.Current.Response.StatusCode = (Int32)HttpStatusCode.BadRequest;
                throw new ContextException(e.Message, e);
            }
        }
Example #13
0
        public void LoadFileBrowser()
        {
            int i = 0;

            tvFiles.Nodes.Clear();
            FileSystem fs = new FileSystem(Globals.CurrentIdentity);

            foreach (string droot in m_roots)
            {
                CFile dirroot = fs.GetFile(droot);

                TreeNode root = new TreeNode();
                root.Text       = dirroot.Alias;
                root.ImageUrl   = GetFolderIcon(dirroot);
                root.NodeData   = dirroot.FullPath;
                root.Expandable = ExpandableValue.Always;
                tvFiles.Nodes.Add(root);

                if (i == 0 && ViewState["gridpath"] == null)
                {
                    ViewState["gridpath"] = dirroot.FullPath;
                    ExpandTreeNode(root);
                }
                ++i;
            }

            BindFileGrid();
            BindClipBoard();
        }
Example #14
0
        private void BindFileGrid()
        {
            FileSystem fs   = new FileSystem(Globals.CurrentIdentity);
            string     path = GetCurrentPath();

            if (path == null)
            {
                return;
            }

            CFile file = fs.GetFile(path);

            CFile.FileList dirlist;
            try {
                dirlist = fs.ListDirectory(file);
            } catch (CustomException er) {
                dirlist = new CFile.FileList();
                DisplayMessage(er.Message);
            }

            dirlist.Insert(0, file);

            m_curdir           = file;
            dgFiles.DataSource = dirlist;
            dgFiles.DataBind();
        }
Example #15
0
        private void DoDelete(int subID, int locid)
        {
            FileSystem fs = new FileSystem(m_ident);

            //Take results
            Results resultda = new Results(m_ident);

            Result.ResultList ress = GetResults(subID);
            foreach (Result res in ress)
            {
                resultda.Delete(res.ID);
            }

            //Take any tests queued
            AutoJobs jobda = new AutoJobs(m_ident);

            AutoJobTest.AutoJobTestList tests = jobda.GetSubTests(subID);
            foreach (AutoJobTest test in tests)
            {
                jobda.FinishTest(test);
            }

            //Take the submission record
            m_dp.DeleteSubmission(subID);

            //Take the files
            CFile subdir = fs.GetFile(locid);

            if (subdir != null)
            {
                fs.DeleteFile(subdir);
            }
        }
Example #16
0
        /// <summary>
        /// Save Log file
        /// </summary>
        /// <param name="arrLine"></param>
        private void LogErrorFileSave(ArrayList arrLine)
        {
            string strYear  = DateTime.Now.Year.ToString();
            string strMonth = DateTime.Now.Month.ToString();
            string strDay   = DateTime.Now.Day.ToString();

            if (arrLine.Count == 0)
            {
                return;
            }

            Config cConf    = new Config();
            CFile  cLogFile = new CFile();
            string DirPath  = cConf.getappSettings(Config.SettingField.DataSyncDir.ToString());

            cLogFile.fileName = DirPath + "/errorTerminal.log";

            string sLine;

            foreach (string Line in arrLine)
            {
                sLine = "[" + DateTime.Now.ToUniversalTime().ToString() + "]" + Line;
                cLogFile.AddLine(sLine);
            }
            cLogFile.Write();
        }
Example #17
0
        private void SaveToCacheDt(string Key, string FullPathToSave)
        {
            CreateCacheFolder();

            string FullPathCache = GetFullPathCacheDt(Key);

            if (!File.Exists(FullPathCache))
            {
                CreateDt(FullPathCache, false);
            }

            DataTable dt = new DataTable();

            dt.ReadXml(FullPathCache);

            string Criteria = "Key = '" + Key.Replace("'", "''") + "'";

            DataRow[] adr = dt.Select(Criteria);

            if (adr.Length > 0)
            {
                adr[0]["Content"] = CFile.GetByteFromFile(FullPathToSave);
            }
            else
            {
                DataRow dr = dt.NewRow();
                dr["Key"]     = Key;
                dr["Content"] = CFile.GetByteFromFile(FullPathToSave);
                dt.Rows.Add(dr);
            }

            dt.WriteXml(FullPathCache, XmlWriteMode.WriteSchema);
            dt = null;
        }
Example #18
0
        /// <summary>
        /// Fetch the data for a file object
        /// </summary>
        public void FetchData(CFile file)
        {
            SqlConnection myConnection = new SqlConnection(Globals.DataConnectionString);
            SqlCommand    myCommand    =
                new SqlCommand("SELECT data FROM FileData WHERE fileID = @FileID", myConnection);

            SqlParameter parameter = new SqlParameter("@FileID", SqlDbType.Int, 4);

            parameter.Value = file.ID;
            myCommand.Parameters.Add(parameter);

            myConnection.Open();
            SqlDataReader reader = myCommand.ExecuteReader();

            if (!reader.Read())
            {
                throw new Exception("File Not Found!");
            }

            byte[] data = (byte[])reader["data"];
            file.RawData = data;

            reader.Close();
            myConnection.Close();
        }
Example #19
0
        public void CopyFile(CFile dest, CFile src)
        {
            string dpath = Path.Combine(m_localpath, dest.ID.ToString());
            string spath = Path.Combine(m_localpath, src.ID.ToString());

            File.Copy(spath, dpath, true);
        }
Example #20
0
        public void SaveDataByProcToCache(string Key, object DataToSave)
        {
            string FullPathTemp = CFile.GetTempFileName();

            if (this.mUseAdo)
            {
                Recordset RsToSave = DataToSave as Recordset;
                RsToSave.Save(FullPathTemp, PersistFormatEnum.adPersistXML);
                SaveToCacheRs(Key, FullPathTemp);
            }
            else
            {
                DataTable DtToSave = DataToSave as DataTable;
                DtToSave.TableName = "Content";
                if (DtToSave.DataSet == null)
                {
                    DtToSave.WriteXml(FullPathTemp, XmlWriteMode.WriteSchema);
                }
                else
                {
                    DtToSave.DataSet.WriteXml(FullPathTemp, XmlWriteMode.WriteSchema);
                }
                SaveToCacheDt(Key, FullPathTemp);
            }
        }
Example #21
0
        public void TestReadInt32s()
        {
            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                var vals = cfile.ReadInt32s(4);
                Assert.Equal(2, vals.Length);
                Assert.Equal((int)0x78563412, vals[0]);
                Assert.Equal(0x98BADCFE, (uint)vals[1]);
                Assert.Equal(null, cfile.ReadInt32s(4));
                Assert.Equal(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA }))) {
                var vals = cfile.ReadInt32s(4);
                Assert.Equal(1, vals.Length);
                Assert.Equal((int)0x78563412, vals[0]);
                Assert.Equal(null, cfile.ReadInt32s(4));
                Assert.Equal(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 97, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.Equal('a', cfile.ReadChar());
                var vals = cfile.ReadInt32s(4);
                Assert.Equal(2, vals.Length);
                Assert.Equal((int)0x78563412, vals[0]);
                Assert.Equal(0x98BADCFE, (uint)vals[1]);
                Assert.Equal(null, cfile.ReadInt32s(4));
                Assert.Equal(true, cfile.EOF);
            }
        }
Example #22
0
        public void TestCreate()
        {
            using (var stream = new System.IO.MemoryStream())
                using (var cfile = new CFile(stream))
                {
#if !NET_STANDARD
                    Assert.Equal("Windows-1252", cfile.Encoding.WebName);
#else
                    Assert.Equal("utf-8", cfile.Encoding.WebName);
#endif
                    Assert.Equal(0, cfile.Length);
                    Assert.Equal(0, cfile.Position);
                    Assert.Equal(false, cfile.EOF);
                    Assert.Equal(-1, cfile.Read());
                    Assert.Equal(true, cfile.EOF);
                }
            using (var stream = new System.IO.MemoryStream())
                using (var cfile = new CFile(stream, Encoding.UTF8))
                {
                    Assert.Equal("utf-8", cfile.Encoding.WebName);
                    Assert.Equal(0, cfile.Length);
                    Assert.Equal(0, cfile.Position);
                    Assert.Equal(false, cfile.EOF);
                    Assert.Equal(-1, cfile.Read());
                    Assert.Equal(true, cfile.EOF);
                }
        }
Example #23
0
    /// <summary>
    /// 获取SDK目录
    /// </summary>
    /// <returns></returns>

    /*private static string GetSDKDir()
     * {
     *  return EditorUtility.OpenFolderPanel("Please select the android sdk directory", SDK_PATH_DEFAULT, "");
     * }*/

    /// <summary>
    /// 更改标题画面
    /// </summary>
    /// <param name="titleName"></param>
    private static bool CopyLogo()
    {
        try
        {
            string src  = Application.dataPath + "/Projects/" + PlayerSettings.companyName + "/Logo";
            string desc = Application.dataPath + "/Logo";

            Debug.Log("copy file from:" + src + " to:" + desc);

            if (!Directory.Exists(src))
            {
                Debug.Log(src + " dir is not exists");
                return(true);
            }

            if (Directory.Exists(desc))
            {
                CFile.DeleteDirectory(desc);
            }

            CFile.CopyDirectory(src, desc);

            AssetDatabase.Refresh();
        }
        catch (Exception ex)
        {
            Debug.LogException(ex);
            return(false);
        }

        return(true);
    }
Example #24
0
        public void TestReadDoubles()
        {
            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                var vals = cfile.ReadDoubles(4);
                Assert.Equal(2, vals.Length);
                Assert.Equal("4.69197536052338E+271", vals[0].ToString(CultureInfo.InvariantCulture));
                Assert.Equal(-1.50730608775746E-189, vals[1], 15);
                Assert.Equal(null, cfile.ReadDoubles(4));
                Assert.Equal(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA }))) {
                var vals = cfile.ReadDoubles(4);
                Assert.Equal(1, vals.Length);
                Assert.Equal("4.69197536052338E+271", vals[0].ToString(CultureInfo.InvariantCulture));
                Assert.Equal(null, cfile.ReadDoubles(4));
                Assert.Equal(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 97, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.Equal('a', cfile.ReadChar());
                var vals = cfile.ReadDoubles(4);
                Assert.Equal(2, vals.Length);
                Assert.Equal("4.69197536052338E+271", vals[0].ToString(CultureInfo.InvariantCulture));
                Assert.Equal(-1.50730608775746E-189, vals[1], 15);
                Assert.Equal(null, cfile.ReadDoubles(4));
                Assert.Equal(true, cfile.EOF);
            }
        }
Example #25
0
        /// <summary>
        /// Update a rubric entry
        /// </summary>
        public bool Update(Rubric rub)
        {
            //check permission
            Assignment asst = new Assignments(m_ident).GetInfo(rub.AsstID);

            Authorize(asst.CourseID, "updaterubric", asst.ID, null);

            //Rename zone on entry rename
            if (rub.EvalID >= 0)
            {
                FileSystem fs     = new FileSystem(m_ident);
                int        zoneID =
                    (new Evaluations(m_ident).GetInfo(rub.EvalID) as AutoEvaluation).ZoneID;
                CFile zdir = fs.GetFile(zoneID);
                zdir.Alias = rub.Name;
                fs.UpdateFileInfo(zdir, false);
            }

            //Update entry
            m_dp.UpdateRubricEntry(rub);

            //Retally points and update root entry
            Rubric root = new Assignments(m_ident).GetRubric(rub.AsstID);

            root.Points = RetallyPoints(root);
            m_dp.UpdateRubricEntry(root);

            //Log
            Log("Updated rubric entry: " + rub.Name, rub.AsstID);

            return(true);
        }
Example #26
0
            /// <summary>
            /// No Path, No Extension
            /// </summary>
            /// <param name="NameFull"></param>
            /// <param name="Name"></param>
            /// <param name="Error"></param>
            /// <returns></returns>
            public static bool GetNameShort(String NameFull, out String Name, out String Error)
            {
                int    iIndex;
                String strMsg, strName, strNameFull;

                Name = "";

                if (!CFile.GetName(NameFull, out strName, out Error))
                {
                    return(false);
                }

                //System.IO.Path.GetFileNameWithoutExtension()
                strNameFull = NameFull;
                iIndex      = strName.LastIndexOf(".");
                if (iIndex == -1)
                {
                    strMsg = String.Format("The name of file doesn't contain the extension.({0})", strNameFull);
                    Error  = strMsg;

                    return(false);
                }

                Name = strName.Substring(0, iIndex);
                return(true);
            }
Example #27
0
        private void SaveToCacheRs(string Key, string FullPathToSave)
        {
            CreateCacheFolder();

            string FullPathCache = GetFullPathCacheRs(Key);

            if (!File.Exists(FullPathCache))
            {
                CreateRs(FullPathCache, false);
            }

            Recordset Rs = new Recordset();

            Rs.Open(FullPathCache, Missing.Value, CursorTypeEnum.adOpenStatic, LockTypeEnum.adLockPessimistic, -1);

            string Criteria = "Key = '" + Key.Replace("'", "''") + "'";

            Rs.Find(Criteria, 0, SearchDirectionEnum.adSearchForward, Missing.Value);

            if (!Rs.EOF)
            {
                Rs.Fields["Content"].AppendChunk(CFile.GetByteFromFile(FullPathToSave));
            }
            else
            {
                Rs.AddNew(Missing.Value, Missing.Value);
                Rs.Fields["Key"].Value = Key;
                Rs.Fields["Content"].AppendChunk(CFile.GetByteFromFile(FullPathToSave));
            }

            Rs.Save(FullPathCache, PersistFormatEnum.adPersistXML);
            Rs.Close();
            Rs = null;
        }
Example #28
0
        public static void GetFileFromField(ADODB.Field Fld, string FullPath)
        {
            byte[] aChunks = new byte[Fld.ActualSize];
            aChunks = (byte[])Fld.GetChunk(Fld.ActualSize);

            CFile.WriteByteToFile(FullPath, aChunks);
        }
Example #29
0
        protected IEnumerator UpdateAssetFromUrl(CUpdateList needUpdateLst, string downloadUrl)
        {
            updateNum     = 0;
            needUpdateNum = needUpdateLst.Count();
            string savePath, downloadPath, saveDir;

            base.Event.Trigger(CAutoUpdateEvents.ON_UPDATE_FILE_START);
            foreach (CUpdateListField field in needUpdateLst)
            {
                downloadPath = downloadUrl + field.Path;
                savePath     = CEnv.AssetPath + field.Path;

                saveDir = savePath.Substring(0, savePath.LastIndexOf('/'));

                updateNum++;
                base.Event.Trigger(CAutoUpdateEvents.ON_UPDATE_FILE_ACTION);

                using (UnityWebRequest request = UnityWebRequest.Get(downloadPath))
                {
                    yield return(request.Send());

                    if (request.isError || request.responseCode != 200)
                    {
                        base.Event.Trigger(CAutoUpdateEvents.ON_UPDATE_FILE_FAILD);
                        yield break;
                    }
                    CDirectory.CreateDir(saveDir);
                    CFile.Cover(savePath, request.downloadHandler.data, 0, request.downloadHandler.data.Length);
                }
            }

            base.Event.Trigger(CAutoUpdateEvents.ON_UPDATE_FILE_END);
        }
Example #30
0
        static public void SaveToBinFile(String fileName, T_DictFile dictFile)
        {
            Stream s = CSerialization.SerializeBinary(dictFile);

            s.Position = 0;
            CFile.WriteStream(fileName, (MemoryStream)s);
        }
Example #31
0
        public async Task<ActionResult> Receive()
        {
            bool thumb = true;

            int thumb_width = 200;
            int thumb_height = 200;
            string name = Request.Headers["UploaderName"];

            bool chunk = bool.Parse(Request.Headers["Chunk"]);

            if (chunk)
            {
                var fileName = Request.Headers["FileName"];
                var size = int.Parse(Request.Headers["FileSize"]);
                
                CFile file = null;

                //Check it if there is a file with that name and if there is not create one
                if (!chunkFilesPath.ContainsKey(fileName))
                {
                    file = new CFile(Server.MapPath("~/uploads") + "/" + fileName, size);
                    chunkFilesPath.Add(fileName, file);
                }

                //Write the partion of the file with the position.
                if (chunkFilesPath.TryGetValue(fileName, out file))
                {
                    var stream = Request.InputStream;
                    var position = int.Parse(Request.Headers["ChunkPosition"]);

                    file.Upload(stream, position);
                }

                //If it is %100 then remove it from the dictionary.
                if (file.Percent == 100)
                {
                    chunkFilesPath.Remove(fileName);
                }

                return Json(true);
            }
            else
            {
                TFile file = new TFile(Server.MapPath("~/uploads/images"), Server.MapPath("~/uploads/thumbnails"), thumb_width, thumb_height);

                if (file.UploadAjax(Request.InputStream, name, thumb) == -1) //fail
                {
                    return Json(false);
                }
                else //success
                {
                    return Json(true);
                }

            }

        }
Example #32
0
        public Collection(  string FileName, object ProgressBar )
        {
            _vectors_name       = new List<string>();
            _vectors_visibility = new List<bool>();
            Vectors            = new List<Vector>();

            File    = new CFile(_vectors_name, _vectors_visibility, Vectors, FileParam);

            File.Load_TextFile( FileName, ProgressBar );
        }
Example #33
0
 public void TestCreate()
 {
     var stream = new System.IO.MemoryStream();
     using (var cfile = new CFile(stream)) {
         Assert.AreEqual(0, cfile.Length);
         Assert.AreEqual(0, cfile.Position);
         Assert.AreEqual(false, cfile.EOF);
         Assert.AreEqual(-1, cfile.Read());
         Assert.AreEqual(true, cfile.EOF);
     }
 }
Example #34
0
 public CHashSetResponse(MemoryStream buffer, CFile File)
 {
     BinaryWriter writer = new BinaryWriter(buffer);
     DonkeyHeader header = new DonkeyHeader((byte)Protocol.ClientCommand.HashSetAnswer, writer);
     writer.Write(File.FileHash);
     writer.Write((ushort)File.HashSet.Count);
     foreach (byte[] PartialHash in File.HashSet)
     {
         writer.Write(PartialHash);
     }
     header.Packetlength = (uint)writer.BaseStream.Length - header.Packetlength + 1;
     writer.Seek(0, SeekOrigin.Begin);
     header.Serialize(writer);
 }
Example #35
0
        public Collection(int ItemsCount = 1)
        {
            _vectors_name   = new List<string>();
            _vectors_visibility = new List<bool>();
            Vectors = new List<Vector>();

            File    = new CFile(_vectors_name, _vectors_visibility, Vectors, FileParam);

            FileParam.CanalCount   = ItemsCount;
            FileParam.FileVersion  = 1;
            FileParam.SamplingTime = 1.0f;
            FileParam.ScaleFactor  = 1.0f;

            for (int i = 0; i < ItemsCount; i++)
            {
                _vectors_name.Add("Canal_" + i.ToString());
                _vectors_visibility.Add(true);
            }
            set_Vectors_Count(ItemsCount);
        }
Example #36
0
        public Collection(int ItemsCount)
        {
            _names   = new List<string>();
            _visible = new List<bool>();
            _items   = new List<List<float>>();

            File    = new CFile(_names, _visible, _items, FileParam);

            FileParam.CanalCount   = 0;
            FileParam.FileVersion  = 0;
            FileParam.SamplingTime = 0.0f;
            FileParam.ScaleFactor  = 1.0f;

            for (int i = 0; i < ItemsCount; i++)
            {
                _names.Add("Canal_" + i.ToString());
                _visible.Add(true);
            }
            SetListsCount(ItemsCount);
        }
Example #37
0
        public Collection( Collection inCollection )
        {
            _vectors_name       = new List<string>(inCollection._vectors_name);
            _vectors_visibility = new List<bool>(inCollection._vectors_visibility);
            Vectors            = new List<Vector>();

            File    = new CFile(_vectors_name, _vectors_visibility, Vectors, FileParam);

            FileParam.CanalCount   = inCollection.FileParam.CanalCount;
            FileParam.FileVersion  = inCollection.FileParam.FileVersion;
            FileParam.SamplingTime = inCollection.FileParam.SamplingTime;
            FileParam.ScaleFactor  = inCollection.FileParam.ScaleFactor;

            int ItemsCount = inCollection.Vectors.Count;

            // Копирование содержимого
            Vectors.Clear();
            for (int i = 0; i < ItemsCount; i++)
                Vectors.Add(new Vector(inCollection.Vectors[i]));

            GC.Collect();
        }
Example #38
0
 public CHashSetResponse(MemoryStream buffer, ref CFile File)
 {
     BinaryReader reader = new BinaryReader(buffer);
     byte[] FileHash;//=new byte[16];
     FileHash = reader.ReadBytes(16);
     if (!CKernel.SameHash(ref FileHash, ref File.FileHash)) return;
     ArrayList NewHashSet = new ArrayList();
     ushort nChunks = reader.ReadUInt16();
     if (nChunks == 0)
     {
         NewHashSet.Add(FileHash);
         //Fichero.GetHashSet().Clear();
         //Fichero.SetHashSet(null);
         File.HashSet = NewHashSet;
     }
     else
     {
         byte[] PartialHash;//=new byte[16];
         while (nChunks > 0)
         {
             PartialHash = reader.ReadBytes(16);
             NewHashSet.Add(PartialHash);
             nChunks--;
         }
         byte[] HashSetChecked = CHash.DoHashSetHash(NewHashSet);
         if (CKernel.SameHash(ref HashSetChecked, ref File.FileHash))
         {
             //Fichero.GetHashSet().Clear();
             //Fichero.SetHashSet(null);
             File.HashSet = NewHashSet;
         }
     }
     reader.Close();
     buffer.Close();
     reader = null;
     buffer = null;
 }
Example #39
0
        public void TestReadChar()
        {
            using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
                Assert.AreEqual(195, cfile.ReadChar());
                Assert.AreEqual(168, cfile.ReadChar());
                Assert.AreEqual(97, cfile.ReadChar());
                Assert.AreEqual(195, cfile.ReadChar());
                Assert.AreEqual(160, cfile.ReadChar());
                Assert.AreEqual(10, cfile.ReadChar());
                Assert.AreEqual(195, cfile.ReadChar());
                Assert.AreEqual(188, cfile.ReadChar());
                Assert.AreEqual(195, cfile.ReadChar());
                Assert.AreEqual(174, cfile.ReadChar());
                Assert.AreEqual(0, cfile.ReadChar());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")))) {
                Assert.AreEqual(232, cfile.ReadChar());
                Assert.AreEqual(97, cfile.ReadChar());
                Assert.AreEqual(224, cfile.ReadChar());
                Assert.AreEqual(10, cfile.ReadChar());
                Assert.AreEqual(252, cfile.ReadChar());
                Assert.AreEqual(238, cfile.ReadChar());
                Assert.AreEqual(0, cfile.ReadChar());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî"), Encoding.UTF8)) {
                Assert.AreEqual('è', cfile.ReadChar());
                Assert.AreEqual('a', cfile.ReadChar());
                Assert.AreEqual('à', cfile.ReadChar());
                Assert.AreEqual('\n', cfile.ReadChar());
                Assert.AreEqual('ü', cfile.ReadChar());
                Assert.AreEqual('î', cfile.ReadChar());
                Assert.AreEqual(0, cfile.ReadChar());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual(232, cfile.ReadChar());
                Assert.AreEqual(97, cfile.ReadChar());
                Assert.AreEqual(224, cfile.ReadChar());
                Assert.AreEqual(10, cfile.ReadChar());
                Assert.AreEqual(252, cfile.ReadChar());
                Assert.AreEqual(238, cfile.ReadChar());
                Assert.AreEqual(0, cfile.ReadChar());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.UTF8), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual(195, cfile.ReadChar());
                Assert.AreEqual(168, cfile.ReadChar());
                Assert.AreEqual(97, cfile.ReadChar());
                Assert.AreEqual(195, cfile.ReadChar());
                Assert.AreEqual(160, cfile.ReadChar());
                Assert.AreEqual(10, cfile.ReadChar());
                Assert.AreEqual(195, cfile.ReadChar());
                Assert.AreEqual(188, cfile.ReadChar());
                Assert.AreEqual(195, cfile.ReadChar());
                Assert.AreEqual(174, cfile.ReadChar());
                Assert.AreEqual(0, cfile.ReadChar());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 195 }), Encoding.UTF8)) {
                Assert.AreEqual(65533, cfile.ReadChar());
                Assert.AreEqual(0, cfile.ReadChar());
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #40
0
        public void TestReadChars()
        {
            using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
                CollectionAssert.AreEqual(new char[] { 'Ã', '¨', 'a' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { 'Ã', ' ', '\n' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { 'Ã', '¼', 'Ã', }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { '®' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(null, cfile.ReadChars(3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")))) {
                CollectionAssert.AreEqual(new char[] { 'è', 'a', 'à' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { '\n', 'ü', 'î' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(null, cfile.ReadChars(3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî"), Encoding.UTF8)) {
                CollectionAssert.AreEqual(new char[] { 'è', 'a', 'à' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { '\n', 'ü', 'î' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(null, cfile.ReadChars(3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")), Encoding.GetEncoding("windows-1252"))) {
                CollectionAssert.AreEqual(new char[] { 'è', 'a', 'à' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { '\n', 'ü', 'î' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(null, cfile.ReadChars(3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.UTF8), Encoding.GetEncoding("windows-1252"))) {
                CollectionAssert.AreEqual(new char[] { 'Ã', '¨', 'a' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { 'Ã', ' ', '\n' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { 'Ã', '¼', 'Ã', }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(new char[] { '®' }, cfile.ReadChars(3));
                CollectionAssert.AreEqual(null, cfile.ReadChars(3));
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #41
0
        public void TestRead()
        {
            using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(168, cfile.Read());
                Assert.AreEqual(97, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(160, cfile.Read());
                Assert.AreEqual(10, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(188, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(174, cfile.Read());
                Assert.AreEqual(-1, cfile.Read());
                Assert.AreEqual(-1, cfile.Read());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")))) {
                Assert.AreEqual(232, cfile.Read());
                Assert.AreEqual(97, cfile.Read());
                Assert.AreEqual(224, cfile.Read());
                Assert.AreEqual(10, cfile.Read());
                Assert.AreEqual(252, cfile.Read());
                Assert.AreEqual(238, cfile.Read());
                Assert.AreEqual(-1, cfile.Read());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî"), Encoding.UTF8)) {
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(168, cfile.Read());
                Assert.AreEqual(97, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(160, cfile.Read());
                Assert.AreEqual(10, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(188, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(174, cfile.Read());
                Assert.AreEqual(-1, cfile.Read());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual(232, cfile.Read());
                Assert.AreEqual(97, cfile.Read());
                Assert.AreEqual(224, cfile.Read());
                Assert.AreEqual(10, cfile.Read());
                Assert.AreEqual(252, cfile.Read());
                Assert.AreEqual(238, cfile.Read());
                Assert.AreEqual(-1, cfile.Read());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.UTF8), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(168, cfile.Read());
                Assert.AreEqual(97, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(160, cfile.Read());
                Assert.AreEqual(10, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(188, cfile.Read());
                Assert.AreEqual(195, cfile.Read());
                Assert.AreEqual(174, cfile.Read());
                Assert.AreEqual(-1, cfile.Read());
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #42
0
        public void TestReadDoubles()
        {
            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                var vals = cfile.ReadDoubles(4);
                Assert.AreEqual(2, vals.Length);
                Assert.AreEqual(4.69197536052338E+271, vals[0], 1e+257);
                Assert.AreEqual(-1.50730608775746E-189, vals[1], 1e-150);
                Assert.AreEqual(null, cfile.ReadDoubles(4));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA }))) {
                var vals = cfile.ReadDoubles(4);
                Assert.AreEqual(1, vals.Length);
                Assert.AreEqual(4.69197536052338E+271, vals[0], 1e+257);
                Assert.AreEqual(null, cfile.ReadDoubles(4));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 97, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.AreEqual('a', cfile.ReadChar());
                var vals = cfile.ReadDoubles(4);
                Assert.AreEqual(2, vals.Length);
                Assert.AreEqual(4.69197536052338E+271, vals[0], 1e+257);
                Assert.AreEqual(-1.50730608775746E-189, vals[1], 1e-150);
                Assert.AreEqual(null, cfile.ReadDoubles(4));
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #43
0
        public void TestSeek()
        {
            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.AreEqual(0, cfile.Seek(4, SeekOrigin.Current));
                Assert.AreEqual(0x98BADCFE, (uint)cfile.ReadInt32());
                Assert.AreEqual(0, cfile.Seek(0, SeekOrigin.Begin));
                Assert.AreEqual((int)0x78563412, cfile.ReadInt32());
            }

            using (var cfile = new CFile(null)) {
                Assert.AreEqual(-1, cfile.Seek(4, SeekOrigin.Current));
            }
        }
Example #44
0
        public void TestReadLine()
        {
            using (var cfile = new CFile(BuildStream(""))) {
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(" "))) {
                Assert.AreEqual(" ", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n2"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual("2", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n2\r"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual("2", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n2\r3"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual("2", cfile.ReadLine());
                Assert.AreEqual("3", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n2\r3\n\r"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual("2", cfile.ReadLine());
                Assert.AreEqual("3", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n2\r3\n\r4"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual("2", cfile.ReadLine());
                Assert.AreEqual("3", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual("4", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n2\r3\n\r4\r\n"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual("2", cfile.ReadLine());
                Assert.AreEqual("3", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual("4", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n2\r3\n\r4\r\n5"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual("2", cfile.ReadLine());
                Assert.AreEqual("3", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual("4", cfile.ReadLine());
                Assert.AreEqual("5", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("1\n\n\n\r\r\r\n5"))) {
                Assert.AreEqual("1", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual("", cfile.ReadLine());
                Assert.AreEqual("5", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #45
0
        public void TestReadSBytes()
        {
            using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
                CollectionAssert.AreEqual(new sbyte[] { -61, -88, 97 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -61, -96, 10 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -61, -68, -61 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -82 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(null, cfile.ReadSBytes(3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")))) {
                CollectionAssert.AreEqual(new sbyte[] { -24, 97, -32 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { 10, -4, -18 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(null, cfile.ReadSBytes(3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî"), Encoding.UTF8)) {
                CollectionAssert.AreEqual(new sbyte[] { -61, -88, 97 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -61, -96, 10 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -61, -68, -61 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -82 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(null, cfile.ReadSBytes(3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")), Encoding.GetEncoding("windows-1252"))) {
                CollectionAssert.AreEqual(new sbyte[] { -24, 97, -32 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { 10, -4, -18 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(null, cfile.ReadSBytes(3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.UTF8), Encoding.GetEncoding("windows-1252"))) {
                CollectionAssert.AreEqual(new sbyte[] { -61, -88, 97 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -61, -96, 10 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -61, -68, -61 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(new sbyte[] { -82 }, cfile.ReadSBytes(3));
                CollectionAssert.AreEqual(null, cfile.ReadSBytes(3));
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #46
0
        public void TestReadString()
        {
            String str = null;
            using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("èa", str);

                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("à\n", str);

                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("üÃ", str);

                str = "$$$";
                Assert.AreEqual(false, cfile.ReadString(ref str, 3));
                Assert.AreEqual("®", str);

                str = "$$$";
                Assert.AreEqual(false, cfile.ReadString(ref str, 3));
                Assert.AreEqual(null, str);

                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")))) {
                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("èaà", str);

                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("\nüî", str);

                str = "$$$";
                Assert.AreEqual(false, cfile.ReadString(ref str, 3));
                Assert.AreEqual(null, str);

                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî"), Encoding.UTF8)) {
                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("èaà", str);

                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("\nüî", str);

                str = "$$$";
                Assert.AreEqual(false, cfile.ReadString(ref str, 3));
                Assert.AreEqual(null, str);

                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")), Encoding.GetEncoding("windows-1252"))) {
                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("èaà", str);

                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("\nüî", str);

                str = "$$$";
                Assert.AreEqual(false, cfile.ReadString(ref str, 3));
                Assert.AreEqual(null, str);

                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.UTF8), Encoding.GetEncoding("windows-1252"))) {
                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("èa", str);

                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("à\n", str);

                str = "$$$";
                Assert.AreEqual(true, cfile.ReadString(ref str, 3));
                Assert.AreEqual("üÃ", str);

                str = "$$$";
                Assert.AreEqual(false, cfile.ReadString(ref str, 3));
                Assert.AreEqual("®", str);

                str = "$$$";
                Assert.AreEqual(false, cfile.ReadString(ref str, 3));
                Assert.AreEqual(null, str);

                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #47
0
 public void TestReadByte()
 {
     using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
         Assert.AreEqual(195, cfile.ReadByte());
         Assert.AreEqual(168, cfile.ReadByte());
         Assert.AreEqual(97, cfile.ReadByte());
         Assert.AreEqual(195, cfile.ReadByte());
         Assert.AreEqual(160, cfile.ReadByte());
         Assert.AreEqual(10, cfile.ReadByte());
         Assert.AreEqual(195, cfile.ReadByte());
         Assert.AreEqual(188, cfile.ReadByte());
         Assert.AreEqual(195, cfile.ReadByte());
         Assert.AreEqual(174, cfile.ReadByte());
         Assert.AreEqual(0, cfile.ReadByte());
         Assert.AreEqual(0, cfile.ReadByte());
         Assert.AreEqual(true, cfile.EOF);
     }
 }
Example #48
0
        public void TestReadBytes()
        {
            byte[] buff = new byte[3];
            using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 168, 97 }, buff);
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 160, 10}, buff);
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 188, 195 }, buff);
                Assert.AreEqual(1, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 174, 188, 195 }, buff);
                Assert.AreEqual(0, cfile.Read(buff, 0, 3));
                Assert.AreEqual(0, cfile.Read(buff, 0, 3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")))) {
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 232, 97, 224 }, buff);
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 10, 252, 238 }, buff);
                Assert.AreEqual(0, cfile.Read(buff, 0, 3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî"), Encoding.UTF8)) {
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 168, 97 }, buff);
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 160, 10 }, buff);
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 188, 195 }, buff);
                Assert.AreEqual(1, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 174, 188, 195 }, buff);
                Assert.AreEqual(0, cfile.Read(buff, 0, 3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 232, 97, 224 }, buff);
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 10, 252, 238 }, buff);
                Assert.AreEqual(0, cfile.Read(buff, 0, 3));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.UTF8), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 168, 97 }, buff);
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 160, 10 }, buff);
                Assert.AreEqual(3, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 195, 188, 195 }, buff);
                Assert.AreEqual(1, cfile.Read(buff, 0, 3));
                CollectionAssert.AreEqual(new byte[] { 174, 188, 195 }, buff);
                Assert.AreEqual(0, cfile.Read(buff, 0, 3));
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #49
0
        public void TestReadInt32s()
        {
            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                var vals = cfile.ReadInt32s(4);
                Assert.AreEqual(2, vals.Length);
                Assert.AreEqual((int)0x78563412, vals[0]);
                Assert.AreEqual(0x98BADCFE, (uint)vals[1]);
                Assert.AreEqual(null, cfile.ReadInt32s(4));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA }))) {
                var vals = cfile.ReadInt32s(4);
                Assert.AreEqual(1, vals.Length);
                Assert.AreEqual((int)0x78563412, vals[0]);
                Assert.AreEqual(null, cfile.ReadInt32s(4));
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 97, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.AreEqual('a', cfile.ReadChar());
                var vals = cfile.ReadInt32s(4);
                Assert.AreEqual(2, vals.Length);
                Assert.AreEqual((int)0x78563412, vals[0]);
                Assert.AreEqual(0x98BADCFE, (uint)vals[1]);
                Assert.AreEqual(null, cfile.ReadInt32s(4));
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #50
0
        public void TestReadLineEncoded()
        {
            using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
                Assert.AreEqual("èaà", cfile.ReadLine());
                Assert.AreEqual("üî", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")))) {
                Assert.AreEqual("èaà", cfile.ReadLine());
                Assert.AreEqual("üî", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî"), Encoding.UTF8)) {
                Assert.AreEqual("èaà", cfile.ReadLine());
                Assert.AreEqual("üî", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual("èaà", cfile.ReadLine());
                Assert.AreEqual("üî", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.UTF8), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual("èaà", cfile.ReadLine());
                Assert.AreEqual("üî", cfile.ReadLine());
                Assert.AreEqual(null, cfile.ReadLine());
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #51
0
        public void TestReadUInt32()
        {
            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.AreEqual((uint)0x78563412, cfile.ReadUInt32());
                Assert.AreEqual(0x98BADCFE, cfile.ReadUInt32());
                Assert.AreEqual((uint)0, cfile.ReadUInt32());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA }))) {
                Assert.AreEqual((uint)0x78563412, cfile.ReadUInt32());
                Assert.AreEqual((uint)0, cfile.ReadUInt32());
                Assert.AreEqual((uint)0, cfile.ReadUInt32());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 97, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.AreEqual('a', cfile.ReadChar());
                Assert.AreEqual((uint)0x78563412, cfile.ReadUInt32());
                Assert.AreEqual(0x98BADCFE, cfile.ReadUInt32());
                Assert.AreEqual((uint)0, cfile.ReadUInt32());
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #52
0
        public void TestReadDouble()
        {
            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.AreEqual(4.69197536052338E+271, cfile.ReadDouble(), 1e+257);
                Assert.AreEqual(-1.50730608775746E-189, cfile.ReadDouble(), 1e-150);
                Assert.AreEqual(0, cfile.ReadDouble());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA}))) {
                Assert.AreEqual(4.69197536052338E+271, cfile.ReadDouble(), 1e+257);
                Assert.AreEqual(0, cfile.ReadDouble());
                Assert.AreEqual(0, cfile.ReadDouble());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] {97,  0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0xFE, 0xDC, 0xBA, 0x98, 0xFE, 0xDC, 0xBA, 0x98 }))) {
                Assert.AreEqual('a', cfile.ReadChar());
                Assert.AreEqual(4.69197536052338E+271, cfile.ReadDouble(), 1e+257);
                Assert.AreEqual(-1.50730608775746E-189, cfile.ReadDouble(), 1e-150);
                Assert.AreEqual(0, cfile.ReadInt32());
                Assert.AreEqual(true, cfile.EOF);
            }
        }
Example #53
0
        public void TestReadSByte()
        {
            using (var cfile = new CFile(BuildStream("èaà\nüî"))) {
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-88, cfile.ReadSByte());
                Assert.AreEqual(97, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-96, cfile.ReadSByte());
                Assert.AreEqual(10, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-68, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-82, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")))) {
                Assert.AreEqual(-24, cfile.ReadSByte());
                Assert.AreEqual(97, cfile.ReadSByte());
                Assert.AreEqual(-32, cfile.ReadSByte());
                Assert.AreEqual(10, cfile.ReadSByte());
                Assert.AreEqual(-4, cfile.ReadSByte());
                Assert.AreEqual(-18, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî"), Encoding.UTF8)) {
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-88, cfile.ReadSByte());
                Assert.AreEqual(97, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-96, cfile.ReadSByte());
                Assert.AreEqual(10, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-68, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-82, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.GetEncoding("windows-1252")), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual(-24, cfile.ReadSByte());
                Assert.AreEqual(97, cfile.ReadSByte());
                Assert.AreEqual(-32, cfile.ReadSByte());
                Assert.AreEqual(10, cfile.ReadSByte());
                Assert.AreEqual(-4, cfile.ReadSByte());
                Assert.AreEqual(-18, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream("èaà\nüî", Encoding.UTF8), Encoding.GetEncoding("windows-1252"))) {
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-88, cfile.ReadSByte());
                Assert.AreEqual(97, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-96, cfile.ReadSByte());
                Assert.AreEqual(10, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-68, cfile.ReadSByte());
                Assert.AreEqual(-61, cfile.ReadSByte());
                Assert.AreEqual(-82, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(true, cfile.EOF);
            }

            using (var cfile = new CFile(BuildStream(new byte[] { 0, 0x01, 0x10, 0x80, 0xF0, 0xFF }))) {
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(1, cfile.ReadSByte());
                Assert.AreEqual(16, cfile.ReadSByte());
                Assert.AreEqual(-128, cfile.ReadSByte());
                Assert.AreEqual(-16, cfile.ReadSByte());
                Assert.AreEqual(-1, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(0, cfile.ReadSByte());
                Assert.AreEqual(true, cfile.EOF);
            }
        }