public void should_be_greater_when_first_quality_is_a_proper()
        {
            var first = new Revision(version: 2);
            var second = new Revision();

            first.Should().BeGreaterThan(second);
        }

        public void should_be_lesser_when_second_quality_is_a_proper()
        {
            var first = new Revision();
            var second = new Revision(version: 2);

            first.Should().BeLessThan(second);
        }

        public static Content SetupTestContentData(Guid newGuid, Guid newGuidRedHerring, ProviderSetup providerSetup)
        {
            var baseEntity = HiveModelCreationHelper.MockTypedEntity();
            var entity = new Content(baseEntity); 
            entity.Id = new HiveId(newGuid);
            entity.EntitySchema.Alias = "schema-alias1";

            var existingDef = entity.EntitySchema.AttributeDefinitions[0];
            var newDef = HiveModelCreationHelper.CreateAttributeDefinition("aliasForQuerying", "", "", existingDef.AttributeType, existingDef.AttributeGroup, true);
            entity.EntitySchema.AttributeDefinitions.Add(newDef);
            entity.Attributes.Add(new TypedAttribute(newDef, "my-new-value"));

            entity.Attributes[1].DynamicValue = "not-on-red-herring";
            entity.Attributes[NodeNameAttributeDefinition.AliasValue].Values["UrlName"] = "my-test-route";

            var redHerringEntity = HiveModelCreationHelper.MockTypedEntity();
            redHerringEntity.Id = new HiveId(newGuidRedHerring);
            redHerringEntity.EntitySchema.Alias = "redherring-schema";

            using (var uow = providerSetup.UnitFactory.Create())
            {
                var publishedRevision = new Revision<TypedEntity>(entity)
                    { MetaData = { StatusType = FixedStatusTypes.Published } };

                uow.EntityRepository.Revisions.AddOrUpdate(publishedRevision);
                // Only add extra entity if caller wants it
                if (newGuidRedHerring != Guid.Empty) uow.EntityRepository.AddOrUpdate(redHerringEntity);
                uow.Complete();
            }

            return entity;
        }

 public void ShortVersionOfLongHashComparesEqual()
 {
     var longRevision = new Revision("e0e50f0f23264cb59ab059fa049741f3e0e50f0f");
     var shortRevision = new Revision("e0e50f0f2326");
     Assert.That(longRevision, Is.EqualTo(shortRevision));
     Assert.That(shortRevision, Is.EqualTo(longRevision));
 }

        public void should_be_lesser_when_second_quality_is_a_real()
        {
            var first = new Revision();
            var second = new Revision(real: 1);

            first.Should().BeLessThan(second);
        }

        public void should_be_greater_when_first_quality_is_a_real()
        {
            var first = new Revision(real: 1);
            var second = new Revision();

            first.Should().BeGreaterThan(second);
        }

        public void should_be_greater_when_first_is_a_proper_for_a_real()
        {
            var first = new Revision(real: 1, version: 2);
            var second = new Revision(real: 1);

            first.Should().BeGreaterThan(second);
        }

        public override void CommitRevision(Revision revision, string folder)
        {
            var filename = GetFileFromAlias(revision.Name, folder);

            if (File.Exists(filename))
                File.Delete(filename);

            if (File.Exists(filename))
                throw new Exception("An archive with the same name already exists.");

            using (var package = Package.Open(filename, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
            {
                package.PackageProperties.Identifier = revision.Name;
                package.PackageProperties.Title = "Umbraco Courier 2.0 Package - " + revision.Name;
                package.PackageProperties.LastModifiedBy = "Umbraco Courier 2.0";
                package.PackageProperties.Creator = "Umbraco Courier 2.0";
                package.PackageProperties.Created = DateTime.Now;
                package.PackageProperties.Modified = DateTime.Now;
                package.PackageProperties.ContentType = "application/courierPackage";

                foreach (var item in revision.RevisionCollection)
                    AddPackagePart(package, item.Value.FilePath, item.Value.FileContent, "Revision");

                foreach (var item in revision.ResourceCollection)
                    AddPackagePart(package, item.Value.FilePath, item.Value.FileContent, "Resource");

                foreach (var item in revision.VirtualResourceCollection)
                    AddPackagePart(package, item.Value.FilePath, item.Value.FileContent, "VirtualResource");
            }
        }

        public void should_be_equal_when_both_real_and_version_match_for_real_proper()
        {
            var first = new Revision(version: 2, real: 1);
            var second = new Revision(version: 2, real: 1);

            first.CompareTo(second).Should().Be(0);
        }

        public object Post(RevisionDTO request)
        {
            var revision = new Revision
                {
                    Fecha = new DateTime().Date,
                    Hora = new DateTime(),
                    IdEquipo = request.Equipo,
                    //Usuario = request.Usuario,
                    Entidad = RpEntidad.Cargar((Int64) 2),
                    Tipo = Revision.TipoDocumento.TrasladoDeposito
                };

            foreach (var documento in request.Documentos)
            {
                revision.Documento.Add(new RevisionDocumento
                    {
                        Documento = documento,
                    });
            }

            foreach (var detalle  in request.Detalles)
            {
                revision.Detalle.Add(new RevisionDetalle
                    {
                        Articulo = RpArticulo.Cargar(detalle.Articulo.Codigo, revision.Entidad.Empresa.Codigo),
                        Bultos = detalle.Bultos,
                        Cantidad = detalle.Cantidad,
                        UnidadesBulto = detalle.UnidadesBulto,
                    });
            }

            RpRevision.Procesar(revision);

            return revision;
        }

        public static int GetChahngesetId(Revision revision)
        {
            int prevLinksCount = revision.Index == 0
                ? 0
                : revision.WorkItem.Revisions[revision.Index - 1].Links.Count;
            if (prevLinksCount == revision.Links.Count)
                return 0;

            ExternalLink lastChangeset = null;
            for (int i = 0; i < revision.Links.Count; i++)
            {
                var link = revision.Links[i];
                if (link.BaseType == BaseLinkType.ExternalLink)
                {
                    var extLink = link as ExternalLink;
                    if (extLink.ArtifactLinkType.Name != "Fixed in Changeset")
                        continue;
                    lastChangeset = extLink;
                }
                if (lastChangeset != null && link.BaseType != BaseLinkType.ExternalLink)
                    break;
            }

            if (lastChangeset == null)
                return 0;

            string url = lastChangeset.LinkedArtifactUri;
            int lastInd = url.LastIndexOf('/');
            return int.Parse(url.Substring(lastInd + 1, url.Length - 1 - lastInd));
        }

 /// <summary>
 /// Constructs reporter.
 /// </summary>
 public ProjectStatisticsReporter(Revision[] revisions, GroupingPeriod groupBy, DateTime fromDate, DateTime toDate)
 {
     m_revisions = revisions;
       m_groupBy = groupBy;
       m_fromDate = fromDate;
       m_toDate = toDate;
 }

        public void should_be_equal_when_both_real_and_version_match()
        {
            var first = new Revision();
            var second = new Revision();

            first.CompareTo(second).Should().Be(0);
        }

        public void should_be_lesser_when_second_is_a_proper_for_a_real()
        {
            var first = new Revision(real: 1);
            var second = new Revision(real: 1, version: 2);

            first.Should().BeLessThan(second);
        }

 public ChangeSet GetChanges(Revision revision)
 {
     var changes = new ChangeSet();
     changes.Inserts = RetriveInserts(revision);
     changes.Updates = RetriveUpdates(revision);
     changes.Deletes = RetriveDeletes(revision);
     return changes;
 }

		/// <summary>
		/// Add a branch tag to the file. This is a pseudo revision that marks the revision that the branch
		/// starts at along with the branch "number" (since multiple branches can be made at a specific revision).
		/// E.g. revision 1.5.0.4 is a branch at revision 1.5 and its revisions will be 1.5.4.1, 1.5.4.2, etc.
		/// </summary>
		public void AddBranchTag(string name, Revision revision)
		{
			if (!revision.IsBranch)
				throw new ArgumentException(String.Format("Invalid branch tag revision: {0}", revision));

			m_revisionForBranch[name] = revision;
			m_branchForRevision[revision.BranchStem] = name;
		}

		/// <summary>
		/// Add a tag to the file.
		/// </summary>
		public void AddTag(string name, Revision revision)
		{
			if (revision.IsBranch)
				throw new ArgumentException(String.Format("Invalid tag revision: {0} is a branch tag revision", revision));

			m_revisionForTag[name] = revision;
			m_tagsForRevision.Add(revision, name);
		}

        public static double GetCompletedWork(Revision revision)
        {
            if (revision == null)
                return 0;

            object obj = revision["Completed Work"];
            return obj == null ? 0 : (double)obj;
        }

        //�Public�Methods�(4)
        public override void CommitRevision(Revision revision)
        {
            string path = System.IO.Path.Combine(Path, revision.Name);

            RevisionStorage revstorage = new RevisionStorage();
            revstorage.Save(revision, path);
            revstorage.Dispose();
        }

		public static void Show (VersionControlItemList items, Revision since)
		{
			foreach (VersionControlItem item in items) {
				var document = IdeApp.Workbench.OpenDocument (item.Path);
				ComparisonView.AttachViewContents (document, item);
				document.Window.SwitchView (4);
			}
		}