Inheritance: MonoBehaviour
Exemple #1
0
        private HttpActionDescriptor GetNewActionDescriptor(
            VersionNumber theRequestedApiVersion, 
            HttpActionDescriptor theOriginalHttpActionDescriptor)
        {
            var aApiVersionAttributes = theOriginalHttpActionDescriptor.GetCustomAttributes<ApiVersionAttribute>();
            if (aApiVersionAttributes == null || aApiVersionAttributes.Count == 0)
            {
                return theOriginalHttpActionDescriptor;
            }

            var aActionMappings = GetActionMapping(theOriginalHttpActionDescriptor.ControllerDescriptor);
            var aMatchedActionDescriptorMappings = new Dictionary<VersionNumber, HttpActionDescriptor>();
            foreach (var aApiVersionAttribute in aApiVersionAttributes)
            {
                var aActionName = aApiVersionAttribute.OperatioName;
                if (!aActionMappings.Contains(aActionName))
                {
                    continue;
                }

                var aHttpActionDescriptor = aActionMappings[aActionName].ElementAt(0);
                aMatchedActionDescriptorMappings[aApiVersionAttribute.VersionNumber] = aHttpActionDescriptor;
            }

            // this mapping could be cached
            if (aMatchedActionDescriptorMappings.Count == 0)
            {
                return theOriginalHttpActionDescriptor;
            }

            // customize version select logic here
            return CustomizedActionDescriptorSelector(theRequestedApiVersion, aMatchedActionDescriptorMappings);
        }
        static void Main(string[] args)
        {
            //todo use mono.options https://www.nuget.org/packages/Mono.Options/
            if (args.Length < 5)
            {
                Console.WriteLine("YouTrack Release helper, marks a version as released and creates version numbers for follow up releases. Works with version numbers up to 3 digits");
                Console.WriteLine("");
                Console.WriteLine("Usage:");
                Console.WriteLine("  YouTrackRelease --server=<server> --username=<username> --password=<password> --project=<project> --version=<version>");
                Console.WriteLine("");
                Console.WriteLine("Options:");
                Console.WriteLine("  --server=<server>          Server address, ie http://youtrack.domain.com/youtrack");
                Console.WriteLine("  --username=<username>      User with admin role");
                Console.WriteLine("  --password=<password>      ");
                Console.WriteLine("  --project=<project>        ID of project being released");
                Console.WriteLine("  --version=<version>        The version number to be released (i.e 1.2.3)");
                return;
            }

            var server = GetArgNotNull(args, "--server");
            var username = GetArgNotNull(args, "--username");
            var password = GetArgNotNull(args, "--password");
            var projectId = GetArgNotNull(args, "--project");
            var version = GetArgNotNull(args, "--version");

            var uri = new Uri(server);
            Console.WriteLine("Connecting to server: {0}, {1}, {2}", uri, uri.Port, uri.AbsolutePath);

            var conn = new Connection(uri.Host, uri.Port, uri.Scheme == "https", uri.AbsolutePath);
            conn.Authenticate(username, password);

            var projectManagement = new ProjectManagement(conn);
            var project = projectManagement.GetProject(projectId);
            if (project == null)
                throw new Exception("Project does not exist");

            var existingVersions = projectManagement.GetVersions(project).Select((v) => v.Name);

            if (!existingVersions.Contains(version))
                throw new Exception("Version does not exist");

            Console.Out.WriteLine("Releasing version: {0}", version);
            projectManagement.UpdateVersion(project, new ProjectVersion { IsReleased = true, Name = version, ReleaseDate = JavaTimeNow() });

            var currentVersion = new VersionNumber(version);
            var nextVersions = currentVersion.GetNextReleaseVersions().Select((v) => v.ToString());

            var missingVersions = nextVersions.Where((v) => !existingVersions.Contains(v));
            foreach (var newVersion in missingVersions)
            {
                Console.Out.WriteLine("Adding version: {0}", newVersion);
                projectManagement.AddVersion(project, new ProjectVersion {IsReleased = false, Name = newVersion});
            }

            if (Debugger.IsAttached)
                Console.ReadLine();
        }
 public static string GetName(VersionNumber VersionNumberEnum)
 {
     switch (VersionNumberEnum)
     {
         case VersionNumber.Version3:
             return "Version 3";
         case VersionNumber.Version4:
             return "Version 4";
         default:
             return "Unknown";
     }
 }
Exemple #4
0
    public static VersionNumber Parse(string numberString)
    {
        VersionNumber result = new VersionNumber();

        try
        {
            if (numberString.Contains('.'))
            {
                string[] stringArray = numberString.Split('.');

                switch (stringArray.Length)
                {
                case 1:
                    result.Major = int.Parse(stringArray[0]);
                    break;

                case 2:
                    result.Major = int.Parse(stringArray[0]);
                    result.Minor = int.Parse(stringArray[1]);
                    break;

                case 3:
                    result.Major = int.Parse(stringArray[0]);
                    result.Minor = int.Parse(stringArray[1]);
                    result.Patch = int.Parse(stringArray[2]);
                    break;

                default:
                    Debug.LogError("Version number not supported: " + numberString);
                    return(null);
                }
            }
            else
            {
                result.Major = int.Parse(numberString);
            }

            return(result);
        }
        catch (Exception e)
        {
            Debug.LogError(e);
            return(null);
        }
    }
        private bool VerifyDependencies()
        {
            if (SpawnModularCar == null)
            {
                LogError("SpawnModularCar is not loaded, get it at https://umod.org");
                return(false);
            }

            var requiredVersion = new VersionNumber(5, 0, 1);

            if (SpawnModularCar.Version < requiredVersion)
            {
                LogError($"SpawnModularCar {requiredVersion} or newer is required, get it at https://umod.org");
                return(false);
            }

            return(true);
        }
