Project

Profile

Help

How to connect?
Download (21.5 KB) Statistics
| Branch: | Revision:

he / src / samples / cs / TestRunner10.0 / TestDriver.cs @ be17ef52

1
using System;
2
using System.Collections;
3
using System.Collections.Generic;
4
using System.Text;
5
using Saxon.Api;
6
using System.Xml;
7
using System.IO;
8
using System.Text.RegularExpressions;
9
using System.Globalization;
10
using TestRunner;
11

    
12

    
13
//using net.sf.saxon.Version;
14
using JFeatureKeys = net.sf.saxon.lib.FeatureKeys;
15
using javax.xml.transform.stream;
16
using System.Diagnostics;
17

    
18
namespace TestRunner
19
{
20

    
21

    
22

    
23
	public abstract class TestDriver {
24

    
25
		protected string resultsDir = null;
26
		public ResultsDocument resultsDoc;
27
		protected int successes = 0;
28
		protected int total = 200000;
29
		protected int failures = 0;
30
		protected int notrun = 0;
31
		protected int wrongErrorResults = 0;
32
		protected bool unfolded = false;
33
		protected bool saveResults = false;
34
		protected int generateByteCode = 0;
35
		protected TreeModel treeModel = TreeModel.TinyTree; //TODO test .net dom
36
		protected bool debug = false;
37
		protected Regex testPattern = null;
38
		protected string requestedTestSet = null;
39
		protected string testSuiteDir;
40
		protected Processor driverProc = new Processor(true);
41
		protected Serializer driverSerializer;
42
		protected Spec spec;
43
		protected Dictionary<string, XdmNode> exceptionsMap = new Dictionary<string, XdmNode>();
44
		protected Dictionary<string, Environment> globalEnvironments = new Dictionary<string, Environment>();
45
		protected Dictionary<string, Environment> localEnvironments = new Dictionary<string, Environment>();
46
		protected Dictionary<string, string> optimizationAssertions = new Dictionary<string, string>();
47
        public Dictionary<Uri, string> queryModules = new Dictionary<Uri, string>();
48
        protected IFeedbackListener feedback = new DefaultFeedbackListener();
49
		protected bool useXslt30Transformer = true;  // Temporary for controlling test processor
50
        protected bool strict = false;
51

    
52

    
53
        static HashSet<string> unsharedEnvironments = new HashSet<string>();
54
		protected bool export = false;
55
		private string exceptionsFileName = "exceptions.xml";
56

    
57
		public abstract string catalogNamespace();
58

    
59
		public int GenerateByteCode {
60
			get { return generateByteCode; }
61
			set { generateByteCode = value; }
62
		}
63

    
64
		public class DefaultFeedbackListener : IFeedbackListener
65
		{
66

    
67
			public void Feedback(int passed, int failed, int total)
68
			{
69
				Console.WriteLine("Done " + (passed + failed) + " of " + total);
70
				//Trace.WriteLine("Done " + (passed + failed) + " of " + total);
71

    
72
			}
73

    
74

    
75
			public void Message(String message, bool popup)
76
			{
77
				try {
78
					Console.WriteLine(message);
79
					//Trace.WriteLine(message);
80
				} catch (Exception e) {
81
					Console.WriteLine("issue with the message");
82

    
83
				}
84

    
85
			}
86
		}
87

    
88

    
89
		public Spec Spec {
90
			get { return spec; }
91
		}
92
		public void setFeedbackListener(IFeedbackListener f)
93
		{
94
			feedback = f;
95
		}
96

    
97
		public int Failures
98
		{
99
			get { return failures; }
100
			set { failures = value; }
101
		}
102

    
103
		public bool Unfolded
104
		{
105
			get { return unfolded; }
106
			set { unfolded = value; }
107
		}
108

    
109
		public TreeModel TreeModel
110
		{
111
			get { return treeModel; }
112
			set { treeModel = value; }
113
		}
114
		public void go(string[] args) {
115

    
116
			//    AutoActivate.activate(driverProc);
117
			driverSerializer = driverProc.NewSerializer();
118
			//testSuiteDir = args[0];
119

    
120
			Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
121

    
122
			testSuiteDir = args[0];
123
			if (testSuiteDir.EndsWith("/"))
124
			{
125
				testSuiteDir = testSuiteDir.Substring(0, testSuiteDir.Length - 1);
126
			}
127

    
128

    
129
			resultsDir = args[1];
130
			if (resultsDir.EndsWith("/"))
131
			{
132
				resultsDir = resultsDir.Substring(0, resultsDir.Length - 1);
133
			}
134
			string catalog = testSuiteDir + "/catalog.xml";
135
			string specStr = null;
136

    
137
			for (int i = 2; i < args.Length; i++) {
138
				if (args[i].StartsWith("-t:")) {
139
					testPattern = new Regex(args[i].Substring(3));
140
				}
141
				if (args[i].StartsWith("-s:")) {
142
					requestedTestSet = args[i].Substring(3);
143
				}
144
				if (args[i].StartsWith("-debug")) {
145
					debug = true;
146
				}
147
				if (args[i].Equals("-unfolded")) {
148
					unfolded = true;
149
				}
150
                if (args[i].Equals("-strict"))
151
                {
152
                    export = true;
153
                }
154
                if (args[i].Equals("-export"))
155
				{
156
					export = true;
157
				}
158
				if (args[i].Equals("-save"))
159
				{
160
					saveResults = true;
161
				}
162
				if (args[i].StartsWith("-bytecode"))
163
				{
164
					if (args[i].Substring(10).Equals("on"))
165
					{
166
						generateByteCode = 1;
167
					}
168
					else if (args[i].Substring(10).Equals("debug"))
169
					{
170
						generateByteCode = 2;
171
					}
172
					else
173
					{
174
						generateByteCode = 0;
175
					}
176
				}
177
				/* if (args[i].StartsWith("-tree"))
178
				 {
179
					 if (args[i].Substring(6).EqualsIgnoreCase("dom"))
180
					 {
181
						 treeModel = new DOMObjectModel();
182
					 }
183
					 else if (args[i].Substring(6).EqualsIgnoreCase("jdom"))
184
					 {
185
						 treeModel = new JDOMObjectModel();
186
					 }
187
					 else if (args[i].Substring(6).EqualsIgnoreCase("jdom2"))
188
					 {
189
						 treeModel = new JDOM2ObjectModel();
190
					 }
191
					 else if (args[i].Substring(6).EqualsIgnoreCase("dom4j"))
192
					 {
193
						 treeModel = new DOM4JObjectModel();
194
					 }
195
					 else if (args[i].Substring(6).EqualsIgnoreCase("xom"))
196
					 {
197
						 treeModel = new XOMObjectModel();
198
					 }
199
					 else if (args[i].Substring(6).EqualsIgnoreCase("axiom"))
200
					 {
201
						 treeModel = new AxiomObjectModel();
202
					 }
203
					 else if (args[i].Substring(6).EqualsIgnoreCase("tinytree"))
204
					 {
205
						 treeModel = TreeModel.TINY_TREE;
206
					 }
207
					 else if (args[i].Substring(6).EqualsIgnoreCase("condensed"))
208
					 {
209
						 treeModel = TreeModel.TINY_TREE_CONDENSED;
210
					 }
211
					 else if (args[i].Substring(6).EqualsIgnoreCase("linked"))
212
					 {
213
						 treeModel = TreeModel.LINKED_TREE;
214
					 }
215
					 else
216
					 {
217
						 throw new Exception("The TreeModel specified does not exist");
218
					 }
219
				 }*/
220
				if (args[i].StartsWith("-lang"))
221
				{
222
					specStr = args[i].Substring(6);
223
					processSpec(specStr);
224
				}
225

    
226
				// Temporary for controlling test processor
227
				if (args[i].StartsWith("-xt30")) {
228
					if (args[i].Substring(6).Equals("on")) {
229
						useXslt30Transformer = true;
230
					} else if (args[i].Substring(6).Equals("off")) {
231
						useXslt30Transformer = false;
232
					}
233
				}
234
			}
235
			if (resultsDir == null)
236
			{
237
				feedback.Message("No results directory specified (use -o:dirname)", true);
238
				/*if (guiForm == null)
239
				{
240
					System.exit(2);
241
				}*/
242
			}
243
			if (resultsDoc == null)
244
			{
245
				feedback.Message("No results document specified (use -lang option)", true);
246
				/*if (guiForm == null)
247
				{
248
					System.exit(2);
249
				}*/
250
			}
251

    
252
			driverSerializer.SetOutputStream(System.Console.OpenStandardError());
253
			driverSerializer.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes");
254
			processCatalog(catalog);
255
			printResults(resultsDir + "/results" + driverProc.ProductVersion + ".xml");
256
		}
257

    
258
		public string getResultsDir() {
259
			return resultsDir;
260
		}
261

    
262
        public void RegisterXQueryModule(Uri uri,String resource) {
263
            queryModules.Add(uri, resource);
264
        }
265

    
266
		public abstract void processSpec(string specStr);
267

    
268
		internal class MyLogger : net.sf.saxon.lib.Logger
269
		{
270
			StreamWriter writer;
271

    
272
			public MyLogger() {
273
			   // writer =File.CreateText("logger.txt");
274
			   
275
			}
276
			public override StreamResult asStreamResult()
277
			{
278
				return null;
279
			}
280

    
281
			public override void println(string str, int i)
282
			{
283
				Trace.WriteLine(str);
284
			 //  writer.WriteLine(str);
285
			}
286
		}
287

    
288

    
289
		private void processCatalog(String catalogFile) {
290
	   if (generateByteCode == 1) {
291
			driverProc.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "true");
292
			driverProc.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "false");
293
		} else if (generateByteCode == 2) {
294
			driverProc.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "true");
295
			driverProc.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "true");
