internal void Debug_DuplicateSerieURL(Serie a_serie)
        {
            var sd = new SerieData();

            sd.Seed  = m_random.Next();
            sd.Title = ">>> duplicated name serie " + a_serie.Title;
            sd.URL   = a_serie.URL;

            var serie = m_series.First(s => s.Title == a_serie.Title);

            m_series.Insert(m_series.IndexOf(serie) + 1, sd);
        }
        internal void Debug_DuplicateChapterURL(Chapter a_chapter)
        {
            SerieData serie_data = m_series.First(sd => sd.Title == a_chapter.Serie.Title);

            var cd = new ChapterData();

            cd.Seed  = m_random.Next();
            cd.Title = ">>> duplicated name chapter " + a_chapter.Title;
            cd.URL   = a_chapter.URL;

            var chapter = serie_data.Chapters.First(s => s.Title == a_chapter.Title);

            serie_data.Chapters.Insert(serie_data.Chapters.IndexOf(chapter) + 1, cd);
        }
Example #3
0
        internal void Debug_DuplicateSerieURL(Serie a_serie)
        {
            var sd = new SerieData
            {
                Seed = m_random.Next(),
                Title = ">>> duplicated name serie " + a_serie.Title,
                URL = a_serie.URL
            };

            var serie = m_series.First(s => s.Title == a_serie.Title);
            m_series.Insert(m_series.IndexOf(serie) + 1, sd);
        }
Example #4
0
        public void Debug_InsertSerie(int a_index)
        {
            var sd = new SerieData {Seed = m_random.Next()};
            sd.SetTitleURL(">>> added serie " + m_random.Next());

            m_series.Insert(a_index, sd);
        }