Exemple #6
0
        // package level for testing purposes
        internal virtual string DetermineDateFormat(PlatformDate date, VersionNumber version)
        {
            // date format precedence:
            //    provided Date is a dateWithPattern
            //    format has been overridden for this version
            //    default format for version/specializationType
            string datePattern = GetPatternFromDateWithPattern(date);

            if (datePattern == null)
            {
                datePattern = GetOverrideDatePattern(version);
                if (datePattern == null)
                {
                    datePattern = DATE_FORMAT_YYYYMMDDHHMMSS_SSSZZZZZ;
                }
            }
            return(datePattern);
        }
 ///<summary>Поиск последней версии приложения</summary><param name="version_name"></param><param name="versionNumber"></param>
 public AppVersion Find(string version_name, VersionNumber versionNumber)
 {
     try
     {
         mydb = new DB.SQLite.SQLite(BDPath);
         SQLiteCommand command = new SQLiteCommand();
         command.CommandText = "SELECT * FROM FilesVersions WHERE Applications = @Applications and AppVersions = @AppVersions";
         command.Parameters.Add("@Applications", DbType.String).Value = version_name;
         command.Parameters.Add("@AppVersions", DbType.String).Value  = versionNumber.ToString();
         logger.Add("Версия найдена");
         return(Result(command));
     }
     catch (FilePathIsNullException ex)
     {
         logger.Add(ex);
         throw new FilePathIsNullException();
     }
 }
        public void GenericContent_Save_VersionModeNone_ApprovingFalse_Test()
        {
            Page test = CreatePage("GCSaveTest");

            VersionNumber vn = test.Version;
            string        cm = test.CustomMeta;

            test.VersioningMode = VersioningType.None;
            test.ApprovingMode  = ApprovingType.False;

            test.CustomMeta = Guid.NewGuid().ToString();

            test.Save();

            Assert.AreEqual(vn, test.Version, "#1");
            Assert.AreEqual(test.Version.Status, VersionStatus.Approved, "#2");
            Assert.AreNotEqual(cm, test.CustomMeta, "#3");
        }
Exemple #9
0
        private void setVersion(string version)
        {
            var version_parts = version.Split('.').Select(part =>
            {
                ushort number;
                if (!ushort.TryParse(part, out number))
                {
                    number = 0;
                }
                return(number);
            }).ToList();

            while (version_parts.Count < 3)
            {
                version_parts.Add(0);
            }
            Version = new VersionNumber(version_parts[0], version_parts[1], version_parts[2]);
        }
Exemple #10
0
        ///<summary>Поиск последней версии приложения</summary><param name="version_name"></param><param name="versionNumber"></param>
        public AppVersion Find(string version_name, VersionNumber versionNumber)
        {
            string[]             Apps     = Directory.GetDirectories(RootPath);                                                                                       // массив приложений(папки с названиями всех приложений)
            string               App      = (from app in Apps where (Path.GetFileNameWithoutExtension(app.ToLower()) == version_name.ToLower()) select app).Single(); //Строка содержащая суть к нужному приложению(к версиям)
            List <FileOfVersion> fileApp  = new List <FileOfVersion>();
            List <string>        ListFile = new List <string>();

            ListFile = GetFiles_app(version_name, versionNumber);
            for (int x = 0; x < ListFile.Count; x++)
            {
                FileOfVersion verss = new FileOfVersion(ListFile[x], fileContain(RootPath + "\\" + version_name + "\\" + versionNumber.ToString() + ListFile[x]), File.GetCreationTime(RootPath + "\\" + version_name + "\\" + versionNumber.ToString() + ListFile[x]));
                fileApp.Add(verss);
            }
            AppVersion res = null;

            res = new AppVersion(Path.GetFileNameWithoutExtension(App), versionNumber, fileApp);
            return(res);
        }
Exemple #11
0
        public IInteraction ConvertXMLToMessageObject(String xml, VersionNumber version)
        {
            IInteraction msg = null;

            MessageBeanTransformerImpl transformer = this.CreateTransformer();

            try
            {
                XmlToModelResult result = transformer.TransformFromHl7(version, new DocumentFactory().CreateFromString(xml));
                msg = (IInteraction)result.GetMessageObject();
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine("Exception in HelloWorldApp.Deserialize() method");
                throw new Exception(ex.ToString());
            }
            return(msg);
        }
Exemple #12
0
        public void SavingAction_Off_None_Approved_Save()
        {
            Test(true, () =>
            {
                var gc = CreateNodeInMemory(ApprovingType.False, VersioningType.None);

                InitializeAsExisting(gc, 2, 456, "V1.0.A");
                var action = SavingAction.Create(gc);

                SetVersionHistory(action, gc, new[]
                {
                    new NodeHead.NodeVersion(VersionNumber.Parse("V1.0.A"), 456)
                });

                action.CheckOutAndSave();
                SavingAssert(action, "V1.0.A", 456, "V2.0.L", 0, 1, new List <int>());
            });
        }
Exemple #13
0
        private bool VersionNumberTryCreate(string str, out VersionNumber Version)
        {
            Version = null;
            try
            {
                Version = new VersionNumber(str);
            }
            catch (Exception ex)
            {
                if (ex is ThreadAbortException)
                {
                    throw ex;
                }

                return(false);
            }
            return(true);
        }
Exemple #14
0
        public void SavingAction_Off_MajorMinor_StartMultistepSave_02()
        {
            Test(true, () =>
            {
                var gc = CreateNodeInMemory(ApprovingType.False, VersioningType.MajorAndMinor);

                InitializeAsExisting(gc, 1, 111, "V2.0.A");
                var action = SavingAction.Create(gc);
                SetVersionHistory(action, gc, new[]
                {
                    new NodeHead.NodeVersion(VersionNumber.Parse("V1.0.A"), 110),
                    new NodeHead.NodeVersion(VersionNumber.Parse("V2.0.A"), 111)
                });
                action.StartMultistepSave();

                SavingAssert(action, "V2.0.A", 111, "V2.1.L", 0, 1, new List <int>());
            });
        }
Exemple #15
0
        public virtual BigDecimal ValidateValueR2(string value, VersionNumber version, string type, bool hasNullFlavor, XmlElement
                                                  element, string propertyPath, Hl7Errors errors)
        {
            BigDecimal result = null;

            if (!StringUtils.IsBlank(value))
            {
                try
                {
                    result = new BigDecimal(value);
                }
                catch (FormatException)
                {
                    CreateWarning(System.String.Format("value \"{0}\" is not a valid decimal value", value), element, propertyPath, errors);
                }
            }
            return(result);
        }