296
		} else {
297
			driverProc.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "false");
298
			driverProc.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "false");
299
		}
300
		 
301
		DocumentBuilder catbuilder = driverProc.NewDocumentBuilder();
302
		catbuilder.TreeModel = treeModel;
303
		XdmNode catalog = catbuilder.Build(new Uri(catalogFile)); 
304
		XPathCompiler xpc = driverProc.NewXPathCompiler();
305
		//xpc.XPathLanguageVersion = "3.1";
306
		xpc.Caching = true;
307
		xpc.DeclareNamespace("", catalogNamespace());
308

    
309
		createGlobalEnvironments(catalog, xpc);
310

    
311
		try {
312
			writeResultFilePreamble(driverProc, catalog);
313
		} catch (Exception e) {
314
			System.Console.WriteLine(e.Message);
315
		}
316

    
317
		readExceptionsFile();
318

    
319

    
320
		if (requestedTestSet != null) {
321
			try {
322
				XdmNode funcSetNode = (XdmNode) xpc.EvaluateSingle("//test-set[@name='" + requestedTestSet + "']", catalog);
323
				if (funcSetNode == null) {
324
					throw new Exception("Test-set " + requestedTestSet + " not found!");
325
				}
326
				processTestSet(catbuilder, xpc, funcSetNode);
327
			} catch (Exception e1) {
328
				//e1.printStackTrace();
329
				System.Console.WriteLine(e1.Message);
330
			}
331
		} else {
332
			foreach (XdmItem testSet in xpc.Evaluate("//test-set", catalog)) {
333
				processTestSet(catbuilder, xpc, ((XdmNode) testSet.Simplify));
334
			}
335
		}
