public static void FormatPeek(this StringBuilder sb, string indent, PriorityQueueState qs)
        {
            CacheItem item = qs.Peek();

            sb.Append(indent);
            var ti = new CacheItemPriorityQueueTestItem()
            {
                Operation      = QueueOperation.Peek,
                QueueCount     = qs.Queue.Count,
                OperationCount = qs.PeekCount
            };

            if (item != null)
            {
                ti.Guid       = item.Guid.ToString();
                ti.IsDisabled = item.Disabled;
            }
            else
            {
                ti.IsNull = true;
            }

            sb.AppendFormat("\"{0}\",", ti.Serialize());
            sb.AppendLine();

            qs.PeekCount++;
        }
Beispiel #2
0
        public static void FormatDisableItem(this StreamWriter sw, PriorityQueueState qs, List <CacheItem> list, int index)
        {
            CacheItem item = list [index];
            var       ti   = new CacheItemPriorityQueueTestItem()
            {
                Operation          = QueueOperation.Disable,
                QueueCount         = qs.Queue.Count,
                ListIndex          = index,
                PriorityQueueIndex = item.PriorityQueueIndex,
                OperationCount     = qs.DisableCount
            };

            if (item == null)
            {
                ti.IsNull = true;
            }
            else
            {
                ti.Guid       = item.Guid.ToString();
                ti.IsDisabled = item.Disabled;
                ti.Disable    = true;
            }
            sw.WriteLine(ti.Serialize());
            item.Disabled = true;
            qs.DisableCount++;
        }
        public static void FormatDisableItem(this StringBuilder sb, string indent, PriorityQueueState qs, List <CacheItem> list, int index)
        {
            CacheItem item = list [index];

            sb.Append(indent);

            var ti = new CacheItemPriorityQueueTestItem()
            {
                Operation  = QueueOperation.Disable,
                QueueCount = qs.Queue.Count,
                ListIndex  = index
            };

            if (item == null)
            {
                ti.IsNull = true;
            }
            else
            {
                ti.Guid       = item.Guid.ToString();
                ti.IsDisabled = item.Disabled;
                ti.Disable    = true;
            }
            sb.AppendFormat("\"{0}\",", ti.Serialize());
            sb.AppendLine();

            item.Disabled = true;

            qs.DisableCount++;
        }
Beispiel #4
0
		static void RunSequence (StringBuilder sb, string initialIndent, string dataDir, string file, int seqNum)
		{
			Dictionary <Guid, int> cacheIndex;
			List <CacheItem> cacheItems;
			List <EDSequenceEntry> edSequence;

			LoadEDSequence (file, out cacheIndex, out cacheItems, out edSequence);

			if (edSequence == null || edSequence.Count == 0)
				return;


			string listName = String.Format ("Sequence_{0:00000}.list", seqNum);
			string testsName = String.Format ("Sequence_{0:00000}.tests", seqNum);
			using (var sw = new StreamWriter (Path.Combine (dataDir, listName), false, Encoding.UTF8))
				sw.FormatList (cacheItems);
			
			string indent = initialIndent + "\t";
			int idx;
			var pq = new PriorityQueueState ();
			using (var sw = new StreamWriter (Path.Combine (dataDir, testsName), false, Encoding.UTF8)) {
				foreach (EDSequenceEntry entry in edSequence) {
					idx = cacheIndex [entry.Item.Guid];

					switch (entry.Type) {
						case EDSequenceEntryType.Enqueue:
							sw.FormatEnqueue (pq, cacheItems, idx);
							break;

						case EDSequenceEntryType.Dequeue:
							sw.FormatDequeue (pq);
							break;

						case EDSequenceEntryType.Disable:
							sw.FormatDisableItem (pq, cacheItems, idx);
							break;

						case EDSequenceEntryType.Peek:
							sw.FormatPeek (pq);
							break;

						case EDSequenceEntryType.Update:
							sw.FormatUpdate (pq, cacheItems, entry.Item, idx);
							break;
					}
				}

				sw.FormatQueueSize (pq);

				while (pq.Queue.Count > 0)
					sw.FormatDequeue (pq);
			}			
			
			sb.SequenceMethodStart (initialIndent, file, seqNum);
 			sb.AppendFormat ("{0}RunTest (\"{1}\", \"{2}\");", indent, testsName, listName);
			sb.AppendLine ();
			
			sb.SequenceMethodEnd (initialIndent);
		}