Exemple #16
0
        /// <summary>
        /// Генерировать все возможные относительные пути сборок по version.
        /// </summary>
        /// <param name="versionNumber">Версия сборки.</param>
        /// <param name="separator">Раздилитель.</param>
        /// <returns>Все возможные относительные пути.</returns>
        public static IEnumerable <string> GenerateAllPossibleRelativePath(VersionNumber versionNumber, char separator)
        {
            string versionNumberAsString = versionNumber.ToString();

            IEnumerable <string> buildNumbers   = GenerateAllPossibleBuildNumbers(versionNumberAsString);
            IEnumerable <string> releaseNumbers = GenerateAllPossibleReleaseNumbers(versionNumberAsString);
            var paths = new HashSet <string>(buildNumbers);

            foreach (var releaseNumber in releaseNumbers)
            {
                foreach (var buildNumber in buildNumbers)
                {
                    paths.Add(string.Join(separator, releaseNumber, buildNumber));
                }
            }

            return(paths);
        }
        public void SavingAction_Off_Full_Draft_Publish1()
        {
            var gc = CreateNodeInMemory(ApprovingType.False, VersioningType.MajorAndMinor);

            InitializeAsExisting(gc, 123, 112, "V1.1.D");

            var action = SavingAction.Create(gc);

            SetVersionHistory(action, gc, new[]
            {
                new NodeHead.NodeVersion(VersionNumber.Parse("V1.0.A"), 111),
                new NodeHead.NodeVersion(VersionNumber.Parse("V1.1.D"), 112)
            });

            action.Publish();

            SavingAssert(action, "V1.1.D", 112, "V2.0.A", 112, 0, new List <int>());
        }
    private void Start()
    {
        TextMeshProUGUI component     = GetComponent <TextMeshProUGUI>();
        VersionNumber   versionNumber = default(VersionNumber);
        TextAsset       textAsset     = Resources.Load <TextAsset>("Curve/build_version_number");
        XmlSerializer   xmlSerializer = new XmlSerializer(versionNumber.GetType());
        StringReader    textReader    = new StringReader(textAsset.text);

        versionNumber     = (VersionNumber)xmlSerializer.Deserialize(textReader);
        gameVersionString = $"v{versionNumber.majorVersion}{versionNumber.minorVersion}{versionNumber.build}{versionNumber.revision}";
        gameVersionString = gameVersionString.Substring(0, 8);
        DateTime dateTime = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddDays(versionNumber.build).AddSeconds(versionNumber.revision * 2);

        gameBuildString = $"v{versionNumber.majorVersion}{versionNumber.minorVersion}{versionNumber.build}{versionNumber.revision}";
        gameBuildString = gameBuildString.Substring(0, 8);
        GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 700f);
        makeGameBuildString(component);
    }
Exemple #19
0
            public bool Before(VersionNumber other, int depth)
            {
                bool result = false;

                if (depth < 1 || depth > 4)
                {
                    throw new System.ArgumentOutOfRangeException("Depth must be in [1,4]");
                }
                for (int i = 0; i < depth; i++)
                {
                    if (subNumbers_[i] < other.subNumbers_[i])
                    {
                        result = true;
                        break;
                    }
                }
                return(result);
            }
 public EditorViewModel(EditorPluginLoader plugins, Settings settings)
 {
     this.plugins      = plugins;
     Settings.Current  = settings;
     service           = new OnlineService();
     AvailableProjects = new List <ProjectNameAndFontWeight>();
     Error             = Resources.GetApiKeyHere;
     SetupLogger();
     VersionNumber = new VersionNumber();
     plugins.FindAndLoadAllPlugins();
     RegisterCommands();
     SetApiKey(LoadDataFromRegistry("ApiKey"));
     SetInitialContentProject();
     ConnectToOnlineServiceAndTryToLogin();
     EditorPlugins    = new List <EditorPluginView>();
     messageViewModel = new PopupMessageViewModel(service);
     messageViewModel.MessageUpdated += RaisePopupMessageProperties;
 }
Exemple #21
0
 /// <summary>
 /// Get all the message parts for a particular interaction and version.
 /// </summary>
 ///
 /// <param name="interaction">- the interaction</param>
 /// <param name="version">- the version</param>
 /// <returns>- the message parts</returns>
 public virtual IDictionary <String, MessagePart> GetAllMessageParts(Interaction interaction,
                                                                     VersionNumber version)
 {
     if (interaction != null)
     {
         /* foreach */
         foreach (MessageDefinitionService service  in  this.services)
         {
             Interaction foundInteraction = service.GetInteraction(version,
                                                                   interaction.Name);
             if (foundInteraction != null)
             {
                 return(service.GetAllMessageParts(interaction, version));
             }
         }
     }
     return(new Dictionary <String, MessagePart>());
 }
        public void SavingAction_On_None_Pending_Reject2()
        {
            var gc = CreateNodeInMemory(ApprovingType.True, VersioningType.None);

            InitializeAsExisting(gc, 123, 112, "V2.0.P");

            var action = SavingAction.Create(gc);

            SetVersionHistory(action, gc, new[]
            {
                new NodeHead.NodeVersion(VersionNumber.Parse("V1.0.R"), 111),
                new NodeHead.NodeVersion(VersionNumber.Parse("V2.0.P"), 112)
            });

            action.Reject();

            SavingAssert(action, "V2.0.P", 112, "V2.0.R", 112, null, new List <int>());
        }
Exemple #23
0
        /// <summary>Store a CodeResolverRegistry to be used for a specific HL7v3 release version.</summary>
        /// <remarks>
        /// Store a CodeResolverRegistry to be used for a specific HL7v3 release version. Passing in a null value for the registry will
        /// remove any existing registry for the supplied version.
        /// </remarks>
        /// <param name="version">the version for which the supplied code resolver registry should be used</param>
        /// <param name="registry">the code resolver registry to use for this version</param>
        /// <returns>returns true if there was a code resolver registry already registered for this version</returns>
        public static bool RegisterCodeResolverRegistryForVersion(VersionNumber version, GenericCodeResolverRegistry registry)
        {
            bool result = (version == null ? false : registryMap.ContainsKey(version));

            if (registry == null)
            {
                if (version != null)
                {
                    registryMap.Remove(version);
                    return(result);
                }
            }
            if (version != null)
            {
                registryMap[version] = registry;
            }
            return(result);
        }