336
		try {
337
			writeResultFilePostamble();
338
		} catch (Exception e) {
339
			System.Console.WriteLine(e.Message);
340
			//e.printStackTrace();
341
		}
342

    
343

    
344
	}
345

    
346
	protected String GetNameOfExceptionsFile()
347
	{
348
			return exceptionsFileName;
349
	}
350

    
351
		/**
352
		 * Look for an exceptions.xml document with the general format:
353
		 * <p/>
354
		 * <exceptions xmlns="...test catalog namespace...">
355
		 * <exception test-set ="testset1" test-case="testcase" run="yes/no/not-unfolded"
356
		 * bug="bug-reference" reason="">
357
		 * <results>
358
		 * ... alternative expected results ...
359
		 * </results>
360
		 * <optimization>
361
		 * ... assertions about the "explain" tree
362
		 * </optimization>
363
		 * </exception>
364
		 * </exceptions>
365
		 */
366

    
367
		protected void readExceptionsFile() {
368

    
369
		XdmNode exceptionsDoc = null;
370
		DocumentBuilder exceptBuilder = driverProc.NewDocumentBuilder();
371
			QName testSet = new QName("", "test-set");
372
			QName testCase = new QName("", "test-case");
373
		QName run = new QName("", "run");
374
		QName edition = new QName("", "edition");
375
		string saxonEdition = driverProc.Edition;
376

    
377
		try {
378
			String suppliedName = GetNameOfExceptionsFile();
379
			Uri exceptionsFile;
380
			Match m = Regex.Match(suppliedName, "^[a-zA-Z]:.*");
381
			   
382
			if (suppliedName.StartsWith("/") || m.Success) {
383
					exceptionsFile = new Uri(suppliedName);
384
			} else
385
			{
386
					exceptionsFile = new Uri(resultsDir + "/" + suppliedName);
387
			}
388
		   Console.WriteLine("Loading exceptions file " + exceptionsFile.AbsolutePath);
389
		   exceptionsDoc = exceptBuilder.Build(exceptionsFile);
390
		   IEnumerator<XdmNode> iter = exceptionsDoc.EnumerateAxis(XdmAxis.Descendant, new QName("", "exception"));
391
			
392
			while (iter.MoveNext()) {
393
				XdmNode entry = iter.Current;
394
				string testName = entry.GetAttributeValue(testCase);
395
				if (testName == null) {
396
						testName = "$" + entry.GetAttributeValue(testSet);
397
				}
398
                    string runVal = entry.GetAttributeValue(run);
399
                    string editionVal = entry.GetAttributeValue(edition);
400
                    if (runVal == null)
401
                    {
402
                        runVal = "false";
403
                    }
404
                    if (editionVal == null)
405
                    {
406
                        editionVal = saxonEdition;
407
                    }
408
                    bool appliesThisEdition = false;
409
                    string[] substrings = Regex.Split(editionVal.Trim(), "\\s+");
410
                    foreach (String ed in substrings)
411
                    {
412
                        if (ed.Equals(saxonEdition))
413
                        {
414
                            appliesThisEdition = true;
415
                            break;
416
                        }
417
                    }
418
                    if (appliesThisEdition)
419
                    {
420
                        if (runVal.Equals("false"))
421
                        {
422
                            string[] substrings2 = Regex.Split(testName.Trim(), "\\s+");
423
                            foreach (String tc in substrings2)
424
                            {
425
                                exceptionsMap.Add(tc, entry);
426
                            }
427
                        }
428
                        else
429
                        {
430
                            IEnumerator<XdmNode> iter2 = entry.EnumerateAxis(XdmAxis.Child, new QName("optimization"));
431
                            bool moved = iter.MoveNext();
432
                            if (moved)
433
                            {
434
                                XdmNode optim = iter2.Current;
435
                                optimizationAssertions.Add(testName, optim.GetAttributeValue("assert"));
436
                            }
437
                        }
438
                    }
439
                }
440
            
441

    
442
        } catch (Exception e) {
443
			feedback.Message("*** Failed to process exceptions file: "+ e.Message, true);
444
			//printError("*** Failed to process exceptions file: ", e.getMessage()); //TODO - review this code later
445
		}
446

    
447
	}
