static void Main(string[] args)
{
MacroProcessor.Register <Foo>();
double mSecFrequency = (Stopwatch.Frequency / 1000);
string result = null;
Stopwatch sw = Stopwatch.StartNew();
CompiledTemplate compiledTemplate = MacroProcessor.Compile("Hello, my name is [name] and I'm [age] years old");
Console.WriteLine($"Compilation duration : {sw.ElapsedTicks / mSecFrequency} msecs");
int iteration = 1000 * 1000;
sw = Stopwatch.StartNew();
for (int i = 0; i < 1000 * 1000; i++)
{
result = MacroProcessor.Process("I'm [name], I'm [age] years old", new Foo(42, "Josh"));
}
Console.WriteLine($"Result: {result}");
Console.WriteLine($"AVG rendering duration : {sw.ElapsedTicks / iteration / mSecFrequency * 1000} usecs over {iteration} iterations");
System.Console.ReadKey();
}
public void MacroProcessor_Basic2()
{
var macros = new MacroProcessor();
macros.Add("var1", "HELLO");
macros.Add("var2", "WORLD");
Assert.AreEqual("HELLO", macros["var1"]);
Assert.AreEqual("HELLO", macros["VAR1"]);
Assert.IsNull(macros["VAR3"]);
Assert.AreEqual("HELLO", macros.Expand("$(var1)"));
Assert.AreEqual("WORLD", macros.Expand("$(var2)"));
Assert.AreEqual("HELLO WORLD", macros.Expand("$(var1) $(var2)"));
Assert.AreEqual("prefix HELLO suffix", macros.Expand("prefix $(var1) suffix"));
Assert.AreEqual("HELLO WORLD", macros.Expand("$(VAR1) $(VAR2)"));
macros.Clear();
Assert.AreEqual("$(var1)", macros.Expand("$(var1)"));
macros["VAR3"] = "TEST";
Assert.AreEqual("TEST", macros["var3"]);
Assert.AreEqual("TEST", macros["VAR3"]);
Assert.AreEqual("TEST", macros.Expand("$(var3)"));
Assert.AreEqual("TEST", macros.Expand("$(VAR3)"));
}
/// <summary>
/// Производит форматирование ячейки таблицы
/// </summary>
/// <param name="profile">Профиль</param>
/// <param name="data">Набор исходных данных для форматировщика</param>
protected override void DoExecute(abstractformatterClass profile, ReportFormatterData data)
{
// если нет значения, ничего не делаем
string sValue = data.CurrentValue as string;
if (sValue == null || sValue == string.Empty)
{
return;
}
int nValue = 0;
nValue = Convert.ToInt32(sValue);
// типизированный профиль
durationevaluatorClass durationEvaluatorProfile = (durationevaluatorClass)profile;
MacroProcessor processor = new MacroProcessor(data, true);
// получим формат отображения
Format format = (Format)processInt(durationEvaluatorProfile.format, (int)Format.DaysHoursMinutes, processor);
// установим текущее значение в зависимости от формата
switch (format)
{
case Format.DaysHoursMinutes:
// продолжительность рабочего дня в минутах
// ВНИМАНИЕ!!! Если не задана, считаем, что 600
int workdayDuration = processInt(durationEvaluatorProfile.workdayDuration, 600, processor);
data.CurrentValue = Utils.FormatTimeDuration(nValue, workdayDuration);
break;
case Format.Hours:
data.CurrentValue = string.Format("{0:0.##}", nValue / 60.0);
break;
}
}
protected void Test(string input, IParsingService inLang, string expected, IParsingService outLang, int maxExpand = 0xFFFF, IMessageSink sink = null)
{
MacroProcessor lemp = NewLemp(maxExpand, inLang).With(l => l.Sink = sink);
var inputCode = new LNodeList(inLang.Parse(input, MessageSink.Default));
Test(inputCode, lemp, expected, outLang);
}
/// <summary>
/// Returns main search columns to filter.
/// </summary>
private string GetSearchColumns()
{
var ti = iObjectType.TypeInfo;
if ((ti.DisplayNameColumn != ObjectTypeInfo.COLUMN_NAME_UNKNOWN))
{
DisplayNameSelectedAsSearchColumn = true;
// Get column for display name
return(ti.DisplayNameColumn);
}
if ((ti.CodeNameColumn != ObjectTypeInfo.COLUMN_NAME_UNKNOWN))
{
// Get column for code name
return(ti.CodeNameColumn);
}
if (!String.IsNullOrEmpty(displayNameFormat))
{
// Get columns from display name format if empty don't filter anything
return(MacroProcessor.GetMacros(displayNameFormat));
}
return(String.Empty);
}
/// <summary>
/// Fills class name selector with data.
/// </summary>
private void FillClassNameSelector(string assemblyName)
{
// Clear items
drpClassName.DropDownList.Items.Clear();
if (String.IsNullOrEmpty(assemblyName))
{
return;
}
if (MacroProcessor.ContainsMacro(assemblyName))
{
// Include macro value if specified
drpClassName.DropDownList.Items.Add(ClassName);
return;
}
var classes = ClassHelper.GetClasses(assemblyName, Settings);
if (classes != null)
{
// Fill drop-down list
foreach (string className in classes)
{
drpClassName.DropDownList.Items.Add(className);
}
// Select first item if nothing was selected
if ((classes.Count > 0) && !AllowEmpty && (drpClassName.SelectedIndex < 0) && String.IsNullOrEmpty(drpClassName.SelectedValue))
{
drpClassName.SelectedIndex = 0;
}
}
}
private List <LogMessage> RunLeMPAndCaptureErrors(UString inputText)
{
MessageHolder messages = new MessageHolder();
MacroProcessor lemp = NewLemp(0xFFFF, EcsLanguageService.Value).With(mp => mp.Sink = messages);
IListSource <LNode> inputCode = EcsLanguageService.Value.Parse(inputText, MessageSink.Default);
lemp.ProcessSynchronously(LNode.List(inputCode));
return(messages.List.Where(m => m.Severity == Severity.Error).ToList());
}
private static bool TrySetMacroDefaultValue(bool isMacro, string defaultValue, EditingFormControl control)
{
if (isMacro || MacroProcessor.ContainsMacro(defaultValue))
{
control.SetValue(defaultValue, isMacro);
return(true);
}
return(false);
}
private static List <MacroProcessingContext> GetMacroIndexes(string text)
{
var macroIndexes = new List <MacroProcessingContext>();
MacroProcessor.ProcessDataMacros(text, MacroProcessor.NOT_RESOLVE, context =>
{
macroIndexes.Add(context);
return(null);
});
return(macroIndexes);
}
public void MacroProcessor_Recursive()
{
var macros = new MacroProcessor();
macros.Add("var1", "$(var2)");
macros.Add("var2", "$(var3) $(var4)");
macros.Add("var3", "HELLO");
macros.Add("VAR4", "WORLD");
Assert.AreEqual("HELLO WORLD", macros.Expand("$(var1)"));
}
protected virtual MacroProcessor NewLemp(int maxExpand, IParsingService inLang)
{
var lemp = new MacroProcessor(MessageSink.Default, typeof(LeMP.Prelude.BuiltinMacros));
lemp.AddMacros(typeof(LeMP.Prelude.Les.Macros));
lemp.AddMacros(typeof(LeMP.StandardMacros).Assembly);
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP"));
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP.Prelude"));
if (inLang.FileExtensions.Any(e => e == "les"))
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP.Prelude.Les"));
lemp.MaxExpansions = maxExpand;
return lemp;
}
/// <summary>
/// Returns true if user control is valid.
/// </summary>
public override bool IsValid()
{
// Check value
string strValue = timePicker.DateTimeTextBox.Text.Trim();
bool required = (FieldInfo != null) && !FieldInfo.AllowEmpty;
bool checkEmptiness = (Form == null) || Form.CheckFieldEmptiness;
if (required && String.IsNullOrEmpty(strValue) && checkEmptiness)
{
// Empty error
if (ErrorMessage != null)
{
if (ErrorMessage != ResHelper.GetString("BasicForm.InvalidInput"))
{
ValidationError = ErrorMessage;
}
else
{
ValidationError += ResHelper.GetString("BasicForm.ErrorEmptyValue");
}
}
return(false);
}
if (AllowMacros && (MacroProcessor.ContainsMacro(strValue) || DateTimeHelper.IsNowOrToday(strValue)))
{
return(true);
}
if (((required && checkEmptiness) || !String.IsNullOrEmpty(strValue)) && (ValidationHelper.GetDateTime(strValue, DateTimeHelper.ZERO_TIME) == DateTimeHelper.ZERO_TIME))
{
if (timePicker.EditTime)
{
// Error invalid DateTime
ValidationError += String.Format("{0} {1}.", ResHelper.GetString("BasicForm.ErrorInvalidDateTime"), DateTime.Now);
}
else
{
// Error invalid date
ValidationError += String.Format("{0} {1}.", ResHelper.GetString("BasicForm.ErrorInvalidDate"), DateTime.Today.ToString("d"));
}
return(false);
}
if (CheckRange && !timePicker.IsValidRange())
{
ValidationError += GetString("general.errorinvaliddatetimerange");
return(false);
}
return(true);
}
public static void Main(string[] args)
{
// Acquire a log for, well, logging purposes.
var rawLog = TerminalLog.Acquire();
Log = new TransformLog(
rawLog,
entry => DiagnosticExtractor.Transform(entry, new Text("LeMP-repl")));
// Wrap the log in a Loyc message sink.
Sink = new SeverityMessageFilter(
new PixieMessageSink(Log),
Loyc.Severity.NoteDetail);
// Create an option parser.
var optParser = new GnuOptionSetParser(
Options.All,
Options.Files,
Options.Files.Forms[0]);
// Parse command-line arguments.
var parsedOptions = optParser.Parse(args, Log);
// Optionally display help message.
if (parsedOptions.GetValue <bool>(Options.Help))
{
rawLog.Log(
new HelpMessage(
"LeMP-repl is a simple interactive program that " +
"reads unprocessed EC#, LES v2 or LES v3 code as " +
"input and produces processed or unprocessed EC#, " +
"LES v2 or LES v3 code as output.",
"LeMP-repl [options]",
Options.All));
return;
}
// Create a macro processor.
if (!parsedOptions.GetValue <bool>(Options.DoNotProcessMacros))
{
Processor = new MacroProcessor(Sink);
Processor.AddMacros(typeof(StandardMacros).Assembly, false);
Processor.PreOpenedNamespaces.Add(GSymbol.Get("LeMP"));
}
Parser = GetParser(parsedOptions);
Printer = GetPrinter(parsedOptions);
// Start the REPL.
RunRepl();
}
public InputHub(
ILogger <InputHub> logger,
InputProcessor inputProcessor,
MacroProcessor macroProcessor,
JoystickCollection joystickCollection,
PanelHosting panelHosting
)
{
_logger = logger;
_inputProcessor = inputProcessor;
_macroProcessor = macroProcessor;
_joystickCollection = joystickCollection;
_panelHosting = panelHosting;
}
protected virtual MacroProcessor NewLemp(int maxExpand, IParsingService inLang)
{
var lemp = new MacroProcessor(MessageSink.Default, typeof(LeMP.Prelude.BuiltinMacros));
lemp.AddMacros(typeof(LeMP.Prelude.Les.Macros));
lemp.AddMacros(typeof(LeMP.StandardMacros).Assembly);
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP"));
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP.Prelude"));
if (inLang.FileExtensions.Any(e => e == "les"))
{
lemp.PreOpenedNamespaces.Add(GSymbol.Get("LeMP.Prelude.Les"));
}
lemp.MaxExpansions = maxExpand;
return(lemp);
}
/// <summary>
/// Преобразует значение с помощью макропроцессора
/// </summary>
/// <param name="value">значение, которое нужно преобразовать</param>
/// <param name="defaultValue">возвращаемое значение по умолчанию</param>
/// <param name="processor">макропроцессор</param>
/// <returns>целое значение, полученное после работы макропроцессора</returns>
private int processInt(string value, int defaultValue, MacroProcessor processor)
{
if (value == null || value == string.Empty)
{
return(defaultValue);
}
string processedValue = processor.Process(value);
if (processedValue == null || processedValue == string.Empty)
{
return(defaultValue);
}
return(Convert.ToInt32(processedValue));
}
public void MacroProcessor_InfiniteRecursion()
{
var macros = new MacroProcessor();
macros.Add("var1", "$(var2)");
macros.Add("var2", "$(var1)");
try
{
macros.Expand("$(var1)");
Assert.Fail(); // Expected a StackOverflowException
}
catch (StackOverflowException)
{
}
}
/// <summary>
/// Checks validity of inputs
/// </summary>
public override bool IsValid()
{
if (!ValidateAssembly)
{
return(true);
}
// Do not validate values returned via textboxes
if (SimpleMode)
{
return(true);
}
// Do not validate if macros are used
if (MacroProcessor.ContainsMacro(AssemblyName) || MacroProcessor.ContainsMacro(ClassName))
{
return(true);
}
// Check allow empty setting
if (AllowEmpty && (String.IsNullOrEmpty(AssemblyName) || String.IsNullOrEmpty(ClassName)))
{
return(true);
}
try
{
// Check assembly and class
Type classObject = ClassHelper.GetClassType(AssemblyName, ClassName);
if (classObject != null)
{
// Check base class
if (String.IsNullOrEmpty(BaseClassNames) || (ClassHelper.IsAllowed(classObject, Settings)))
{
return(true);
}
}
}
catch
{
}
// Set validation error message
ValidationError = ErrorMessage;
return(false);
}
/// <summary>
/// Returns true if user control is valid.
/// </summary>
public override bool IsValid()
{
string[] values = ValidationHelper.GetString(uniSelector.Value, string.Empty).Split(new char[] { ';' });
foreach (string className in values)
{
if ((className != string.Empty) && !MacroProcessor.ContainsMacro(className))
{
DataClassInfo di = DataClassInfoProvider.GetDataClassInfo(className);
if (di == null)
{
ValidationError = GetString("formcontrols_selectcustomtable.notexist").Replace("%%code%%", className);
return(false);
}
}
}
return(true);
}
/// <summary>
/// Validates control. Returns true, if control contains double or macro.
/// </summary>
public override bool IsValid()
{
String val = txtValue.Text.Trim();
if (String.IsNullOrEmpty(val))
{
return(true);
}
if (MacroProcessor.ContainsMacro(val) || ValidationHelper.IsDouble(val))
{
return(true);
}
ErrorMessage = GetString("ecommerce.settings.doubleormacro");
return(false);
}
/// <summary>
/// Loads text into textbox from value or from 'QueryColumnName' column.
/// </summary>
/// <param name="value">Value parameter</param>
/// <returns>Returns text of options or query</returns>
private string LoadTextFromData(string value)
{
InitOptions();
txtValue.Editor.ValueIsMacro = false;
// Options data
if (!String.IsNullOrEmpty(value))
{
lstOptions.SelectedIndex = ListSourceIndex;
// Get string representation
SpecialFieldsDefinition def = new SpecialFieldsDefinition(null, FieldInfo, ContextResolver);
def.LoadFromText(value);
return(def.ToString());
}
// Query selected
if (ContainsColumn(QueryColumnName))
{
string query = ValidationHelper.GetString(Form.Data.GetValue(QueryColumnName), string.Empty).Trim();
if (!String.IsNullOrEmpty(query))
{
lstOptions.SelectedIndex = SqlSourceIndex;
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Form", "EditSQLQueries"))
{
mDisabledSql = true;
}
return(query);
}
}
// Macro data source selected
if (ContainsColumn(MacroColumnName))
{
string macro = ValidationHelper.GetString(Form.Data.GetValue(MacroColumnName), string.Empty).Trim();
if (!String.IsNullOrEmpty(macro))
{
lstOptions.SelectedIndex = MacroSourceIndex;
txtValue.Editor.ValueIsMacro = true;
return(MacroProcessor.RemoveDataMacroBrackets(macro));
}
}
return(null);
}
/// <summary>
/// Saves translation for given resource string.
/// </summary>
/// <returns>Returns TRUE if resource string was successfully modified</returns>
public override bool Save()
{
// Save changes only when translation is edited
if (IsLocalizationMacro && mUserHasPermissionForLocalizations && LocalizationExists && !IsInplaceMacro(OriginalValue))
{
string resKey = GetResourceKeyFromString(OriginalValue);
// Prevent from creating translation containing macro
if (!MacroProcessor.IsLocalizationMacro(TextBox.Text))
{
resKey = resKey.Trim();
var translationText = TextBox.Text.Trim();
if (string.IsNullOrEmpty(translationText))
{
lblError.Visible = true;
lblError.ResourceString = "localize.entertext";
return(false);
}
var cultureCode = CultureInfoProvider.GetCultureID(CultureHelper.PreferredUICultureCode) != 0
? CultureHelper.PreferredUICultureCode
: CultureHelper.DefaultUICultureCode;
if (IsTranslationChanged(resKey, cultureCode, translationText))
{
// Update / insert key
var ri = ResourceStringInfoProvider.GetResourceStringInfo(resKey) ?? new ResourceStringInfo
{
StringKey = resKey,
StringIsCustom = !SystemContext.DevelopmentMode
};
ri.TranslationText = translationText;
ri.CultureCode = cultureCode;
ResourceStringInfoProvider.SetResourceStringInfo(ri);
return(true);
}
return(false);
}
}
return(false);
}
/// <summary>
/// Fills assembly selector with data.
/// </summary>
private void FillAssemblySelector()
{
if (AllowEmpty)
{
drpAssemblyName.DropDownList.Items.Add(noneValue);
}
var classes = ClassHelper.GetClasses(ClassHelper.ASSEMBLY_APPCODE, Settings);
if ((classes != null) && (classes.Count > 0))
{
drpAssemblyName.DropDownList.Items.Add(customClassString);
}
// Get assembly names filtered by given restriction settings
var assemblies = ClassHelper.GetAssemblyNames(AssembliesFilter, Settings)
// Web site App_Code assembly are not supported. Custom class must be used instead
.Where(assemblyName => !assemblyName.StartsWith(APPCODE_PREFIX, StringComparison.OrdinalIgnoreCase));
// Fill assemblies list
foreach (string assemblyName in assemblies)
{
drpAssemblyName.DropDownList.Items.Add(assemblyName);
}
// Include macro value if specified
if (!String.IsNullOrEmpty(AssemblyName) && MacroProcessor.ContainsMacro(AssemblyName))
{
drpAssemblyName.DropDownList.Items.Insert(0, AssemblyName);
}
// Clear selected value if drop down is empty
if (drpAssemblyName.DropDownList.Items.Count == 0)
{
drpAssemblyName.SelectedValue = String.Empty;
}
else
{
// Select first item if nothing was selected
if (drpAssemblyName.SelectedIndex < 0 && String.IsNullOrEmpty(drpAssemblyName.SelectedValue))
{
drpAssemblyName.SelectedIndex = 0;
}
}
}
private void RunMacro(string macroFilePath)
{
string[] inputArray = GetInputTextArray();
string input = string.Empty;
if (inputArray.Length == 0)
{
input = string.Empty;
}
else if (inputArray.Length >= 1)
{
input = inputArray[0];
}
string result = MacroProcessor.RunMacro(input, macroFilePath);
SetOutputText(result);
}
/// <summary>
/// HAdds the a file to the package, handling any special processing necessary when
/// adding the PACKAGE.INI file.
/// </summary>
/// <param name="package">The application package.</param>
/// <param name="path">Path to he file.</param>
/// <param name="basePath">Base path.</param>
/// <returns><c>true</c> if the file processed was the PACKAGE.INI file.</returns>
private static bool AddFile(AppPackage package, string path, string basePath)
{
string file;
if (path.ToLowerInvariant().StartsWith(basePath.ToLowerInvariant() + Helper.PathSepString))
{
file = path.Substring(basePath.Length + 1);
}
else
{
file = path;
}
if (String.Compare(file, "package.ini", true) != 0)
{
package.AddFile(path, basePath);
return(false);
}
else
{
// Handle special processing of the PACKAGE.INI file.
StreamReader reader = new StreamReader(path, Encoding.UTF8);
string settings;
MacroProcessor processor;
try
{
processor = new MacroProcessor();
processor.Add("appref", package.AppRef.ToString());
settings = reader.ReadToEnd();
settings = processor.Expand(settings);
package.AddFile("Package.ini", Helper.ToUTF8(settings));
}
finally
{
reader.Close();
}
return(true);
}
}
/// <summary>
/// Fills assembly selector with data.
/// </summary>
private void FillAssemblySelector()
{
if (AllowEmpty)
{
drpAssemblyName.DropDownList.Items.Add(noneValue);
}
var classes = ClassHelper.GetClasses(ClassHelper.ASSEMBLY_APPCODE, Settings);
if ((classes != null) && (classes.Count > 0))
{
drpAssemblyName.DropDownList.Items.Add(customClassString);
}
// Get assembly names filtered by given restriction settings
var assemblies = ClassHelper.GetAssemblyNames(AssembliesFilter, Settings);
// Fill assemblies list
foreach (string assemblyName in assemblies)
{
drpAssemblyName.DropDownList.Items.Add(assemblyName);
}
// Include macro value if specified
if (!String.IsNullOrEmpty(AssemblyName) && MacroProcessor.ContainsMacro(AssemblyName))
{
drpAssemblyName.DropDownList.Items.Insert(0, AssemblyName);
}
// Clear selected value if drop down is empty
if (drpAssemblyName.DropDownList.Items.Count == 0)
{
drpAssemblyName.SelectedValue = String.Empty;
}
else
{
// Select first item if nothing was selected
if (drpAssemblyName.SelectedIndex < 0 && String.IsNullOrEmpty(drpAssemblyName.SelectedValue))
{
drpAssemblyName.SelectedIndex = 0;
}
}
}
private static string Process(MacroProcessor MP, string codeStr, int lineZero)
{
VList <LNode> output = VList <LNode> .Empty;
var msgs = new MessageHolder();
using (MessageSink.PushCurrent(msgs))
{
var code = EcsLanguageService.Value.Parse(codeStr, msgs);
if (!msgs.List.Any(m => m.Severity >= Severity.Error))
{
output = MP.ProcessSynchronously(LNode.List(code));
}
}
foreach (var m in msgs.List)
{
// Goal: add lineNo to line number of error message to get correct line number
object loc = MessageSink.LocationOf(m.Context);
SourcePos pos = default(SourcePos);
if (loc is SourceRange)
{
pos = ((SourceRange)loc).Start;
}
else if (loc is SourcePos)
{
pos = ((SourcePos)loc);
}
else
{
pos = new SourcePos("Unknown", 0, 0);
}
pos = new SourcePos(pos.FileName, pos.Line + lineZero, pos.PosInLine);
MessageSink.Current.Write(m.Severity, pos, m.Format, m.Args);
}
if (msgs.List.Any(m => m.Severity >= Severity.Error))
{
return(null);
}
else
{
return(EcsLanguageService.Value.Print(output, null, null, " ", "\n"));
}
}
public void MacroProcessor_Basic1()
{
var macros = new MacroProcessor();
macros.Add("var1", "INSERT");
Assert.AreEqual("", macros.Expand(""));
Assert.AreEqual("INSERT", macros.Expand("INSERT"));
Assert.AreEqual("INSERT", macros.Expand("$(var1)"));
Assert.AreEqual("prefix INSERT suffix", macros.Expand("prefix $(VAR1) suffix"));
Assert.AreEqual("$(none)", macros.Expand("$(none)"));
Assert.AreEqual("prefix $(none) suffix", macros.Expand("prefix $(none) suffix"));
Assert.AreEqual("$", macros.Expand("$"));
Assert.AreEqual("$(", macros.Expand("$("));
Assert.AreEqual("$hello", macros.Expand("$hello"));
Assert.AreEqual("$(hello", macros.Expand("$(hello"));
Assert.AreEqual("$(hello)", macros.Expand("$(hello)"));
Assert.AreEqual("hello)", macros.Expand("hello)"));
Assert.AreEqual("hello)world", macros.Expand("hello)world"));
}
protected void Test(LNodeList input, MacroProcessor lemp, string expected, IParsingService outLang)
{
// The current printer affects the assert macro and contract macros,
// so we'll want to set it up before running LeMP
using (LNode.SetPrinter((ILNodePrinter)outLang))
{
var inputCode = input;
var results = lemp.ProcessSynchronously(inputCode);
var expectCode = outLang.Parse(expected, MessageSink.Default);
if (!results.SequenceEqual(expectCode))
{ // TEST FAILED, print error
string resultStr = results.Select(n => ((ILNodePrinter)outLang).Print(n)).Join("\n");
Assert.AreEqual(TestCompiler.StripExtraWhitespace(expected),
TestCompiler.StripExtraWhitespace(resultStr));
// In some tests, the text is equal even though the trees are different,
// typically because of differences in #trivia attributes between the two.
Console.WriteLine("(minor dif)"); // it's OK, but print a hint that this occurred.
}
}
}
/// <summary>
/// Returns true if user control is valid.
/// </summary>
public override bool IsValid()
{
if (ReturnColumnName.EqualsCSafe("ClassName", true))
{
string[] values = ValidationHelper.GetString(uniSelector.Value, "").Split(new[] { ';' });
foreach (string className in values)
{
if ((className != "") && !MacroProcessor.ContainsMacro(className) && !className.Contains("*"))
{
DataClassInfo di = DataClassInfoProvider.GetDataClassInfo(className);
if (di == null)
{
ValidationError = GetString("formcontrols_selectclassnames.notexist").Replace("%%code%%", className);
return(false);
}
}
}
}
return(true);
}
protected void Page_Load(object sender, EventArgs e)
{
RegisterESCScript = false;
controlHash = QueryHelper.GetString("controlHash", "");
clientId = QueryHelper.GetString("clientid", "");
SetTitle(GetString("conditionbuilder.title"));
PageTitle.HelpTopicName = HELP_TOPIC_LINK;
Save += btnSave_Click;
designerElem.RuleCategoryNames = QueryHelper.GetString("module", "");
designerElem.DisplayRuleType = QueryHelper.GetInteger("ruletype", 0);
designerElem.ShowGlobalRules = QueryHelper.GetBoolean("showglobal", true);
designerElem.MacroRuleAvailability = (MacroRuleAvailabilityEnum)QueryHelper.GetInteger("macroruleavailability", 0);
// Set correct resolver to the control
string resolverName = ValidationHelper.GetString(SessionHelper.GetValue("ConditionBuilderResolver_" + controlHash), "");
if (!string.IsNullOrEmpty(resolverName))
{
designerElem.ResolverName = resolverName;
}
// Set correct default condition text
string defaultText = ValidationHelper.GetString(SessionHelper.GetValue("ConditionBuilderDefaultText_" + controlHash), "");
if (!string.IsNullOrEmpty(defaultText))
{
designerElem.DefaultConditionText = defaultText;
}
if (!RequestHelper.IsPostBack())
{
string condition = MacroProcessor.RemoveDataMacroBrackets(ValidationHelper.GetString(SessionHelper.GetValue("ConditionBuilderCondition_" + controlHash), ""));
designerElem.Value = condition;
}
CurrentMaster.PanelContent.RemoveCssClass("dialog-content");
}