Exemple #24
0
        public void VersionNumberFeatureVersion(
            string highestAnnotatedTag,
            string branchName,
            uint commitsOnDevelopSinsLastMinorCoreVersion,
            uint commitsUniqueToFeature,
            string hash,
            string expectedVersion)
        {
            _mock.Setup(f => f.CurrentBranch).Returns(BranchInfoFactory.CreateBranchInfo(branchName));
            _mock.Setup(f => f.CurrentCoreVersion).Returns(VersionNumber.Parse(highestAnnotatedTag));
            _mock.Setup(f => f.CommitCountDevelopSinceLastMinorCoreVersion).Returns(commitsOnDevelopSinsLastMinorCoreVersion);
            _mock.Setup(f => f.CommitCountUniqueToFeature).Returns(commitsUniqueToFeature);
            _mock.Setup(f => f.HeadCommitHash).Returns(hash);

            var version = VersionNumberGenerator.GenerateVersionNumber(_mock.Object);

            version.ToString().Should().Be(expectedVersion);
        }
        public void SavingAction_Off_None_CheckOut2()
        {
            // do not save the content in this test
            // do not change the parent to TestRoot
            var gc = CreateNodeInMemory(ApprovingType.False, VersioningType.None);

            InitializeAsExisting(gc, 100, 111, "V2.0.A");
            var action = SavingAction.Create(gc);

            SetVersionHistory(action, gc, new[]
            {
                new NodeHead.NodeVersion(VersionNumber.Parse("V1.0.A"), 110),
                new NodeHead.NodeVersion(VersionNumber.Parse("V2.0.A"), 111)
            });
            action.CheckOut();

            SavingAssert(action, "V2.0.A", 111, "V3.0.L", 0, 1, new List <int>());
        }
Exemple #26
0
    private void OnInitMessageResponse(string response)
    {
#if UNITY_EDITOR
        if (Tracking)
        {
            PrintTrack(MethodBase.GetCurrentMethod().Name);
            PrintTrack("response: " + response);
        }
#endif

        _initializeAppMessageRef = null;

        if (string.IsNullOrEmpty(response))
        {
            FinishInit();
            return;
        }

        InitializeAppResponseMessage responseMessage = InitializeAppResponseMessage.FromJson(response);
        if (responseMessage == null)
        {
            FinishInit();
            return;
        }

        VersionNumber        currentApiVersionOnDevice = GetCurrentApiVersionOnDevice();
        CompareVersionNumber compareResult             =
            (CompareVersionNumber)currentApiVersionOnDevice.CompareTo(responseMessage.ApiVersion);

        if (compareResult == CompareVersionNumber.Equal)
        {
            _currentApiClientId = responseMessage.ApiclientId;
            _currentToken       = responseMessage.Token;
            FinishInit(responseMessage.ApiclientId, responseMessage.Token);
        }
        else
        {
            _updating = false;
            if (_onNewApiVersion != null)
            {
                _onNewApiVersion(currentApiVersionOnDevice, responseMessage.ApiVersion);
            }
        }
    }
Exemple #27
0
        private static void ShowNewUpdateAvailableForm(Tuple <VersionNumber, ProductVersionDto, bool> versionInfo)
        {
            VersionNumber     currentVersion       = versionInfo.Item1;
            ProductVersionDto latestProductVersion = versionInfo.Item2;
            bool skipNewVersion = versionInfo.Item3;

            bool DoNotShowAgain = FormProductUpdate.DialogShow(currentVersion, latestProductVersion, skipNewVersion);


            RegistryKey registryKey = Registry.CurrentUser.OpenSubKey(Const.PRODUCT_REG_KEY, true);

            if (registryKey == null)
            {
                registryKey = Registry.CurrentUser.CreateSubKey(Const.PRODUCT_REG_KEY);
            }

            if (registryKey != null)
            {
                string currentValue =
                    registryKey.GetValue(Const.PRODUCT_REG_KEY_VALUE_DONT_SHOW_UPDATE_VERSION) as string;
                List <VersionNumber> versionsToSkip = string.IsNullOrEmpty(currentValue)
                                                         ? new List <VersionNumber>()
                                                         : ParseVersionsToSkip(currentValue);

                VersionNumber latestVersion = new VersionNumber(latestProductVersion.Version);

                if (DoNotShowAgain)
                {
                    if (!versionsToSkip.Any(item => item.Equals(latestVersion)))
                    {
                        versionsToSkip.Add(latestVersion);
                    }
                }
                else
                {
                    versionsToSkip.RemoveAll(number => number.Equals(latestVersion));
                }

                currentValue = string.Join(";", versionsToSkip.Select(item => item.ToString()).ToArray());

                registryKey.SetValue(Const.PRODUCT_REG_KEY_VALUE_DONT_SHOW_UPDATE_VERSION, currentValue);
                registryKey.Close();
            }
        }
        protected override void Execute(CodeActivityContext context)
        {
            #region Extract Workflow Argument Values

            // The file path of the nuget.exe - if null or empty then
            //  assume nuget is "installed" on the build server and in the path
            var nuGetExeFilePath = NuGetExeFilePath.Get(context);

            // The path of the nuspec file
            var nuSpecFilePath = NuSpecFilePath.Get(context);

            // The folder location of the files to be packed
            var basePath = BasePath.Get(context);

            // The folder location of the files to be packed
            var outputDirectory = OutputDirectory.Get(context);

            // The destination location if deployment is to be done
            var versionNumber = VersionNumber.Get(context);

            // command line options to append (as is) to the nuget command line
            var additionalOptions = AdditionalOptions.Get(context);

            #endregion

            context.WriteBuildMessage(string.Format("In CallNuGetPackageCommandLine:"), BuildMessageImportance.High);
            context.WriteBuildMessage(string.Format("nuGetExeFilePath: {0}", nuGetExeFilePath), BuildMessageImportance.High);
            context.WriteBuildMessage(string.Format("basePath: {0}", basePath), BuildMessageImportance.High);
            context.WriteBuildMessage(string.Format("outputDirectory: {0}", outputDirectory), BuildMessageImportance.High);
            context.WriteBuildMessage(string.Format("versionNumber: {0}", versionNumber), BuildMessageImportance.High);
            context.WriteBuildMessage(string.Format("additionalOptions: {0}", additionalOptions), BuildMessageImportance.High);

            // Don't assume that DI will have happened.  If the value is null then create the default object.);)
            if (NuGetProcess == null)
            {
                NuGetProcess = new NuGetProcess();
            }

            // Call the method that will do the work
            var results = NuGetPackaging(nuGetExeFilePath, nuSpecFilePath, outputDirectory, basePath, versionNumber, additionalOptions, context);

            // Send the result back to the workflow
            NuGetPackagingResult.Set(context, results);
        }