448

    
449
	protected abstract void createGlobalEnvironments(
450
			XdmNode catalog, XPathCompiler xpc);
451

    
452
	protected void createLocalEnvironments(XdmNode testSetDocNode) {
453
		localEnvironments.Clear();
454
		Environment defaultEnvironment =
455
				Environment.createLocalEnvironment(testSetDocNode.BaseUri, generateByteCode, unfolded, spec);
456
		localEnvironments.Add("default", defaultEnvironment);
457
	}
458

    
459
	protected Environment getEnvironment(XdmNode testCase, XPathCompiler xpc) {
460
		string testCaseName = testCase.GetAttributeValue(new QName("name"));
461
		XdmNode environmentNode = (XdmNode) xpc.EvaluateSingle("environment", testCase);
462
		Environment env;
463
		if (environmentNode == null) {
464
			env = localEnvironments["default"];
465
		} else {
466
			string envName = environmentNode.GetAttributeValue(new QName("ref"));
467
			if (envName == null || envName.Equals("")) {
468
				env = Environment.processEnvironment(this, xpc, environmentNode, null, localEnvironments["default"]);
469
				bool baseUriCheck = ((XdmAtomicValue) xpc.EvaluateSingle("static-base-uri/@uri='#UNDEFINED'", environmentNode)).GetBooleanValue();
470
				if (baseUriCheck) {
471
					//writeTestcaseElement(testCaseName, "notRun", "static-base-uri not supported", null);
472
					return null;
473
				}
474
			} else {
475
				try
476
				{
477
					env = localEnvironments[envName];
478
				}catch(Exception){
479
					env = null;
480
				}
481
				if (env == null) {
482
					try
483
					{
484
						env = globalEnvironments[envName];
485
					}
486
					catch (Exception e) { }
487
				}
488
				if (env == null) {
489
					foreach (XdmNode e in testCase.Parent.Select(Steps.Descendant("environment").Where(Predicates.AttributeEq("name", envName)))) {
490
						Environment.processEnvironment(this, xpc, e, localEnvironments, localEnvironments["default"]);
491
					}
492
					try
493
					{
494
						env = localEnvironments[envName];
495
					} catch(Exception e) {}
496
				}
497
				if (env == null) {
498
					System.Console.WriteLine("*** Unknown environment " + envName);
499
					//println("*** Unknown environment " + envName);
500
					//writeTestcaseElement(testCaseName, "fail", "Environment " + envName + " not found", null);
501
					failures++;
502
					return null;
503
				}
504

    
505
			}
506
		}
507
		return env;
508
	}