Beispiel #5
0
		static void RunSequence (StringBuilder sb, string initialIndent, string file, int seqNum)
		{
			Dictionary <Guid, int> cacheIndex;
			List <CacheItem> cacheItems;
			List <EDSequenceEntry> edSequence;

			LoadEDSequence (file, out cacheIndex, out cacheItems, out edSequence);

			if (edSequence == null || edSequence.Count == 0)
				return;


			string listName = String.Format ("list_{0:00000}", seqNum);
			string testsName = String.Format ("tests_{0:00000}", seqNum);
			sb.AppendLine ();
			sb.FormatList (initialIndent, listName, cacheItems);

			sb.AppendLine ();
			sb.AppendFormat ("{0} string[] {1} = {{\n", initialIndent, testsName);

			string indent = initialIndent + "\t";
			int idx;
			var pq = new PriorityQueueState (listName, testsName);
			foreach (EDSequenceEntry entry in edSequence) {
				idx = cacheIndex [entry.Item.Guid];

				switch (entry.Type) {
					case EDSequenceEntryType.Enqueue:
						sb.FormatEnqueue (indent, pq, cacheItems, idx);
						break;

					case EDSequenceEntryType.Dequeue:
						sb.FormatDequeue (indent, pq);
						break;

					case EDSequenceEntryType.Disable:
						sb.FormatDisableItem (indent, pq, cacheItems, idx);
						break;

					case EDSequenceEntryType.Peek:
						sb.FormatPeek (indent, pq);
						break;
				}
			}

			sb.FormatQueueSize (indent, pq);

			while (pq.Queue.Count > 0)
				sb.FormatDequeue (indent, pq);
			sb.AppendFormat ("{0}}};", initialIndent);
			sb.AppendLine ();
			
			sb.SequenceMethodStart (initialIndent, file, seqNum);
 			sb.AppendFormat ("{0}RunTest ({1}, {2});", indent, testsName, listName);
			sb.AppendLine ();
			
			sb.SequenceMethodEnd (initialIndent);
		}
Beispiel #6
0
        public static void FormatQueueSize(this StreamWriter sw, PriorityQueueState qs)
        {
            var ti = new CacheItemPriorityQueueTestItem()
            {
                Operation  = QueueOperation.QueueSize,
                QueueCount = qs.Queue.Count
            };

            sw.WriteLine(ti.Serialize());
        }
        public static void FormatQueueSize(this StringBuilder sb, string indent, PriorityQueueState qs)
        {
            sb.Append(indent);
            var ti = new CacheItemPriorityQueueTestItem()
            {
                Operation  = QueueOperation.QueueSize,
                QueueCount = qs.Queue.Count
            };

            sb.AppendFormat("\"{0}\",", ti.Serialize());
            sb.AppendLine();
        }
