File: TestID.cs

package info (click to toggle)
mono 4.6.2.7+dfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 778,148 kB
  • ctags: 914,052
  • sloc: cs: 5,779,509; xml: 2,773,713; ansic: 432,645; sh: 14,749; makefile: 12,361; perl: 2,488; python: 1,434; cpp: 849; asm: 531; sql: 95; sed: 16; php: 1
file content (144 lines) | stat: -rw-r--r-- 3,584 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
// ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;

namespace NUnit.Core
{
	/// <summary>
	/// TestID encapsulates a unique identifier for tests. As
	/// currently implemented, this is an integer and is unique
	/// within the AppDomain. TestID is one component of a 
	/// TestName. We use this object, rather than a raw int,
	/// for two reasons: (1) to hide the implementation so
	/// it may be changed later if necessary and (2) so that the
	/// id may be null in a "weak" TestName.
	/// </summary>
	[Serializable]
	public class TestID : ICloneable
	{
		#region Fields
			/// <summary>
			/// The int key that distinguishes this test from all others created
			/// by the same runner.
			/// </summary>
			private int id;
		
		/// <summary>
		/// Static value to seed ids. It's started at 1000 so any
		/// uninitialized ids will stand out.
		/// </summary>
		private static int nextID = 1000;

		#endregion

		#region Construction
		/// <summary>
		/// Construct a new TestID
		/// </summary>
		public TestID()
		{
			this.id = unchecked( nextID++ );
		}

		/// <summary>
		/// Construct a TestID with a given value.
		/// Used in parsing test names and in order
		/// to construct an artificial test node for
		/// aggregating multiple test runners.
		/// </summary>
		/// <param name="id"></param>
		public TestID( int id )
		{
			this.id = id;
		}
		#endregion

		#region Static Methods
		/// <summary>
		/// Parse a TestID from it's string representation
		/// </summary>
		/// <param name="s"></param>
		/// <returns></returns>
		public static TestID Parse( string s )
		{
			int id = Int32.Parse( s );
			return new TestID( id );
		}
		#endregion

		#region Object Overrides
		/// <summary>
		/// Override of Equals method to allow comparison of TestIDs
		/// </summary>
		/// <param name="obj"></param>
		/// <returns></returns>
		public override bool Equals(object obj)
		{
			TestID other = obj as TestID;
			if ( other != null )
				return this.id == other.id;

			return base.Equals (obj);
		}

		/// <summary>
		/// Override of GetHashCode for TestIDs
		/// </summary>
		/// <returns></returns>
		public override int GetHashCode()
		{
			return id.GetHashCode();
		}

		/// <summary>
		/// Override ToString() to display the int id
		/// </summary>
		/// <returns></returns>
		public override string ToString()
		{
			return id.ToString();
		}
		#endregion

		#region Operator Overrides
        /// <summary>
        /// Operator == override
        /// </summary>
        /// <param name="id1"></param>
        /// <param name="id2"></param>
        /// <returns></returns>
		public static bool operator ==( TestID id1, TestID id2 )
		{
			if ( Object.Equals( id1, null ) )
				return Object.Equals( id2, null );

			return id1.Equals( id2 );
		}

        /// <summary>
        /// Operator != override
        /// </summary>
        /// <param name="id1"></param>
        /// <param name="id2"></param>
        /// <returns></returns>
		public static bool operator !=( TestID id1, TestID id2 )
		{
			return id1 == id2 ? false : true;
		}
		#endregion

		#region ICloneable Implementation
        /// <summary>
        /// Clone this TestID
        /// </summary>
        /// <returns>An identical TestID</returns>
		public object Clone()
		{
			return this.MemberwiseClone();
		}
		#endregion
	}
}