Exemple #29
0
        /// <summary>
        /// Обновляет сборку.
        /// </summary>
        /// <param name="location">Новый путь.</param>
        /// <param name="number">Номер сборки.</param>
        /// <param name="releaseNumber">Номер релиза.</param>
        /// <param name="updatedSuffixes">Новые суффиксы.</param>
        /// <param name="changeDate">Дата изменения сборки.</param>
        public void Update(string location, VersionNumber releaseNumber, VersionNumber number, IList <string> updatedSuffixes, DateTime changeDate)
        {
            location.ThrowIsNullOrWhiteSpace(new UpdateBuildException("Location is null or empty."));
            number.ThrowIfNull(new UpdateBuildException("Number must not be null"));
            ValidateReleaseNumber(releaseNumber, number, location);

            IList <string> newSuffixes =
                Suffixes.ToHashSet().SetEquals(updatedSuffixes)
                    ? Suffixes
                    : updatedSuffixes;

            if (location == Location && newSuffixes.SequenceEqual(Suffixes))
            {
                return;
            }

            Apply(new BuildUpdated(location, number, releaseNumber, newSuffixes, CreateMetadata(changeDate)));
            UpdateArtifactState(ArtifactState.Updated);
        }
        public void SavingAction_On_Full_Pending_Approve2()
        {
            var gc = CreateNodeInMemory(ApprovingType.True, VersioningType.MajorAndMinor);

            InitializeAsExisting(gc, 123, 113, "V0.3.P");

            var action = SavingAction.Create(gc);

            SetVersionHistory(action, gc, new[]
            {
                new NodeHead.NodeVersion(VersionNumber.Parse("V0.1.P"), 111),
                new NodeHead.NodeVersion(VersionNumber.Parse("V0.2.D"), 112),
                new NodeHead.NodeVersion(VersionNumber.Parse("V0.3.P"), 113)
            });

            action.Approve();

            SavingAssert(action, "V0.3.P", 113, "V1.0.A", 113, null, new List <int>());
        }
        public void VersionNumberPreReleaseTag(
            string versionTag,
            uint expectedMajor,
            uint expectedMinor,
            uint expectedPatch,
            string expectedBranchLabel,
            uint expectedBranchLabelOrdinal)
        {
            var versionNumber = VersionNumber.Parse(versionTag);

            versionNumber.Major.Should().Be(expectedMajor);
            versionNumber.Minor.Should().Be(expectedMinor);
            versionNumber.Patch.Should().Be(expectedPatch);
            versionNumber.Metadata.Should().BeEmpty();
            versionNumber.PreReleaseLabel.Should().NotBeNull();
            versionNumber.PreReleaseLabel?.BranchLabel.Label.Should().Be(expectedBranchLabel);
            versionNumber.PreReleaseLabel?.BranchLabel.Ordinal.Should().Be(expectedBranchLabelOrdinal);
            versionNumber.PreReleaseLabel?.BranchLabel.Should().NotBeOfType(typeof(FeaturePreReleaseLabel));
        }
        public void ItShouldSetVersionOnServiceManifest()
        {
            // g
            var oldVersion = VersionNumber.Create(1, "hash");
            var newVersion = new GlobalVersion
            {
                Version = VersionNumber.Create(2, "newhash")
            };
            var serviceManifest = new ServiceManifest
            {
                Version = oldVersion.ToString()
            };

            // w
            _serviceManifestHandler.SetServiceManifestGeneral(serviceManifest, newVersion);

            // t
            serviceManifest.Version.Should().Be("2-newhash");
        }
Exemple #33
0
    public static InitializeAppResponseMessage FromJson(string jsonString)
    {
        InitializeAppResponseMessage result = new InitializeAppResponseMessage();

        try
        {
            JsonData jsonData = JsonMapper.ToObject(jsonString);
            result.Status      = jsonData["status"].ToString();
            result.ApiVersion  = VersionNumber.Parse(jsonData["apiversion"].ToString());
            result.Token       = jsonData["token"].ToString();
            result.ApiclientId = int.Parse(jsonData["apiclientid"].ToString());
            return(result);
        }
        catch (Exception e)
        {
            Debug.LogError(e);
            return(null);
        }
    }
Exemple #34
0
        public void SetCoreAttributes(int nodeId, int nodeTypeId, int contentListId, int contentListTypeId,
            bool isDeleted, bool isInherited, int parentId, string name, string displayName, string path, int index,
            bool locked, int lockedById, string etag, int lockType, int lockTimeout, DateTime lockDate, string lockToken, DateTime lastLockUpdate,
            int versionId, VersionNumber version, DateTime creationDate, int createdById, DateTime modificationDate, int modifiedById,
            DateTime nodeCreationDate, int nodeCreatedById, DateTime nodeModificationDate, int nodeModifiedById, long nodeTimestamp, long versionTimestamp)
        {
            _data.Id = nodeId;
            _data.NodeTypeId = nodeTypeId;
            _data.ContentListId = contentListId;
            _data.ContentListTypeId = contentListTypeId;
            _data.IsDeleted = isDeleted;
            _data.IsInherited = isInherited;
            _data.ParentId = parentId;
            _data.Name = name;
            _data.DisplayName = displayName;
            _data.Path = path;
            _data.Index = index;
            _data.Locked = locked;
            _data.LockedById = lockedById;
            _data.ETag = etag;
            _data.LockType = lockType;
            _data.LockTimeout = lockTimeout;
            _data.LockDate = lockDate;
            _data.LockToken = lockToken;
            _data.LastLockUpdate = lastLockUpdate;
            _data.VersionId = versionId;
            _data.Version = version;
            _data.CreationDate = creationDate;
            _data.CreatedById = createdById;
            _data.ModificationDate = modificationDate;
            _data.ModifiedById = modifiedById;
            _data.NodeCreationDate = nodeCreationDate;
            _data.NodeCreatedById = nodeCreatedById;
            _data.NodeModificationDate = nodeModificationDate;
            _data.NodeModifiedById = nodeModifiedById;
            _data.NodeTimestamp = nodeTimestamp;
            _data.VersionTimestamp = versionTimestamp;

            _loaded = true;
        }
Exemple #35
0
        private HttpActionDescriptor CustomizedActionDescriptorSelector(
            VersionNumber theRequestedApiVersion,
            IDictionary<VersionNumber, HttpActionDescriptor> theMatchedActionDescriptorMappings)
        {
            if (theRequestedApiVersion == new VersionNumber("1.0.0") || theRequestedApiVersion < new VersionNumber("1.0.0"))
            {
                return theMatchedActionDescriptorMappings[new VersionNumber("1.0.0")];
            }

            if (theRequestedApiVersion > new VersionNumber("1.0.0") &&
                theRequestedApiVersion < new VersionNumber("1.2.1"))
            {
                return theMatchedActionDescriptorMappings[new VersionNumber("1.0.0")];
            }

            if (theRequestedApiVersion < new VersionNumber("1.9.9"))
            {
                return theMatchedActionDescriptorMappings[new VersionNumber("1.2.1")];
            }

            return theMatchedActionDescriptorMappings[new VersionNumber("2.0.0")];
        }