Beispiel #8
0
		static void RunSequence (StringBuilder sb, string initialIndent, string file, int seqNum)
		{
			Dictionary <Guid, int> cacheIndex;
			List <CacheItem> cacheItems;
			List <EDSequenceEntry> edSequence;

			LoadEDSequence (file, out cacheIndex, out cacheItems, out edSequence);

			if (edSequence == null || edSequence.Count == 0)
				return;

			string indent = initialIndent + "\t";
			sb.SequenceMethodStart (initialIndent, file, seqNum);
			sb.FormatList (indent, "list", cacheItems);
			sb.Append (indent + "var queue = new CacheItemPriorityQueue ();\n");
			sb.Append (indent + "CacheItem item;\n\n");
			
			int idx;
			var pq = new PriorityQueueState ("list", "queue", "item");
			foreach (EDSequenceEntry entry in edSequence) {
				idx = cacheIndex [entry.Item.Guid];

				switch (entry.Type) {
					case EDSequenceEntryType.Enqueue:
						sb.FormatEnqueue (indent, pq, cacheItems, idx);
						break;

					case EDSequenceEntryType.Dequeue:
						sb.FormatDequeue (indent, pq);
						break;

					case EDSequenceEntryType.Disable:
						sb.FormatDisableItem (indent, pq, cacheItems, idx);
						break;

					case EDSequenceEntryType.Peek:
						sb.FormatPeek (indent, pq);
						break;
				}
			}

			sb.FormatQueueSize (indent, pq);

			while (pq.Queue.Count > 0)
				sb.FormatDequeue (indent, pq);
			
			sb.SequenceMethodEnd (initialIndent);
		}
        public static void FormatEnqueue(this StringBuilder sb, string indent, PriorityQueueState qs, List <CacheItem> list, int index)
        {
            qs.Enqueue(list [index]);
            sb.Append(indent);

            var ti = new CacheItemPriorityQueueTestItem()
            {
                Operation      = QueueOperation.Enqueue,
                QueueCount     = qs.Queue.Count,
                ListIndex      = index,
                Guid           = qs.Peek().Guid.ToString(),
                OperationCount = qs.EnqueueCount
            };

            sb.AppendFormat("\"{0}\",", ti.Serialize());
            sb.AppendLine();

            qs.EnqueueCount++;
        }
Beispiel #10
0
        public static void FormatEnqueue(this StreamWriter sw, PriorityQueueState qs, List <CacheItem> list, int index)
        {
            CacheItem item = list [index];

            qs.Enqueue(item);

            var ti = new CacheItemPriorityQueueTestItem()
            {
                Operation          = QueueOperation.Enqueue,
                QueueCount         = qs.Queue.Count,
                ListIndex          = index,
                Guid               = qs.Peek().Guid.ToString(),
                OperationCount     = qs.EnqueueCount,
                PriorityQueueIndex = item.PriorityQueueIndex
            };

            sw.WriteLine(ti.Serialize());
            qs.EnqueueCount++;
        }
Beispiel #11
0
        static int FindQueueIndex(PriorityQueueState qs, CacheItem item)
        {
            CacheItem ci;

            for (int i = 0; i < qs.Queue.Count; i++)
            {
                ci = ((IList)qs.Queue) [i] as CacheItem;
                if (ci == null)
                {
                    continue;
                }

                if (ci.Guid == item.Guid)
                {
                    return(i);
                }
            }

            throw new ApplicationException(String.Format("Failed to find CacheItem with UUID {0} in the queue.", item.Guid));
        }
Beispiel #12
0
        public static void FormatUpdate(this StreamWriter sw, PriorityQueueState qs, List <CacheItem> list, CacheItem updatedItem, int index)
        {
            CacheItem item = list [index];

            item.ExpiresAt = updatedItem.ExpiresAt;
            int qidx = FindQueueIndex(qs, item);

            qs.Update(qidx);

            var ti = new CacheItemPriorityQueueTestItem()
            {
                Operation          = QueueOperation.Update,
                QueueCount         = qs.Queue.Count,
                OperationCount     = qs.UpdateCount,
                ListIndex          = index,
                ExpiresAt          = updatedItem.ExpiresAt,
                PriorityQueueIndex = FindQueueIndex(qs, item),
                Guid = updatedItem.Guid != null?updatedItem.Guid.ToString() : null
            };

            sw.WriteLine(ti.Serialize());
            qs.UpdateCount++;
        }
Beispiel #13
0
        public static void FormatPeek(this StreamWriter sw, PriorityQueueState qs)
        {
            CacheItem item = qs.Peek();
            var       ti   = new CacheItemPriorityQueueTestItem()
            {
                Operation          = QueueOperation.Peek,
                QueueCount         = qs.Queue.Count,
                OperationCount     = qs.PeekCount,
                PriorityQueueIndex = item.PriorityQueueIndex
            };

            if (item != null)
            {
                ti.Guid       = item.Guid.ToString();
                ti.IsDisabled = item.Disabled;
            }
            else
            {
                ti.IsNull = true;
            }

            sw.WriteLine(ti.Serialize());
            qs.PeekCount++;
        }
