public string Evaluate(TagModel model)
 {
     var builder = new StringBuilder();
     IList list = ToList(GetIEnumerable(model));
     int start = GetAutoValueAsInt("Begin", model).Value;
     int end = GetAsInt(End, model) ?? list.Count;
     int step = GetAutoValueAsInt("Step", model).Value;
     string var = GetAutoValueAsString("Var", model);
     string varStatus = GetAutoValueAsString("VarStatus", model);
     model.PushTagStack();
     var status = new ForEachStatus(list.Count, start, end);
     if (list.Count > 0)
     {
         model.Tag[varStatus] = status;
         for (int i = start; i < end; i += step)
         {
             status.Index = i;
             model.Tag[var] = list[i];
             builder.Append(GetAsString(Body, model) ?? String.Empty);
         }
         model.Tag[var] = null;
         model.Tag[varStatus] = null;
     }
     model.PopTagStack();
     return builder.ToString();
 }

 public override void SetUp()
 {
     base.SetUp();
     var model = new Hashtable();
     _model = new TagModel(model);
     _model.Page[FormatConstants.LOCALE] = new CultureInfo("en-US");
 }

 public override void SetUp()
 {
     base.SetUp();
     var model = new Hashtable();
     _model = new TagModel(model);
     _model.Page[FormatConstants.LOCALE] = CultureInfo.InvariantCulture;
 }

 public NewTagViewController (WorkspaceModel workspace)
 {
     this.model = new TagModel () {
         Workspace = workspace,
     };
     Title = "NewTagTitle".Tr ();
 }

 public void GlobalResolveTest()
 {
     var model = new TagModel(new Reflection(new Hashtable()));
     model.Global["ResolveNewValue"] = "abc";
     Assert.That(model.Global["ResolveNewValue"], Is.EqualTo("abc"));
     Assert.That(model["ResolveNewValue"], Is.EqualTo("abc"));
 }

 public override object InternalEvaluate(TagModel model)
 {
     string dateStr = GetAutoValueAsString("Value", model);
     CultureInfo culture = ParseLocale != null
                               ? new CultureInfo(GetAsString(ParseLocale, model))
                               : (CultureInfo) model[FormatConstants.LOCALE];
     var format =
         (DateTimeFormatInfo) DateTimeFormatInfo.GetInstance(culture.DateTimeFormat).Clone();
     DateTime? result = null;
     if (!String.IsNullOrEmpty(dateStr))
     {
         if (GetAutoValueAsBool("Exact", model))
         {
             string pattern = GetAsString(Pattern, model) ?? GetPattern(model, format);
             try
             {
                 result = DateTime.ParseExact(dateStr, pattern, format);
             } catch (FormatException)
             {
                 throw TagException.ParseException(dateStr, "Date").Decorate(Context);
             }
         }
         else
         {
             result = DateTime.Parse(dateStr, format);
         }
     }
     return result;
 }

 public string Evaluate(TagModel model)
 {
     string result = GetAutoValueAsString("Value", model);
     var escapeXml = GetAutoValueAsBool("EscapeXml", model);
     result = result ?? String.Empty;
     return escapeXml ? StringUtils.EscapeXml(result) : result;
 }

 public void ModelTest()
 {
     var model = new TagModel(new Reflection(new Hashtable()));
     model.Model["NewValue"] = "abc";
     Assert.That(model.Model["NewValue"], Is.EqualTo("abc"));
     Assert.That(model[VariableScope.Model + ".NewValue"], Is.EqualTo("abc"));
 }

 public string Evaluate(TagModel model)
 {
     string locale = GetAsString(Value, model);
     VariableScope scope = GetAutoValueAs<VariableScope>("Scope", model).Value;
     model[scope + "." + FormatConstants.LOCALE] = new CultureInfo(locale);
     return String.Empty;
 }

 protected override object InternalEvaluate(TagModel model)
 {
     var builder = new StringBuilder();
     builder.Append(GetAsUrl(Value, model) ?? String.Empty);
     builder.Append(ParamsEvaluate(model));
     return builder.ToString();
 }

 public XsltParameter EvaluateNested(TagModel model)
 {
     string name = GetAsString(Name, model) ?? String.Empty;
     string nameSpaceUri = GetAsString(NameSpaceUri, model) ?? String.Empty;
     object value = GetAutoValue("Value", model) ?? String.Empty;
     return new XsltParameter(name, nameSpaceUri, value);
 }

 public static string Evaluate(ITagWithVariable tag, TagModel model)
 {
     object result = tag.InternalEvaluate(model);
     string var = tag.GetAutoValueAsString("Var", model);
     string scope = tag.GetAutoValueAsString("Scope", model);
     model[scope + "." + var] = result;
     return String.Empty;
 }

        protected override object InternalEvaluate(TagModel model)
        {
            var urlBuilder = new StringBuilder();
            urlBuilder.Append(GetAsUrl(Url, model));
            urlBuilder.Append(ParamsEvaluate(model));

            return ReadData(PlaceRequest(urlBuilder));
        }

        public override IEnumerable GetIEnumerable(TagModel model)
        {
            string items = GetAsString(Items, model) ?? String.Empty;
            string delims = GetAsString(Delims, model);
            string[] tokens = items.Split(delims.ToCharArray());

            return new ArrayList(tokens);
        }

 public void CheckParsingOfLocaleDefautScope()
 {
     var model = new TagModel(this);
     var tag = new SetLocale();
     tag.Value = new MockAttribute(new Constant("nl-NL"));
     Assert.That(tag.Evaluate(model), Is.EqualTo(String.Empty));
     Assert.That(model.Page[FormatConstants.LOCALE], Is.EqualTo(new CultureInfo("nl-NL")));
 }

 public void ModelAbovePageResolveTest()
 {
     var model = new TagModel(new Reflection(new Hashtable()));
     model.Page["NewValue"] = "Page";
     Assert.That(model["NewValue"], Is.EqualTo("Page"));
     model.Model["NewValue"] = "Model";
     Assert.That(model["NewValue"], Is.EqualTo("Model"));
 }

 public void TestRequestEncodingNoRepsonseSet()
 {
     var tag = new RequestEncoding();
     tag.Value = new MockAttribute(new Constant("UTF-8"));
     var model = new TagModel(this);
     Assert.That(tag.Evaluate(model), Is.EqualTo(String.Empty));
     Assert.That(model.Encoding, Is.EqualTo(Encoding.UTF8));
 }

 public void DateAutoValueTestTag_Should_Pass_Date()
 {
     var _model = new TagModel(new Hashtable() {
         { "SomeDate", new DateTime(1979,10,2)}
     });
     var tag = new DateAutoValueTestTag();
     tag.SomeDateValue = new MockAttribute(new Property("SomeDate"));
     Assert.That(tag.Evaluate(_model), Is.EqualTo("date=02|10|1979"));
 }

			TagModel GetTagModel (SolutionFolderItem policyParent, Project project, string language, string identifier, string fileName)
			{
				var model = new TagModel();
				var projectModel = ProjectTagModel ?? Outer.ProjectTagModel;
				if (projectModel != null)
					model.InnerModels = new [] { projectModel };
				ModifyTags (policyParent, project, language, identifier, fileName, ref model.OverrideTags);
				return model;
			}

 public string Evaluate(TagModel model)
 {
     var baseName = GetAsString(BaseName, model);
     var prefix = GetAsString(Prefix, model);
     IResourceBundle bundle = new ResourceBundle(baseName, prefix, BaseName.ResourceLocator);
     model.PushTagStack();
     model.Tag[FormatConstants.BUNDLE] = bundle;
     return GetAsString(Body, model) ?? string.Empty;
 }