Exemple #36
0
 public bool Before( VersionNumber other )
 {
     return Before( other, 4 );
 }
Exemple #37
0
            public bool Before( VersionNumber other, int depth )
            {
                bool result = false;

                if (depth < 1 || depth > 4)
                {
                    throw new System.ArgumentOutOfRangeException( "Depth must be in [1,4]" );
                }
                for (int i = 0; i < depth; i++)
                {
                    if (subNumbers_[i] < other.subNumbers_[i])
                    {
                        result = true;
                        break;
                    }
                }
                return result;
            }
 // Internal Methods
 /// <summary>
 /// A SNTPData that is used by a client to send to a server to request data.
 /// </summary>
 internal static SNTPData GetClientRequestPacket(VersionNumber versionNumber)
 {
     SNTPData packet = new SNTPData();
     packet.Mode = Mode.Client;
     packet.VersionNumber = versionNumber;
     packet.TransmitDateTime = DateTime.Now.ToUniversalTime();
     return packet;
 }
Exemple #39
0
 private bool IsExceedTheMaxApiVersion(VersionNumber theRequestedApiVersion)
 {
     return theRequestedApiVersion > new VersionNumber("2.0.0");
 }
 public void MajorVersionNextRelease()
 {
     var versionNumber = new VersionNumber("1");
     Assert.IsTrue(new List<VersionNumber> { new VersionNumber("2") }.SequenceEqual(versionNumber.GetNextReleaseVersions()));
 }
