Esempio n. 1
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);
        }
Esempio n. 2
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);
		}
Esempio n. 3
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);
		}
        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);
        }
Esempio n. 5
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);
		}