コード例 #1
0
        public void FuncionesTagExiste(string texto, Tags t, bool esperado)
        {
            var real = AssFilter.TagExists(texto, t);

            Assert.AreEqual(esperado, real);
        }
コード例 #2
0
        /// <summary>
        /// Inicializa una nueva instancia de la clase <see cref="TagGroup"/>, obteniendo los tags y el comentario existentes en el texto dado.
        /// </summary>
        /// <param name="texto">Texto con tags o comentario.</param>
        public TagGroup(string texto)
        {
            Tags = new List <string>();

            var regex = new Regex(RegularExpressions.RegexGroups);
            var match = regex.Match(texto);

            if (match.Success)
            {
                Comment = match.Groups["texto"].Value;

                var tags = match.Groups["grupo"].Value;

                if (AssFilter.TagExists(tags, Constants.Tags.A))
                {
                    TagA = new TagA(tags);
                    Tags.Add(TagA.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Alpha))
                {
                    TagAlpha = new TagAlpha(tags);
                    Tags.Add(TagAlpha.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Alpha1))
                {
                    TagAlpha1 = new TagAlpha1(tags);
                    Tags.Add(TagAlpha1.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Alpha2))
                {
                    TagAlpha2 = new TagAlpha2(tags);
                    Tags.Add(TagAlpha2.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Alpha3))
                {
                    TagAlpha3 = new TagAlpha3(tags);
                    Tags.Add(TagAlpha3.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Alpha4))
                {
                    TagAlpha4 = new TagAlpha4(tags);
                    Tags.Add(TagAlpha4.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.An))
                {
                    TagAn = new TagAn(tags);
                    Tags.Add(TagAn.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.B))
                {
                    TagB = new TagB(tags);
                    Tags.Add(TagB.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Be))
                {
                    TagBe = new TagBe(tags);
                    Tags.Add(TagBe.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Blur))
                {
                    TagBlur = new TagBlur(tags);
                    Tags.Add(TagBlur.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Bord))
                {
                    TagBord = new TagBord(tags);
                    Tags.Add(TagBord.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.BordX))
                {
                    TagBordX = new TagBordX(tags);
                    Tags.Add(TagBordX.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.BordY))
                {
                    TagBordY = new TagBordY(tags);
                    Tags.Add(TagBordY.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Clip))
                {
                    TagClip = new TagClip(tags);
                    Tags.Add(TagClip.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.ClipI))
                {
                    TagClipI = new TagClipI(tags);
                    Tags.Add(TagClipI.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Color1))
                {
                    TagColor1 = new TagColor1(tags);
                    Tags.Add(TagColor1.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Color2))
                {
                    TagColor2 = new TagColor2(tags);
                    Tags.Add(TagColor2.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Color3))
                {
                    TagColor3 = new TagColor3(tags);
                    Tags.Add(TagColor3.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Color4))
                {
                    TagColor4 = new TagColor4(tags);
                    Tags.Add(TagColor4.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fad))
                {
                    TagFad = new TagFad(tags);
                    Tags.Add(TagFad.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fade))
                {
                    TagFade = new TagFade(tags);
                    Tags.Add(TagFade.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fax))
                {
                    TagFax = new TagFax(tags);
                    Tags.Add(TagFax.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fay))
                {
                    TagFay = new TagFay(tags);
                    Tags.Add(TagFay.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fe))
                {
                    TagFe = new TagFe(tags);
                    Tags.Add(TagFe.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fn))
                {
                    TagFn = new TagFn(tags);
                    Tags.Add(TagFn.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Frx))
                {
                    TagFrx = new TagFrx(tags);
                    Tags.Add(TagFrx.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fry))
                {
                    TagFry = new TagFry(tags);
                    Tags.Add(TagFry.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Frz))
                {
                    TagFrz = new TagFrz(tags);
                    Tags.Add(TagFrz.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fs))
                {
                    TagFs = new TagFs(tags);
                    Tags.Add(TagFs.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fscx))
                {
                    TagFscx = new TagFscx(tags);
                    Tags.Add(TagFscx.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fscy))
                {
                    TagFscy = new TagFscy(tags);
                    Tags.Add(TagFscy.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Fsp))
                {
                    TagFsp = new TagFsp(tags);
                    Tags.Add(TagFsp.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.I))
                {
                    TagI = new TagI(tags);
                    Tags.Add(TagI.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.K))
                {
                    TagK = new TagK(tags);
                    Tags.Add(TagK.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Kf))
                {
                    TagKf = new TagKf(tags);
                    Tags.Add(TagKf.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Ko))
                {
                    TagKo = new TagKo(tags);
                    Tags.Add(TagKo.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Move))
                {
                    TagMove = new TagMove(tags);
                    Tags.Add(TagMove.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Org))
                {
                    TagOrg = new TagOrg(tags);
                    Tags.Add(TagOrg.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.P))
                {
                    TagP = new TagP(tags);
                    Tags.Add(TagP.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Pbo))
                {
                    TagPbo = new TagPbo(tags);
                    Tags.Add(TagPbo.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Pos))
                {
                    TagPos = new TagPos(tags);
                    Tags.Add(TagPos.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Q))
                {
                    TagQ = new TagQ(tags);
                    Tags.Add(TagQ.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.R))
                {
                    TagR = new TagR(tags);
                    Tags.Add(TagR.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.S))
                {
                    TagS = new TagS(tags);
                    Tags.Add(TagS.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.Shad))
                {
                    TagShad = new TagShad(tags);
                    Tags.Add(TagShad.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.ShadX))
                {
                    TagShadX = new TagShadX(tags);
                    Tags.Add(TagShadX.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.ShadY))
                {
                    TagShadY = new TagShadY(tags);
                    Tags.Add(TagShadY.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.T))
                {
                    TagT = new TagT(tags);
                    Tags.Add(TagT.ToString());
                }

                if (AssFilter.TagExists(tags, Constants.Tags.U))
                {
                    TagU = new TagU(tags);
                    Tags.Add(TagU.ToString());
                }
            }
        }