Exemple #41
0
        //protected internal override INodeQueryCompiler CreateNodeQueryCompiler()
        //{
        //    return new SqlCompiler();
        //}
        //protected internal override List<NodeToken> ExecuteQuery(NodeQuery query)
        //{
        //    List<NodeToken> result = new List<NodeToken>();
        //    SqlCompiler compiler = new SqlCompiler();

        //    NodeQueryParameter[] parameters;
        //    string compiledCommandText = compiler.Compile(query, out parameters);

        //    SqlProcedure command = null;
        //    SqlDataReader reader = null;
        //    try
        //    {
        //        command = new SqlProcedure { CommandText = compiledCommandText };
        //        command.CommandType = CommandType.Text;
        //        foreach (var parameter in parameters)
        //            command.Parameters.Add(new SqlParameter(parameter.Name, parameter.Value));

        //        reader = command.ExecuteReader();

        //        ReadNodeTokens(reader, result);
        //    }
        //    finally
        //    {
        //        if (reader != null && !reader.IsClosed)
        //            reader.Close();

        //        command.Dispose();
        //    }

        //    return result;
        //}

        protected internal override void LoadNodes(Dictionary<int, NodeBuilder> buildersByVersionId)
        {
            List<string> versionInfo = new List<string>();
            versionInfo.Add(String.Concat("VersionsId[count: ", buildersByVersionId.Count, "]"));

            if (buildersByVersionId.Keys.Count > 20)
            {
                versionInfo.AddRange(buildersByVersionId.Keys.Take(20).Select(x => x.ToString()));
                versionInfo.Add("...");
            }
            else
                versionInfo.AddRange(buildersByVersionId.Keys.Select(x => x.ToString()).ToArray());
            var operationTitle = String.Join(", ", versionInfo.ToArray());

            using (var traceOperation = Logger.TraceOperation("SqlProvider.LoadNodes" + operationTitle))
            {
                var builders = buildersByVersionId; // Shortcut
                SqlProcedure cmd = null;
                SqlDataReader reader = null;
                try
                {
                    cmd = new SqlProcedure { CommandText = "proc_Node_LoadData_Batch" };
                    string xmlIds = CreateIdXmlForNodeInfoBatchLoad(builders);
                    cmd.Parameters.Add("@IdsInXml", SqlDbType.Xml).Value = xmlIds;
                    reader = cmd.ExecuteReader();

                    //-- #1: FlatProperties
                    //SELECT * FROM FlatProperties
                    //    WHERE VersionId IN (select id from @versionids)
                    var versionIdIndex = reader.GetOrdinal("VersionId");
                    var pageIndex = reader.GetOrdinal("Page");

                    while (reader.Read())
                    {
                        int versionId = reader.GetInt32(versionIdIndex);
                        int page = reader.GetInt32(pageIndex);
                        NodeBuilder builder = builders[versionId];
                        foreach (PropertyType pt in builder.Token.AllPropertyTypes)
                        {
                            string mapping = PropertyMap.GetValidMapping(page, pt);
                            if (mapping.Length != 0)
                            {
                                // Mapped property appears in the given page
                                object val = reader[mapping];
                                builder.AddDynamicProperty(pt, (val == DBNull.Value) ? null : val);
                            }
                        }
                    }

                    reader.NextResult();


                    //-- #2: BinaryProperties
                    //SELECT BinaryPropertyId, VersionId, PropertyTypeId, ContentType, FileNameWithoutExtension,
                    //    Extension, [Size], [Checksum], NULL AS Stream, 0 AS Loaded
                    //FROM dbo.BinaryProperties
                    //WHERE PropertyTypeId IN (select id from @binids) AND VersionId IN (select id from @versionids)
                    var binaryPropertyIdIndex = reader.GetOrdinal("BinaryPropertyId");
                    versionIdIndex = reader.GetOrdinal("VersionId");
                    var checksumPropertyIndex = reader.GetOrdinal("Checksum");
                    var propertyTypeIdIndex = reader.GetOrdinal("PropertyTypeId");
                    var contentTypeIndex = reader.GetOrdinal("ContentType");
                    var fileNameWithoutExtensionIndex = reader.GetOrdinal("FileNameWithoutExtension");
                    var extensionIndex = reader.GetOrdinal("Extension");
                    var sizeIndex = reader.GetOrdinal("Size");

                    while (reader.Read())
                    {
                        string ext = reader.GetString(extensionIndex);
                        if (ext.Length != 0)
                            ext = ext.Remove(0, 1); // Remove dot from the start if extension is not empty

                        string fn = reader.GetSafeString(fileNameWithoutExtensionIndex); // reader.IsDBNull(fileNameWithoutExtensionIndex) ? null : reader.GetString(fileNameWithoutExtensionIndex);

                        var x = new BinaryDataValue
                        {
                            Id = reader.GetInt32(binaryPropertyIdIndex),
                            Checksum = reader.GetSafeString(checksumPropertyIndex), //reader.IsDBNull(checksumPropertyIndex) ? null : reader.GetString(checksumPropertyIndex),
                            FileName = new BinaryFileName(fn, ext),
                            ContentType = reader.GetString(contentTypeIndex),
                            Size = reader.GetInt64(sizeIndex)
                        };

                        var versionId = reader.GetInt32(versionIdIndex);
                        var propertyTypeId = reader.GetInt32(propertyTypeIdIndex);
                        builders[versionId].AddDynamicProperty(propertyTypeId, x);
                    }

                    reader.NextResult();


                    //-- #3: ReferencePropertyInfo + Referred NodeToken
                    //SELECT VersionId, PropertyTypeId, ReferredNodeId
                    //FROM dbo.ReferenceProperties ref
                    //WHERE ref.VersionId IN (select id from @versionids)
                    versionIdIndex = reader.GetOrdinal("VersionId");
                    propertyTypeIdIndex = reader.GetOrdinal("PropertyTypeId");
                    var nodeIdIndex = reader.GetOrdinal("ReferredNodeId");

                    //-- Collect references to Dictionary<versionId, Dictionary<propertyTypeId, List<referredNodeId>>>
                    var referenceCollector = new Dictionary<int, Dictionary<int, List<int>>>();
                    while (reader.Read())
                    {
                        var versionId = reader.GetInt32(versionIdIndex);
                        var propertyTypeId = reader.GetInt32(propertyTypeIdIndex);
                        var referredNodeId = reader.GetInt32(nodeIdIndex);

                        if (!referenceCollector.ContainsKey(versionId))
                            referenceCollector.Add(versionId, new Dictionary<int, List<int>>());
                        var referenceCollectorPerVersion = referenceCollector[versionId];
                        if (!referenceCollectorPerVersion.ContainsKey(propertyTypeId))
                            referenceCollectorPerVersion.Add(propertyTypeId, new List<int>());
                        referenceCollectorPerVersion[propertyTypeId].Add(referredNodeId);
                    }
                    //-- Set references to NodeData
                    foreach (var versionId in referenceCollector.Keys)
                    {
                        var referenceCollectorPerVersion = referenceCollector[versionId];
                        foreach (var propertyTypeId in referenceCollectorPerVersion.Keys)
                            builders[versionId].AddDynamicProperty(propertyTypeId, referenceCollectorPerVersion[propertyTypeId]);
                    }

                    reader.NextResult();


                    //-- #4: TextPropertyInfo (NText:Lazy, NVarchar(4000):loaded)
                    //SELECT VersionId, PropertyTypeId, NULL AS Value, 0 AS Loaded
                    //FROM dbo.TextPropertiesNText
                    //WHERE VersionId IN (select id from @versionids)
                    //UNION ALL
                    //SELECT VersionId, PropertyTypeId, Value, 1 AS Loaded
                    //FROM dbo.TextPropertiesNVarchar
                    //WHERE VersionId IN (select id from @versionids)
                    versionIdIndex = reader.GetOrdinal("VersionID");
                    propertyTypeIdIndex = reader.GetOrdinal("PropertyTypeId");
                    var valueIndex = reader.GetOrdinal("Value");
                    var loadedIndex = reader.GetOrdinal("Loaded");

                    while (reader.Read())
                    {
                        int versionId = reader.GetInt32(versionIdIndex);
                        int propertyTypeId = reader.GetInt32(propertyTypeIdIndex);
                        string value = reader.GetSafeString(valueIndex); // (reader[valueIndex] == DBNull.Value) ? null : reader.GetString(valueIndex);
                        bool loaded = Convert.ToBoolean(reader.GetInt32(loadedIndex));

                        if (loaded)
                            builders[versionId].AddDynamicProperty(propertyTypeId, value);
                    }

                    reader.NextResult();


                    //-- #5: BaseData
                    //SELECT N.NodeId, N.NodeTypeId, N.ContentListTypeId, N.ContentListId, N.IsDeleted, N.IsInherited, 
                    //    N.ParentNodeId, N.[Name], N.[Path], N.[Index], N.Locked, N.LockedById, 
                    //    N.ETag, N.LockType, N.LockTimeout, N.LockDate, N.LockToken, N.LastLockUpdate,
                    //    N.CreationDate AS NodeCreationDate, N.CreatedById AS NodeCreatedById, 
                    //    N.ModificationDate AS NodeModificationDate, N.ModifiedById AS NodeModifiedById,
                    //    V.VersionId, V.MajorNumber, V.MinorNumber, V.CreationDate, V.CreatedById, 
                    //    V.ModificationDate, V.ModifiedById, V.[Status]
                    //FROM dbo.Nodes AS N 
                    //    INNER JOIN dbo.Versions AS V ON N.NodeId = V.NodeId ON N.NodeId = V.NodeId
                    //WHERE V.VersionId IN (select id from @versionids)
                    nodeIdIndex = reader.GetOrdinal("NodeId");
                    var nodeTypeIdIndex = reader.GetOrdinal("NodeTypeId");
                    var contentListTypeIdIndex = reader.GetOrdinal("ContentListTypeId");
                    var contentListIdIndex = reader.GetOrdinal("ContentListId");
                    var isDeletedIndex = reader.GetOrdinal("IsDeleted");
                    var isInheritedIndex = reader.GetOrdinal("IsInherited");
                    var parentNodeIdIndex = reader.GetOrdinal("ParentNodeId");
                    var nameIndex = reader.GetOrdinal("Name");
                    var displayNameIndex = reader.GetOrdinal("DisplayName");
                    var pathIndex = reader.GetOrdinal("Path");
                    var indexIndex = reader.GetOrdinal("Index");
                    var lockedIndex = reader.GetOrdinal("Locked");
                    var lockedByIdIndex = reader.GetOrdinal("LockedById");
                    var eTagIndex = reader.GetOrdinal("ETag");
                    var lockTypeIndex = reader.GetOrdinal("LockType");
                    var lockTimeoutIndex = reader.GetOrdinal("LockTimeout");
                    var lockDateIndex = reader.GetOrdinal("LockDate");
                    var lockTokenIndex = reader.GetOrdinal("LockToken");
                    var lastLockUpdateIndex = reader.GetOrdinal("LastLockUpdate");
                    var nodeCreationDateIndex = reader.GetOrdinal("NodeCreationDate");
                    var nodeCreatedByIdIndex = reader.GetOrdinal("NodeCreatedById");
                    var nodeModificationDateIndex = reader.GetOrdinal("NodeModificationDate");
                    var nodeModifiedByIdIndex = reader.GetOrdinal("NodeModifiedById");
                    var nodeTimestampIndex = reader.GetOrdinal("NodeTimestamp");

                    versionIdIndex = reader.GetOrdinal("VersionId");
                    var majorNumberIndex = reader.GetOrdinal("MajorNumber");
                    var minorNumberIndex = reader.GetOrdinal("MinorNumber");
                    var creationDateIndex = reader.GetOrdinal("CreationDate");
                    var createdByIdIndex = reader.GetOrdinal("CreatedById");
                    var modificationDateIndex = reader.GetOrdinal("ModificationDate");
                    var modifiedByIdIndex = reader.GetOrdinal("ModifiedById");
                    var status = reader.GetOrdinal("Status");
                    var versionTimestampIndex = reader.GetOrdinal("VersionTimestamp");

                    while (reader.Read())
                    {
                        int versionId = reader.GetInt32(versionIdIndex);

                        VersionNumber versionNumber = new VersionNumber(
                            reader.GetInt16(majorNumberIndex),
                            reader.GetInt16(minorNumberIndex),
                            (VersionStatus)reader.GetInt16(status));

                        builders[versionId].SetCoreAttributes(
                            reader.GetInt32(nodeIdIndex),
                            reader.GetInt32(nodeTypeIdIndex),
                            TypeConverter.ToInt32(reader.GetValue(contentListIdIndex)),
                            TypeConverter.ToInt32(reader.GetValue(contentListTypeIdIndex)),
                            Convert.ToBoolean(reader.GetByte(isDeletedIndex)),
                            Convert.ToBoolean(reader.GetByte(isInheritedIndex)),
                            reader.GetSafeInt32(parentNodeIdIndex), // reader.GetValue(parentNodeIdIndex) == DBNull.Value ? 0 : reader.GetInt32(parentNodeIdIndex), //parent,
                            reader.GetString(nameIndex),
                            reader.GetSafeString(displayNameIndex),
                            reader.GetString(pathIndex),
                            reader.GetInt32(indexIndex),
                            Convert.ToBoolean(reader.GetByte(lockedIndex)),
                            reader.GetSafeInt32(lockedByIdIndex), // reader.GetValue(lockedByIdIndex) == DBNull.Value ? 0 : reader.GetInt32(lockedByIdIndex),
                            reader.GetString(eTagIndex),
                            reader.GetInt32(lockTypeIndex),
                            reader.GetInt32(lockTimeoutIndex),
                            reader.GetDateTime(lockDateIndex),
                            reader.GetString(lockTokenIndex),
                            reader.GetDateTime(lastLockUpdateIndex),
                            versionId,
                            versionNumber,
                            reader.GetDateTime(creationDateIndex),
                            reader.GetInt32(createdByIdIndex),
                            reader.GetDateTime(modificationDateIndex),
                            reader.GetInt32(modifiedByIdIndex),
                            reader.GetDateTime(nodeCreationDateIndex),
                            reader.GetInt32(nodeCreatedByIdIndex),
                            reader.GetDateTime(nodeModificationDateIndex),
                            reader.GetInt32(nodeModifiedByIdIndex),
                            GetLongFromBytes((byte[])reader.GetValue(nodeTimestampIndex)),
                            GetLongFromBytes((byte[])reader.GetValue(versionTimestampIndex))
                            );
                    }
                    foreach (var builder in builders.Values)
                        builder.Finish();
                }
                finally
                {
                    if (reader != null && !reader.IsClosed)
                        reader.Close();

                    cmd.Dispose();
                }
                traceOperation.IsSuccessful = true;
            }
        }
