C# Version.Equals方法代码示例

    public bool PosTest2()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest2: Ensure Equals(System.Object) return false when the current Version object and obj are both Version objects but not every component of the current Version object matches the corresponding component of obj.");

        try
        {
            Version TestVersion1 = new Version("2.3.4.5");
			Object TestObject1 = (Object)TestVersion1; 
			Version TestVersion2 = new Version("1.2.3.4");
			if (TestVersion2.Equals(TestObject1))
            {
                TestLibrary.TestFramework.LogError("P02.1", "Equals(System.Object) failed when the current Version object and obj are both Version objects but not every component of the current Version object matches the corresponding component of obj!");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P02.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

		private static void CheckPersistentStoreStatus(Version databaseVersion, Version assemblyVersion)
		{
			if (databaseVersion.Equals(assemblyVersion))
			{
				Console.WriteLine("The database is up-to-date.");
				Environment.ExitCode = 0;
				return;
			}

			var ep = new PersistentStoreUpgradeScriptExtensionPoint();
			var extensions = ep.CreateExtensions();

			var found = false;
			foreach (IPersistentStoreUpgradeScript script in extensions)
			{
				if (script.SourceVersion.Equals(databaseVersion))
				{
					found = true;
					break;
				}
			}

			if (found)
			{
				Console.WriteLine("The database must be upgraded from {0} to {1}", databaseVersion.ToString(4),
								  assemblyVersion.ToString(4));
				Environment.ExitCode = 1;
			}
			else
			{
				Console.WriteLine("An unsupported version ({0}) is installed which cannot be upgraded from", databaseVersion.ToString(4));
				Environment.ExitCode = -1;
			}
		}

        public void ConvertToTestCommandReturnsCorrectResult()
        {
            var verified = false;
            var input = new Version(1, 1);
            Action<Version> expected = v => verified = input.Equals(v);
            var sut = new TestCase<Version>(expected);

            ITestCommand actual = sut.ConvertToTestCommand(dummyMethod);

            var fcc = Assert.IsAssignableFrom<FirstClassCommand>(actual);
            fcc.TestAction(input);
            Assert.True(
                verified,
                "Invoking TestAction on the resulting FirstClassCommand should indirectly indicate that the original test command was invoked.");
        }

    public bool PosTest2()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest2: Ensure Equals(System.Version) return false when not every component of the current Version object matches the corresponding component of the obj parameter.");

        try
        {
            Version TestVersion1 = new Version("2.3.4.5");
            Version TestVersion2 = new Version("2.3.4.6");
            if (TestVersion2.Equals(TestVersion1))
            {
                TestLibrary.TestFramework.LogError("P02.1", "Equals(System.Version) failed when not every component of the current Version object matches the corresponding component of the obj parameter!");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P02.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    public bool PosTest4()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest4: Ensure Equals(System.Object) return false when obj is a null reference.");

        try
        {
            Version TestVersion2 = new Version("2.3.4.8");
            if (TestVersion2.Equals(null))
            {
                TestLibrary.TestFramework.LogError("P04.1", "Equals(System.Object) failed when obj is a null reference!");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P04.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

		public void TestClone () 
		{
			Version v1 = new Version (1, 2, 3, 4);
			Version v2 = (Version) v1.Clone ();

			Assert.IsTrue (v1.Equals (v2), "#A1");
			Assert.IsFalse (object.ReferenceEquals (v1, v2), "#A2");

			Version v3 = new Version (); // 0.0
			v2 = (Version) v3.Clone ();

			Assert.IsTrue (v3.Equals (v2), "#B1");
			Assert.IsFalse (object.ReferenceEquals (v3, v2), "#B2");
		}

        public static void TestEqualsGetHashCode(Assert assert)
        {
            assert.Expect(9);

            var v1 = new Version(100, 200, 300, (400 << 16) + 500);
            var v2 = new Version(100, 200, 300, (400 << 16) + 500);
            var v3 = new Version(101, 200, 300, (400 << 16) + 500);
            var o = new object();
            object o2 = v2;

            assert.Ok(v1.Equals(v2), "v1.Equals(v2)");
            assert.NotOk(v1.Equals(v3), "v1.Equals(v3)");
            assert.NotOk(v1.Equals(o), "v1.Equals(o)");
            assert.NotOk(v1.Equals(null), "v1.Equals(null)");
            assert.NotOk(v1.Equals(100), "v1.Equals(100)");
            assert.Ok(v1.Equals(o2), "v1.Equals(o2)");

            assert.Equal(v1.GetHashCode(), 1283637748, "v1.GetHashCode()");
            assert.Equal(v2.GetHashCode(), 1283637748, "v2.GetHashCode()");
            assert.Equal(v3.GetHashCode(), 1552073204, "v3.GetHashCode()");
        }

        /// <summary>
        /// Load and parse the referenced model but ignored any further referenced model.
        /// </summary>
        /// <param name="mainEdmxVersion">The main edm version.</param>
        /// <returns>A list of CsdlModel (no semantics) of the referenced models.</returns>
        private List<CsdlModel> LoadAndParseReferencedEdmxFiles(Version mainEdmxVersion)
        {
            List<CsdlModel> referencedAstModels = new List<CsdlModel>();
            if (this.getReferencedModelReaderFunc == null)
            {
                // don't try to load Edm xml doc, but this.edmReferences's namespace-alias need to be used later.
                return referencedAstModels;
            }

            foreach (var tmp in this.edmReferences)
            {
                if (!tmp.Includes.Any() && !tmp.IncludeAnnotations.Any())
                {
                    this.RaiseError(EdmErrorCode.ReferenceElementMustContainAtLeastOneIncludeOrIncludeAnnotationsElement, Strings.EdmxParser_InvalidReferenceIncorrectNumberOfIncludes);
                    continue;
                }

                if (tmp.Uri != null && (tmp.Uri.EndsWith(CoreVocabularyConstants.VocabularyUrlSuffix, StringComparison.Ordinal) ||
                    tmp.Uri.EndsWith(CapabilitiesVocabularyConstants.VocabularyUrlSuffix, StringComparison.Ordinal) ||
                    tmp.Uri.EndsWith(AlternateKeysVocabularyConstants.VocabularyUrlSuffix, StringComparison.Ordinal)))
                {
                    continue;
                }

                XmlReader referencedXmlReader = this.getReferencedModelReaderFunc(new Uri(tmp.Uri, UriKind.RelativeOrAbsolute));
                if (referencedXmlReader == null)
                {
                    this.RaiseError(EdmErrorCode.UnresolvedReferenceUriInEdmxReference, Strings.EdmxParser_UnresolvedReferenceUriInEdmxReference);
                    continue;
                }

                // recursively use EdmxReader to parse sub edm:
                EdmxReader referencedEdmxReader = new EdmxReader(referencedXmlReader, /*getReferencedModelReaderFunc*/ null);
                referencedEdmxReader.source = tmp.Uri;
                referencedEdmxReader.ignoreUnexpectedAttributesAndElements = this.ignoreUnexpectedAttributesAndElements;
                Version referencedEdmxVersion;
                CsdlModel referencedAstModel;
                if (referencedEdmxReader.TryParseEdmxFileToCsdlModel(out referencedEdmxVersion, out referencedAstModel))
                {
                    if (!mainEdmxVersion.Equals(referencedEdmxVersion))
                    {
                        // TODO: REF add exception message
                        this.errors.Add(null);
                    }

                    referencedAstModel.AddParentModelReferences(tmp);
                    referencedAstModels.Add(referencedAstModel);
                }

                this.errors.AddRange(referencedEdmxReader.errors);
            }

            return referencedAstModels;
        }

        private static void RegisterConfigurationReaderSelector(ContainerBuilder builder)
        {
            builder.Register(
                c =>
                    {
                        var ctx = c.Resolve<IComponentContext>();
                        Func<Version, IVersionedConfigurationReader> readerSelector =
                            version =>
                            {
                                // Get a collection of lazy resolved meta data objects for the
                                // IVersionedXmlConfigurationReader
                                var allReadersAsLazy = ctx.Resolve<IEnumerable<Meta<IVersionedConfigurationReader>>>();

                                // Now find the reader that we want
                                // This is done by comparing the version numbers. If the
                                // first 2 digits of the input version number match the
                                // first 2 digits of the version number stored in the
                                // meta data, then we assume we found our reader.
                                // This is based on the idea that if we change the
                                // XML config format then we have to increment at least
                                // the minor version number.
                                IVersionedConfigurationReader selectedReader = null;
                                foreach (var reader in allReadersAsLazy)
                                {
                                    var inputShort = new Version(version.Major, version.Minor);

                                    var storedVersion = reader.Metadata["ReaderVersion"] as Version;
                                    var storedShort = new Version(storedVersion.Major, storedVersion.Minor);

                                    if (storedShort.Equals(inputShort))
                                    {
                                        selectedReader = reader.Value;
                                    }
                                }

                                return selectedReader;
                            };

                        return readerSelector;
                    });
        }

 public bool runTest()
   {
   Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
   String strLoc = "Loc_000oo";
   String strValue = String.Empty;
   int iCountErrors = 0;
   int iCountTestcases = 0;
   try
     {
     Version vTest1 = new Version (5,5);
     Version vTest2 = new Version (5,4);
     strLoc = "Loc_100vy";
     iCountTestcases++;
     if (vTest1.Equals(vTest2) == true )
       {
       ++iCountErrors;	
       printerr( "Error_100aa! Expected==false");
       }
     strLoc = "Loc_300vy";
     vTest2 = new Version (5,5);
     iCountTestcases++;
     if (vTest1.Equals(vTest2) == false )
       {
       ++iCountErrors;	
       printerr( "Error_300aa! Expected==true");
       }
     if (vTest2.Equals(vTest1) == false )
       {
       ++iCountErrors;	
       printerr( "Error_300bb! Expected==true");
       }
     vTest1 = new Version (10,10,10);
     vTest2 = new Version (10,10,2);
     strLoc = "Loc_400vy";
     iCountTestcases++;
     if (vTest1.Equals(vTest2) != false )
       {
       ++iCountErrors;	
       printerr( "Error_400aa! Expected==false");
       }
     strLoc = "Loc_600vy";
     vTest2 = new Version (10,10,10);
     iCountTestcases++;
     if (vTest1.Equals(vTest2) != true )
       {
       ++iCountErrors;	
       printerr( "Error_600aa! Expected==true");
       }
     if (vTest2.Equals(vTest1) != true )
       {
       ++iCountErrors;	
       printerr( "Error_600bb! Expected==true");
       }
     vTest1 = new Version (550,500,2,7);
     vTest2 = new Version (550,500,2,5);
     strLoc = "Loc_700vy";
     iCountTestcases++;
     if (vTest1.Equals(vTest2) != false )
       {
       ++iCountErrors;	
       printerr( "Error_700aa! Expected==false");
       }
     strLoc = "Loc_600vy";
     vTest2 = new Version (550,500,2,7);
     iCountTestcases++;
     if (vTest1.Equals(vTest2) != true )
       {
       ++iCountErrors;	
       printerr( "Error_900aa! Expected==true");
       }
     if (vTest2.Equals(vTest1) != true )
       {
       ++iCountErrors;	
       printerr( "Error_900bb! Expected==true");
       }
     strLoc = "Loc_100bb";
     vTest1 = new Version (550,500);
     vTest2 = new Version (550,500,2,7);
     iCountTestcases++;
     if (vTest1.Equals(vTest2) != false )
       {
       ++iCountErrors;	
       printerr( "Error_100xx! Expected==false");
       }
     if (vTest2.Equals(vTest1) != false )
       {
       ++iCountErrors;	
       printerr( "Error_100zz! Expected==false");
       }
     strLoc = "Loc_110zz";
     vTest1 = new Version (Int32.MaxValue,500);
     vTest2 = new Version (550,500,2,0);
     iCountTestcases++;
     if (vTest1.Equals(vTest2) != false )
       {
       ++iCountErrors;	
       printerr( "Error_100xx! Expected==false");
       }
     if (vTest2.Equals(vTest1) != false )
       {
//.........这里部分代码省略.........

	public void TestEquals ()
	{
		Version v1 = new Version (1, 2);
		Version v2 = new Version (1, 2, 3, 4);
		Version v3 = new Version (1, 2, 3, 4);

		AssertEquals ("A1", true, v2.Equals (v3));
		AssertEquals ("A2", true, v2.Equals (v2));
		AssertEquals ("A3", false, v1.Equals (v3));

		AssertEquals ("A4", true, v2 == v3);
		AssertEquals ("A5", true, v2 == v2);
		AssertEquals ("A6", false, v1 == v3);

		AssertEquals ("A7", false, v2.Equals ((Version) null));
		AssertEquals ("A8", false, v2.Equals ("A string"));
		
	}

	public void TestClone () 
	{
		Version v1 = new Version (1, 2, 3, 4);
		Version v2 = (Version) v1.Clone ();

		Assert ("A1", v1.Equals (v2));
		Assert ("A2", !ReferenceEquals (v1, v2));

		Version v3 = new Version (); // 0.0
		v2 = (Version) v3.Clone ();

		Assert ("A3", v3.Equals (v2));
		Assert ("A4", !ReferenceEquals (v3, v2));
	}

    public bool PosTest3()
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("PosTest3: Ensure Equals(System.Object) return false when obj is not Version object.");

        try
        {
            String TestString1 = new String(new char[] { '2', '.', '3', '.', '4', '.', '8' });
            Version TestVersion2 = new Version("2.3.4.8");
            if (TestVersion2.Equals(TestString1))
            {
                TestLibrary.TestFramework.LogError("P03.1", "Equals(System.Object) failed when obj is not Version object!");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("P03.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

 public override bool LoadPostData(string postDataKey, NameValueCollection postCollection)
 {
     string majorVersion = postCollection[postDataKey + "_Major"];
     string minorVersion = postCollection[postDataKey + "_Minor"];
     string buildVersion = postCollection[postDataKey + "_Build"];
     bool dataChanged = false;
     Version presentValue = Version;
     var postedValue = new Version(majorVersion + "." + minorVersion + "." + buildVersion);
     if (!postedValue.Equals(presentValue))
     {
         Value = postedValue;
         dataChanged = true;
     }
     return dataChanged;
 }

        public static void TestEqualsGetHashCode()
        {
            var v1 = new Version(100, 200, 300, (400 << 16) + 500);
            var v2 = new Version(100, 200, 300, (400 << 16) + 500);
            var v3 = new Version(101, 200, 300, (400 << 16) + 500);
            var o = new object();
            object o2 = v2;

            Assert.True(v1.Equals(v2), "v1.Equals(v2)");
            Assert.False(v1.Equals(v3), "v1.Equals(v3)");
            Assert.False(v1.Equals(o), "v1.Equals(o)");
            Assert.False(v1.Equals(null), "v1.Equals(null)");
            Assert.False(v1.Equals(100), "v1.Equals(100)");
            Assert.True(v1.Equals(o2), "v1.Equals(o2)");

            Assert.AreEqual(v1.GetHashCode(), 1283637748, "v1.GetHashCode()");
            Assert.AreEqual(v2.GetHashCode(), 1283637748, "v2.GetHashCode()");
            Assert.AreEqual(v3.GetHashCode(), 1552073204, "v3.GetHashCode()");
        }