Example #5
0
        public TestServerCrawler(string a_name, int a_max_server_delay, 
            bool a_slow_series, bool a_slow_chapters, bool a_empty, int a_max_con)
        {
            m_name = a_name;
            m_seed = a_name.GetHashCode();
            var random = new Random(m_seed);
            m_slow_series = a_slow_series;
            m_slow_chapters = a_slow_chapters;

            if (a_max_server_delay != 0)
                Debug.Assert(a_max_server_delay > MIN_SERVER_DELAY);
            m_max_server_delay = a_max_server_delay;

            m_items_per_page = random.Next(4, 9) * 5;
            m_max_con = a_max_con;

            var maxs = (int)Math.Pow(random.Next(10, 70), 2);

            if (Name.Contains("error series few"))
                maxs = 3456;

            for (var s = 1; s <= maxs; s++)
            {
                var serie = new SerieData();
                serie.SetTitleURL(a_name + " - Serie" + s.ToString());
                serie.Seed = random.Next();
                m_series.Add(serie);
            }

            {
                var serie = new SerieData();
                serie.SetTitleURL(a_name + " - empty chapters");
                m_series.Add(serie);
            }

            {
                var serie = new SerieData();
                serie.SetTitleURL(a_name + " - error chapters none");
                serie.Seed = random.Next();
                m_series.Add(serie);
            }

            {
                var serie = new SerieData();
                serie.SetTitleURL(a_name + " - error chapters few");
                serie.Seed = random.Next();
                m_series.Add(serie);
            }

            {
                var serie = new SerieData();
                serie.SetTitleURL(a_name + " - few chapters");
                serie.Seed = random.Next();
                m_series.Add(serie);
            }

            if (Name.Contains("error series none"))
                m_series.Clear();

            if (a_empty)
                m_series.Clear();
        }
 /// <summary>
 /// 从json中导入数据
 /// </summary>
 /// <param name="jsonData"></param>
 private static bool ParseJsonData(Serie serie, string jsonData)
 {
     if (!CheckJsonData(ref jsonData))
     {
         return(false);
     }
     serie.ClearData();
     if (jsonData.IndexOf("],") > -1 || jsonData.IndexOf("] ,") > -1)
     {
         string[] datas = jsonData.Split(new string[] { "],", "] ," }, StringSplitOptions.RemoveEmptyEntries);
         for (int i = 0; i < datas.Length; i++)
         {
             var    data      = datas[i].Replace("[", "").Replace("]", "").Split(new char[] { '[', ',' }, StringSplitOptions.RemoveEmptyEntries);
             var    serieData = new SerieData();
             double value     = 0;
             if (data.Length == 2 && !double.TryParse(data[0], out value))
             {
                 double.TryParse(data[1], out value);
                 serieData.data = new List <double>()
                 {
                     i, value
                 };
                 serieData.name = data[0].Replace("\"", "").Trim();
             }
             else
             {
                 for (int j = 0; j < data.Length; j++)
                 {
                     var txt  = data[j].Trim().Replace("]", "");
                     var flag = double.TryParse(txt, out value);
                     if (flag)
                     {
                         serieData.data.Add(value);
                     }
                     else
                     {
                         serieData.name = txt.Replace("\"", "").Trim();
                     }
                 }
             }
             serie.AddSerieData(serieData);
         }
     }
     else if (jsonData.IndexOf("value") > -1 && jsonData.IndexOf("name") > -1)
     {
         string[] datas = jsonData.Split(new string[] { "},", "} ,", "}" }, StringSplitOptions.RemoveEmptyEntries);
         for (int i = 0; i < datas.Length; i++)
         {
             var arr       = datas[i].Replace("{", "").Split(',');
             var serieData = new SerieData();
             foreach (var a in arr)
             {
                 if (a.StartsWith("value:"))
                 {
                     double value = double.Parse(a.Substring(6, a.Length - 6));
                     serieData.data = new List <double>()
                     {
                         i, value
                     };
                 }
                 else if (a.StartsWith("name:"))
                 {
                     string name = a.Substring(6, a.Length - 6 - 1);
                     serieData.name = name;
                 }
                 else if (a.StartsWith("selected:"))
                 {
                     string selected = a.Substring(9, a.Length - 9);
                     serieData.selected = bool.Parse(selected);
                 }
             }
             serie.AddSerieData(serieData);
         }
     }
     else
     {
         string[] datas = jsonData.Split(',');
         for (int i = 0; i < datas.Length; i++)
         {
             double value;
             var    flag = double.TryParse(datas[i].Trim(), out value);
             if (flag)
             {
                 var serieData = new SerieData();
                 serieData.data = new List <double>()
                 {
                     i, value
                 };
                 serie.AddSerieData(serieData);
             }
         }
     }
     serie.SetAllDirty();
     return(true);
 }
        public void Debug_DuplicateSerieName(Serie a_serie)
        {
            var sd = new SerieData();
            sd.Seed = m_random.Next();
            sd.Title = a_serie.Title;
            sd.URL = ">>> duplicated name serie " + a_serie.URL;

            var serie = m_series.First(s => s.Title == a_serie.Title);
            m_series.Insert(m_series.IndexOf(serie) + 1, sd);
        }
        public void Debug_RenameSerie(Serie a_serie)
        {
            SerieData serie_data = m_series.First(sd => sd.Title == a_serie.Title);

            serie_data.Title += " " + m_random.Next();
        }
        public void Debug_ChangeSerieURL(Serie a_serie)
        {
            SerieData serie_data = m_series.First(sd => sd.Title == a_serie.Title);

            serie_data.URL += " " + m_random.Next();
        }
        public void Debug_RemoveChapter(Chapter a_chapter)
        {
            SerieData serie_data = m_series.First(sd => sd.Title == a_chapter.Serie.Title);

            serie_data.Chapters.RemoveAll(cd => cd.Title == a_chapter.Title);
        }
        public TestServerCrawler(string a_name, int a_max_server_delay,
                                 bool a_slow_series, bool a_slow_chapters, bool a_empty, int a_max_con)
        {
            m_name = a_name;
            m_seed = a_name.GetHashCode();
            Random random = new Random(m_seed);

            m_slow_series   = a_slow_series;
            m_slow_chapters = a_slow_chapters;

            if (a_max_server_delay != 0)
            {
                Debug.Assert(a_max_server_delay > MIN_SERVER_DELAY);
            }
            m_max_server_delay = a_max_server_delay;

            m_items_per_page = random.Next(4, 9) * 5;
            m_max_con        = a_max_con;

            int maxs = (int)Math.Pow(random.Next(10, 70), 2);

            if (Name.Contains("error series few"))
            {
                maxs = 3456;
            }

            for (int s = 1; s <= maxs; s++)
            {
                SerieData serie = new SerieData();
                serie.SetTitleURL(a_name + " - Serie" + s.ToString());
                serie.Seed = random.Next();
                m_series.Add(serie);
            }

            {
                SerieData serie = new SerieData();
                serie.SetTitleURL(a_name + " - empty chapters");
                m_series.Add(serie);
            }

            {
                SerieData serie = new SerieData();
                serie.SetTitleURL(a_name + " - error chapters none");
                serie.Seed = random.Next();
                m_series.Add(serie);
            }

            {
                SerieData serie = new SerieData();
                serie.SetTitleURL(a_name + " - error chapters few");
                serie.Seed = random.Next();
                m_series.Add(serie);
            }

            {
                SerieData serie = new SerieData();
                serie.SetTitleURL(a_name + " - few chapters");
                serie.Seed = random.Next();
                m_series.Add(serie);
            }

            if (Name.Contains("error series none"))
            {
                m_series.Clear();
            }

            if (a_empty)
            {
                m_series.Clear();
            }
        }
Example #12
0
 public static void Release(SerieData toRelease)
 {
     s_ListPool.Release(toRelease);
 }
Example #13
0
 static void OnClear(SerieData serieData)
 {
     serieData.Clear();
 }
Example #14
0
 static void OnGet(SerieData serieData)
 {
 }