Exemple #42
0
        protected internal override NodeHead.NodeVersion[] GetNodeVersions(int nodeId)
        {
            SqlProcedure cmd = null;
            SqlDataReader reader = null;
            try
            {
                string commandString = @"
                    SELECT VersionId, MajorNumber, MinorNumber, Status
                    FROM Versions
                    WHERE NodeId = @NodeId
                    ORDER BY MajorNumber, MinorNumber
                ";
                cmd = new SqlProcedure { CommandText = commandString };
                cmd.CommandType = CommandType.Text;
                cmd.Parameters.Add("@NodeId", SqlDbType.NVarChar, 450).Value = nodeId;
                reader = cmd.ExecuteReader();

                List<NodeHead.NodeVersion> versionList = new List<NodeHead.NodeVersion>();

                while (reader.Read())
                {
                    var versionId = reader.GetInt32(0);
                    var major = reader.GetInt16(1);
                    var minor = reader.GetInt16(2);
                    var statusCode = reader.GetInt16(3);

                    var versionNumber = new VersionNumber(major, minor, (VersionStatus)statusCode);

                    versionList.Add(new NodeHead.NodeVersion(versionNumber, versionId));
                }

                return versionList.ToArray();

            }
            finally
            {
                if (reader != null)
                    reader.Dispose();
                if (cmd != null)
                    cmd.Dispose();
            }


        }
Exemple #43
0
 public bool Differs( VersionNumber other )
 {
     return Differs( other, 4 );
 }
 public void MajorMinorMaintenanceVersionToString()
 {
     var versionNumber = new VersionNumber("1.2.3");
     Assert.AreEqual("1.2.3", versionNumber.ToString());
 }
 public void MajorMinorVersionNextReleases()
 {
     var versionNumber = new VersionNumber("1.2");
     var nextReleaseVersions = versionNumber.GetNextReleaseVersions();
     Assert.IsTrue(new List<VersionNumber> { new VersionNumber("2.0"), new VersionNumber("1.3")}.SequenceEqual(nextReleaseVersions), "Was not equal to: {0}", string.Join(", ", nextReleaseVersions));
 }
 public void MajorMinorVersionToString()
 {
     var versionNumber = new VersionNumber("1.2");
     Assert.AreEqual("1.2", versionNumber.ToString());
 }
Exemple #47
0
 public bool DiffersExceptBuildNumber( VersionNumber other )
 {
     return Differs( other, 3 );
 }
Exemple #48
0
 public bool BeforeExceptBuildNumber( VersionNumber other )
 {
     return Before( other, 3 );
 }
 public void MajorVersionOnlyToString()
 {
     var versionNumber = new VersionNumber("1");
     Assert.AreEqual("1", versionNumber.ToString());
 }