Beispiel #14
0
        static void RunSequence(StringBuilder sb, string initialIndent, string dataDir, string file, int seqNum)
        {
            Dictionary <Guid, int> cacheIndex;
            List <CacheItem>       cacheItems;
            List <EDSequenceEntry> edSequence;

            LoadEDSequence(file, out cacheIndex, out cacheItems, out edSequence);

            if (edSequence == null || edSequence.Count == 0)
            {
                return;
            }


            string listName  = String.Format("Sequence_{0:00000}.list", seqNum);
            string testsName = String.Format("Sequence_{0:00000}.tests", seqNum);

            using (var sw = new StreamWriter(Path.Combine(dataDir, listName), false, Encoding.UTF8))
                sw.FormatList(cacheItems);

            string indent = initialIndent + "\t";
            int    idx;
            var    pq = new PriorityQueueState();

            using (var sw = new StreamWriter(Path.Combine(dataDir, testsName), false, Encoding.UTF8)) {
                foreach (EDSequenceEntry entry in edSequence)
                {
                    idx = cacheIndex [entry.Item.Guid];

                    switch (entry.Type)
                    {
                    case EDSequenceEntryType.Enqueue:
                        sw.FormatEnqueue(pq, cacheItems, idx);
                        break;

                    case EDSequenceEntryType.Dequeue:
                        sw.FormatDequeue(pq);
                        break;

                    case EDSequenceEntryType.Disable:
                        sw.FormatDisableItem(pq, cacheItems, idx);
                        break;

                    case EDSequenceEntryType.Peek:
                        sw.FormatPeek(pq);
                        break;

                    case EDSequenceEntryType.Update:
                        sw.FormatUpdate(pq, cacheItems, entry.Item, idx);
                        break;
                    }
                }

                sw.FormatQueueSize(pq);

                while (pq.Queue.Count > 0)
                {
                    sw.FormatDequeue(pq);
                }
            }

            sb.SequenceMethodStart(initialIndent, file, seqNum);
            sb.AppendFormat("{0}RunTest (\"{1}\", \"{2}\");", indent, testsName, listName);
            sb.AppendLine();

            sb.SequenceMethodEnd(initialIndent);
        }
        static void RunSequence(StringBuilder sb, string initialIndent, string file, int seqNum)
        {
            Dictionary <Guid, int> cacheIndex;
            List <CacheItem>       cacheItems;
            List <EDSequenceEntry> edSequence;

            LoadEDSequence(file, out cacheIndex, out cacheItems, out edSequence);

            if (edSequence == null || edSequence.Count == 0)
            {
                return;
            }


            string listName  = String.Format("list_{0:00000}", seqNum);
            string testsName = String.Format("tests_{0:00000}", seqNum);

            sb.AppendLine();
            sb.FormatList(initialIndent, listName, cacheItems);

            sb.AppendLine();
            sb.AppendFormat("{0} string[] {1} = {{\n", initialIndent, testsName);

            string indent = initialIndent + "\t";
            int    idx;
            var    pq = new PriorityQueueState(listName, testsName);

            foreach (EDSequenceEntry entry in edSequence)
            {
                idx = cacheIndex [entry.Item.Guid];

                switch (entry.Type)
                {
                case EDSequenceEntryType.Enqueue:
                    sb.FormatEnqueue(indent, pq, cacheItems, idx);
                    break;

                case EDSequenceEntryType.Dequeue:
                    sb.FormatDequeue(indent, pq);
                    break;

                case EDSequenceEntryType.Disable:
                    sb.FormatDisableItem(indent, pq, cacheItems, idx);
                    break;

                case EDSequenceEntryType.Peek:
                    sb.FormatPeek(indent, pq);
                    break;
                }
            }

            sb.FormatQueueSize(indent, pq);

            while (pq.Queue.Count > 0)
            {
                sb.FormatDequeue(indent, pq);
            }
            sb.AppendFormat("{0}}};", initialIndent);
            sb.AppendLine();

            sb.SequenceMethodStart(initialIndent, file, seqNum);
            sb.AppendFormat("{0}RunTest ({1}, {2});", indent, testsName, listName);
            sb.AppendLine();

            sb.SequenceMethodEnd(initialIndent);
        }