509

    
510
	public void writeResultFilePreamble(Processor processor, XdmNode catalog) {
511
		resultsDoc.writeResultFilePreamble(processor, catalog);
512
	}
513

    
514
	public void writeResultFilePostamble(){
515
		resultsDoc.writeResultFilePostamble();
516
	}
517

    
518
	public void startTestSetElement(XdmNode testSetNode) {
519
		resultsDoc.startTestSetElement(testSetNode);
520
	}
521

    
522
	public void writeTestSetEndElement() {
523
		resultsDoc.endElement();
524
	}
525

    
526

    
527
	private void processTestSet(DocumentBuilder catbuilder, XPathCompiler xpc, XdmNode testSetNode) {
528
		string testName;
529
		string testSet;
530
		startTestSetElement(testSetNode);
531
		Uri testSetFile = new Uri(testSuiteDir + "/" + testSetNode.GetAttributeValue(new QName("file")));
532
		XdmNode testSetDocNode = catbuilder.Build(testSetFile);
533
		createLocalEnvironments(testSetDocNode);
534
		bool run = true;
535
		  
536
		IEnumerable<XdmNode> testdocEnum = testSetDocNode.Select(Steps.Child("test-set").Then(Steps.Child("dependency")));
537
		  
538
	   IEnumerator<XdmNode> testDocEnumerator = testdocEnum.GetEnumerator();
539
		if (testDocEnumerator.MoveNext()) {  
540
				 // pick up any test-set level dependencies in the QT3 catalog
541
				foreach (XdmNode dependency in testSetDocNode.Select(Steps.Child("test-set").Then(Steps.Child("dependency"))) ) {
542
				if (!EnsureDependencySatisfied( dependency, localEnvironments["default"])) {
543
						foreach (XdmNode testCase in testSetDocNode.Select(Steps.Descendant("test-case"))) {
544
							String testCaseName = testCase.GetAttributeValue("name");
545
							resultsDoc.writeTestcaseElement(testCaseName, "n/a", "test-set dependencies not satisfied");
546
							notrun++;
547
						}
548
						run = false;
549
						break;
550
					}
551
			}
552

    
553
				// pick up any test-set level dependencies in the QT3 catalog
554
				foreach (XdmNode dependency in testSetDocNode.Select(Steps.Path("test-set", "dependencies", "*" ))) {
555
					if (!EnsureDependencySatisfied(dependency, localEnvironments["default"]))
556
					{
557
						foreach (XdmNode testCase in testSetDocNode.Select(Steps.Descendant("test-case")))
558
						{
559
							String type = dependency.NodeName.LocalName;
560
							String value = testCase.GetAttributeValue("value");
561
							if (value == null)
562
							{
563
								value = type;
564
							}
565
							else {
566
								value = type + ":" + value;
567
							}
568
							if ("false".Equals(dependency.GetAttributeValue("satisfied"))) {
569
								value = "!" + value;
570
							}
571
							String testCaseName = testCase.GetAttributeValue("name");
572
							resultsDoc.writeTestcaseElement(testCaseName, "n/a", "test-set dependencies not satisfied: "+ value);
573
							notrun++;
574
						}
575
						run = false;
576
						break;
577

    
578
					}
579

    
580

    
581
				}
582
		}
583
		if (run) {
584
			if (testPattern == null) {
585
				foreach (XdmNode env in testSetDocNode.Select(Steps.Descendant("environment").Where(Predicates.HasAttribute("name")))) { // xpc.Evaluate("//environment[@name]", testSetDocNode)) {
586
						String envName = env.GetAttributeValue("name");
587
						if (!unsharedEnvironments.Contains(envName))
588
						{
589
							try
590
							{
591
								Environment.processEnvironment(this, xpc, env, localEnvironments, localEnvironments["default"]);
592
							}
593
							catch (Exception ex)
594
							{
595
								Console.WriteLine("Failure loading environment, in processTestSet "+ ex.Message);
596
							}
597
						}
598
						
599
				}
600
			}
601
				IEnumerator<XdmNode> testEnum = testSetDocNode.Select(Steps.Path("/", "test-set", "@name" )).GetEnumerator();
602
				if (testEnum.MoveNext() == false) {
603
					Console.WriteLine("Test-set does not have a @name attribute");
604
					return;
605
				}
606
				testSet = testEnum.Current.GetStringValue();
607

    
608
				IEnumerable<XdmNode> enumerable = testSetDocNode.Select(Steps.Descendant("test-case"));
609
					
610
			   foreach(XdmNode testCase in enumerable) {
611
					String name = testCase.GetAttributeValue("name");
612
					if (testPattern == null || testPattern.Match(name).Success)
613
					{
614
						println("-s:" + testSet + " -t:" + name);
615

    
616
						try
617
						{
618
							runTestCase(testCase, xpc);
619
						}
620
						catch (Exception ex)
621
						{
622
							
623
							Console.WriteLine("*** Error in evaluating testcase:" + ex.Message);
624
						}
625
					}
626
				}
627

    
628

    
629

    
630
				// testSet = testSetDocNode.Select(Steps.Path(new List<String> {"/", "test-set", "@name" })).GetEnumerator(). xpc.EvaluateSingle("/test-set/@name", testSetDocNode).GetStringValue();
631
				//foreach (XdmItem testCase in xpc.Evaluate("//test-case", testSetDocNode)) {
632

    
633
				//testName = xpc.EvaluateSingle("@name", testCase).GetStringValue();
634
				
635
			
636
		}
637
		writeTestSetEndElement();
638
	}
639

    
640
	protected abstract void runTestCase(XdmNode testCase, XPathCompiler catalogXpc);
641

    
642
	//public void setTestDriverForm(TestDriverForm gui) {
643
	//    guiForm = gui;
644
	//}
645

    
646
	public void println(string data)
647
	{
648
		//if (guiForm != null)
649
		//{
650
			//guiForm.setResultTextArea(data);
651
		//}
652
		//else
653
		{
654
			feedback.Message(data+"\n", false);
655
		}
656
	}
657

    
658
	public void printResults(string resultsFileStr)
659
	{
660
	   /* if (guiForm != null)
661
		{
662
			guiForm.printResults("Result: " + successes + " successes, " + failures + " failures, " + wrongErrorResults + " incorrect ErrorCode, " + notrun + " not run", resultsFileStr, resultsDir);
663
		}
664
		else
665
		{*/
666
		feedback.Message(successes + " successes, " + failures + " failures, " + wrongErrorResults + " incorrect ErrorCode, " + notrun + " not run", false);
667
		//}
668
	}
669

    
670
	public void printError(string error, string message)
671
	{
672
		/*if (guiForm != null)
673
		{
674
			guiForm.errorPopup(error);
675
			System.err.println(error + message);
676
		}
677
		else
678
		{*/
679
		feedback.Message(error + message, true);
680
		//}
681
	}
682

    
683
	public abstract bool EnsureDependencySatisfied(XdmNode dependency, Environment env);
684

    
685
}
686

    
687
//
688
// The contents of this file are subject to the Mozilla Public License Version 1.0 (the "License");
689
// you may not use this file except in compliance with the License. You may obtain a copy of the
690
// License at http://www.mozilla.org/MPL/
691
//
692
// Software distributed under the License is distributed on an "AS IS" basis,
693
// WITHOUT WARRANTY OF ANY KIND, either express or implied.
694
// See the License for the specific language governing rights and limitations under the License.
695
//
696
// The Original Code is: all this file.
697
//
698
// The Initial Developer of the Original Code is Saxonica Limited
699
//
700
// Portions created by (your name) are Copyright (C) (your legal entity). All Rights Reserved.
701
//
702
// Contributor(s): none.
703
//
704

    
705
}
(10-10/19)