public void Verify_cannot_add_fields_with_same_identifier() { ISchemaValidator validator = new SchemaValidator(); var schema = Schema.Builder() .Field <Struct>(x => { return(x.Id("field1") .Field <Primitive>(f => f.Id("fieldA").DataType(SchemaDataType.Primitive).IsNullable().Build()) .Field <Primitive>(f => f.Id("fieldB").DataType(SchemaDataType.Primitive).IsNullable().Build()) .Field <Primitive>(f => f.Id("fieldC").DataType(SchemaDataType.Primitive).IsNullable().Build()) .Field <Decimal>(f => f.Id("fieldD").Precision(5).Scale(2).IsNullable().Build()) .Build()); }) .Field <Primitive>(x => x.Id("field2").IsNullable().Build()) .Field <Primitive>(x => x.Id("field3").IsNullable().Build()) .Field <Primitive>(x => x.Id("field4").IsNullable().Build()) .Field <Primitive>(x => x.Id("field5").IsNullable().Build()) .Field <Primitive>(x => x.Id("field6").IsNullable().Build()) .Field <Primitive>(x => x.Id("field3").IsNullable().Build()) .Field(null) .RegisterObserver(validator) .Build(); // .Validate(); validator.Validate(); // Assert.IsTrue(schema.Fields.HasValues); // Assert.AreEqual(7, schema.Fields.Count); // // Assert.IsNotEmpty(validator.Validation); // Assert.AreEqual(1, validator.Validation.Count); }
/// <summary> /// Used to obtain access tokens for the EPiServer ServiceAPI. request an access token for a username, password couplet - Authorize /// </summary> /// <param name="request">Models.TokenPostRequest</param> /// <param name="responseFormatters">response formmaters</param> public virtual async Task<Models.TokenPostResponse> Post(Models.TokenPostRequest request, IEnumerable<MediaTypeFormatter> responseFormatters = null) { var url = "token"; var req = new HttpRequestMessage(HttpMethod.Post, url); if (request.RawHeaders != null) { foreach (var header in request.RawHeaders) { req.Headers.TryAddWithoutValidation(header.Key, string.Join(",", header.Value)); } } req.Content = request.Content; var response = await proxy.Client.SendAsync(req); if (proxy.SchemaValidation.Enabled && proxy.SchemaValidation.RaiseExceptions) { if (proxy.SchemaValidation.RaiseExceptions) { await SchemaValidator.ValidateWithExceptionAsync(Models.TokenPostResponse.GetSchema(ApiMultipleResponse.GetValueAsString(response.StatusCode)), response.Content); } } return new Models.TokenPostResponse { RawContent = response.Content, RawHeaders = response.Headers, Formatters = responseFormatters, StatusCode = response.StatusCode, ReasonPhrase = response.ReasonPhrase, SchemaValidation = new Lazy<SchemaValidationResults>(() => SchemaValidator.IsValid(Models.TokenPostResponse.GetSchema(ApiMultipleResponse.GetValueAsString(response.StatusCode)), response.Content), true) }; }
/// <summary> /// Processes the SQL map element. /// </summary> /// <param name="element">The element.</param> /// <param name="configurationStore">The configuration store.</param> private void ProcessSqlMapElement(Tag element, IConfigurationStore configurationStore) { if (element.Attributes.ContainsKey(ConfigConstants.ATTRIBUTE_URI)) { string uri = element.Attributes[ConfigConstants.ATTRIBUTE_URI]; IResource resource = ResourceLoaderRegistry.GetResource(uri); Contract.Assert.That(resource, Is.Not.Null).When("process Resource in ConfigurationInterpreter"); using (resource) { IConfiguration setting = configurationStore.Settings[ConfigConstants.ATTRIBUTE_VALIDATE_SQLMAP]; if (setting != null) { bool mustValidate = false; Boolean.TryParse(setting.Value, out mustValidate); if (mustValidate) { XmlDocument document = new XmlDocument(); document.Load(resource.Stream); SchemaValidator.Validate(document.ChildNodes[1], "SqlMap.xsd"); } } resource.Stream.Position = 0; using (XmlTextReader reader = new XmlTextReader(resource.Stream)) { using (XmlMappingProcessor processor = new XmlMappingProcessor()) { processor.Process(reader, configurationStore); } } } } }
public SchemaValidationTest() { this._validator07 = new SchemaValidator(); this._validator201 = new SchemaValidator(); this._validator21b = new SchemaValidator(); this._validator21 = new SchemaValidator(); }
/// <summary> /// Versioning the EPiServer ServiceAPI. Obtain the version of the EPiServer ServiceAPI - Api Version /// </summary> /// <param name="request">ApiRequest</param> /// <param name="responseFormatters">response formmaters</param> public virtual async Task<Models.VersionGetResponse> Get(ApiRequest request, IEnumerable<MediaTypeFormatter> responseFormatters = null) { var url = "version"; var req = new HttpRequestMessage(HttpMethod.Get, url); if (string.IsNullOrEmpty(proxy.OAuthAccessToken)) throw new InvalidOperationException("This API call is secured with OAuth, you must provide an access token (set OAuthAccessToken before calling this method)"); req.Headers.Add("Authorization", "Bearer " + proxy.OAuthAccessToken); if (request.RawHeaders != null) { foreach (var header in request.RawHeaders) { req.Headers.TryAddWithoutValidation(header.Key, string.Join(",", header.Value)); } } var response = await proxy.Client.SendAsync(req); if (proxy.SchemaValidation.Enabled && proxy.SchemaValidation.RaiseExceptions) { if (proxy.SchemaValidation.RaiseExceptions) { await SchemaValidator.ValidateWithExceptionAsync("{ \"$schema\": \"http://json-schema.org/draft-04/schema#\", \"title\": \"API Version\", \"description\": \"A Version description for the EPiServer ServiceAPI\", \"type\": \"object\", \"properties\": { \"Component\": { \"type\": \"string\" }, \"Version\": { \"type\": \"string\" } }, \"required\": [\"Component\", \"Version\"]}", response.Content); } } return new Models.VersionGetResponse { RawContent = response.Content, RawHeaders = response.Headers, Formatters = responseFormatters, StatusCode = response.StatusCode, ReasonPhrase = response.ReasonPhrase, SchemaValidation = new Lazy<SchemaValidationResults>(() => SchemaValidator.IsValid("{ \"$schema\": \"http://json-schema.org/draft-04/schema#\", \"title\": \"API Version\", \"description\": \"A Version description for the EPiServer ServiceAPI\", \"type\": \"object\", \"properties\": { \"Component\": { \"type\": \"string\" }, \"Version\": { \"type\": \"string\" } }, \"required\": [\"Component\", \"Version\"]}", response.Content), true) }; }
public void Validate_Failed() { var schemaValidator = new SchemaValidator(new EmbeddedResourceResolver(typeof(Mim.V6301.POCD_IN150001UK06).Assembly)); var result = schemaValidator.Validate("POCD_IN150001UK06.xsd", _localResolver.GetResourceStream("POCD_EX150001UK06_05Invalid.xml").GetText()); Assert.False(result.Status); }
private static async Task SendMessageAsync <T>(Options options, T payload) { var consumer = GetSchemaConsumer(options); var validator = new SchemaValidator() .WithSchemaConsumer(consumer); var factory = MessagingFactory.CreateFromConnectionString(options.ServiceBusConnectionString); var serialised = JsonConvert.SerializeObject(payload, Settings.SerializerSettings); var body = Encoding.UTF8.GetBytes(serialised); using (var stream = new MemoryStream(body)) using (var message = new BrokeredMessage(stream)) { message.Properties.Add("schemaPath", $"{options.BlobBaseUri.TrimEnd('/')}/{options.Container.Trim('/')}/{options.Filepath.TrimStart('/')}"); var topic = factory.CreateTopicClient(options.Topic); var validated = await message.ValidateAsync(validator) .ConfigureAwait(false); await topic.SendAsync(validated) .ConfigureAwait(false); } Console.WriteLine(MessageSent); }
public void Initialize( Func <ISchema> schemaResolver, IReadOnlySchemaOptions options) { if (schemaResolver == null) { throw new ArgumentNullException(nameof(schemaResolver)); } if (options is null) { throw new ArgumentNullException(nameof(options)); } if (RegisterTypes()) { RegisterImplicitInterfaceDependencies(); CompleteNames(schemaResolver); MergeTypeExtensions(); RegisterExternalResolvers(); CompileResolvers(); CompleteTypes(); } _errors.AddRange(SchemaValidator.Validate( _types.Select(t => t.Value.Type), options)); if (_errors.Count > 0) { throw new SchemaException(_errors); } }
public void TestSchema_SampleFiles_AllAreValid() { Dictionary <string, List <string> > filesAndErrors = new Dictionary <string, List <string> >(); foreach (var manifest in TestUtils.GetSampleProjectsRoot().EnumerateFiles($"*.*", SearchOption.AllDirectories).Where(x => x.FullName.EndsWith(Strings.ManifestSuffix, StringComparison.OrdinalIgnoreCase))) { string text = File.ReadAllText(manifest.FullName); var xDoc = XDocument.Parse(text); var validator = new SchemaValidator(); var errors = validator.ValidateManifest(xDoc); filesAndErrors.Add(manifest.FullName, errors); } filesAndErrors.Count.Should().BeGreaterOrEqualTo(2); if (filesAndErrors.SelectMany(x => x.Value).Any()) { var sb = new StringBuilder(); foreach (KeyValuePair <string, List <string> > fileAndError in filesAndErrors) { if (fileAndError.Value.Any()) { sb.AppendLine($"File {fileAndError.Key} errors: \r\n\r\n{string.Join("\r\n", fileAndError.Value)}"); } } Assert.Fail(sb.ToString()); } }
/// <summary> /// gets an order by id /// </summary> /// <param name="id"></param> public virtual async Task <Models.OrdersGetResponse> Get(string id) { var url = "orders/{id}"; url = url.Replace("{id}", id.ToString()); var req = new HttpRequestMessage(HttpMethod.Get, url); var response = await proxy.Client.SendAsync(req); if (proxy.SchemaValidation.Enabled) { if (proxy.SchemaValidation.RaiseExceptions) { await SchemaValidator.ValidateWithExceptionAsync("", response.Content); } } return(new Models.OrdersGetResponse { RawContent = response.Content, RawHeaders = response.Headers, StatusCode = response.StatusCode, ReasonPhrase = response.ReasonPhrase, SchemaValidation = new Lazy <SchemaValidationResults>(() => SchemaValidator.IsValid("", response.Content), true) }); }
private void runSchemaValidatorTest(string reportFileName, CultureInfo testCulture) { // Preserve current culture CultureInfo previousCulture = Thread.CurrentThread.CurrentCulture; // Enable test culture Thread.CurrentThread.CurrentCulture = testCulture; try { string testsDll = "mock-assembly.dll"; TestSuiteBuilder builder = new TestSuiteBuilder(); Test suite = builder.Build(new TestPackage(testsDll)); TestResult result = suite.Run(NullListener.NULL); XmlResultVisitor visitor = new XmlResultVisitor(reportFileName, result); result.Accept(visitor); visitor.Write(); SchemaValidator validator = new SchemaValidator(reportFileName, schemaFile.Path); Assert.IsTrue(validator.Validate(), "validate failed"); } finally { // Restore previous culture Thread.CurrentThread.CurrentCulture = previousCulture; } }
public ISessionFactory GetSessionFactory() { NHibernateProfiler.Initialize(); var config = Fluently.Configure() .Database(_databaseConfig) .Mappings(m => m.AutoMappings .Add(AutoMap.AssemblyOf <NHibernateConfiguration <SqlClientDriver> >() .Where(type => type.Namespace != null && type.Namespace.EndsWith("Entities")) .UseOverridesFromAssemblyOf <NHibernateConfiguration <SqlClientDriver> >() ) ) // Ensure batching is used .ExposeConfiguration(c => c.SetProperty(Environment.BatchSize, "10")) // Turn off cache to make sure all calls actually go to the database .ExposeConfiguration(c => c.SetProperty(Environment.UseQueryCache, "false")) .ExposeConfiguration(c => c.SetProperty(Environment.UseSecondLevelCache, "false")); if (typeof(LocalTestingReliableSql2008ClientDriver).IsAssignableFrom(typeof(T))) { config.ExposeConfiguration(c => c.SetProperty(Environment.TransactionStrategy, typeof(ReliableAdoNetWithDistributedTransactionFactory).AssemblyQualifiedName)); } var nhConfig = config.BuildConfiguration(); SchemaMetadataUpdater.QuoteTableAndColumns(nhConfig); var validator = new SchemaValidator(nhConfig); validator.Validate(); return(config.BuildSessionFactory()); }
public void LeafElementValidateTest() { string runOuterXml = "<w:r xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">" + "<w:rPr><w:strike /><w:vanish><!-- comments is OK --></w:vanish><w:webHidden><w:invalidChild /></w:webHidden></w:rPr>" + "<w:t>Run Text.</w:t><w:t><!-- comments is ok -->Text 2</w:t><w:t>Text 3.<invalidElement /></w:t></w:r>"; var target = new SchemaValidator(); var openxmlElement = new Run(runOuterXml); var result = target.Validate(openxmlElement); Assert.Collection( result, error => { Assert.Same(openxmlElement.LastChild, error.Node); Assert.Equal("Sch_InvalidChildinLeafElement", error.Id); Assert.Equal("The element 'http://schemas.openxmlformats.org/wordprocessingml/2006/main:t' is a leaf element and cannot contain children.", error.Description); }, error => { Assert.Same(openxmlElement.GetFirstChild <RunProperties>().WebHidden, error.Node); Assert.Equal("Sch_InvalidChildinLeafElement", error.Id); Assert.Equal("The element 'http://schemas.openxmlformats.org/wordprocessingml/2006/main:webHidden' is a leaf element and cannot contain children.", error.Description); }); }
public override void Execute(Context context) { InitializeSchemaSet(); ArrayList arr = new ArrayList(); // Load XML document from input file try { SchemaValidator sv = new SchemaValidator(SchemaSet); arr = sv.ValidateIt(InputFileName); context.Add("XmlValidateStepErrorCount", arr.Count.ToString(), true); if (arr.Count > 0) { foreach (string valerr in arr) { context.LogInfo(valerr); } } } //catch any exceptions from the try block catch (Exception ex) { context.LogException(ex); } }
public void Validate_NormalCall(string filename) { var schemaValidator = new SchemaValidator(new EmbeddedResourceResolver(typeof(Mim.V6301.POCD_IN150001UK06).Assembly)); var result = schemaValidator.Validate(filename, _localResolver.GetResourceStream("POCD_EX150001UK06_05.xml").GetText()); Assert.True(result.Status); }
private void RunVersioningTests(SifVersion dataVersion, SifVersion schemaVersion, bool ignoreEnumerationErrors) { // Tests assume that the schema files are embedded in the test assembly DirectoryInfo workingDirectory = new DirectoryInfo(Environment.CurrentDirectory); Type rootNamespaceType = typeof(UsAdkTest); String schemaVersionStr = getShortenedVersion(schemaVersion); String schemaResourcePath = rootNamespaceType.Namespace + ".schemas." + schemaVersionStr; AssemblyResourceResolver asr = new AssemblyResourceResolver(rootNamespaceType.Assembly, schemaResourcePath); SchemaValidator sv = null; using (Stream rootSchema = rootNamespaceType.Assembly.GetManifestResourceStream(schemaResourcePath + ".SIF_Message.xsd")) using (TextReader textReader = new StreamReader(rootSchema)) { sv = SchemaValidator.NewInstance(textReader, asr); textReader.Close(); rootSchema.Close(); } sv.IgnoreEnumerationErrors = ignoreEnumerationErrors; String dataVersionStr = getShortenedVersion(dataVersion); // Warning, slight hack. Move up two directories to the project root directory (assumes the project directory is still there) workingDirectory = workingDirectory.Parent.Parent; DirectoryInfo dataDir = new DirectoryInfo(workingDirectory.FullName + "\\data\\" + dataVersionStr); int errorCount = RunDirectoryTest(dataVersion, schemaVersion, dataDir, Console.Out, sv); Assert.AreEqual(0, errorCount, "Tests Failed. See System.out for details"); }
public void Validate_SpecifyingUsingSchemaNames_NormalCall() { var schemaValidator = new SchemaValidator(new EmbeddedResourceResolver(typeof(Mim.V6301.POCD_IN150001UK06).Assembly)); var result = schemaValidator.Validate(Mim.V6301.SchemaNames.POCD_MT000001UK04.ToString(), _localResolver.GetResourceStream("POCD_EX150001UK06_05.xml").GetText()); Assert.True(result.Status); }
public static XmlDocument IsValid(string fileName, bool warningsAsError) { Assert.IsNotNull(fileName); SchemaValidator validator = new SchemaValidator(warningsAsError); return(validator.Validate(IsWellFormed(fileName))); }
public bool ValidateSchema(Configuration configuration) { var validator = new SchemaValidator(configuration); try { validator.Validate(); return(true); } catch (HibernateException ex) { if (ex is SchemaValidationException) { foreach (var error in (ex as SchemaValidationException).ValidationErrors) { Console.WriteLine(error); } } return(false); } catch (Exception e) { Console.WriteLine(e); return(false); } }
public static XmlDocument IsValid(TextReader reader, bool warningsAsError) { Assert.IsNotNull(reader); SchemaValidator validator = new SchemaValidator(warningsAsError); return(validator.Validate(IsWellFormed(reader))); }
private static async Task ReceiveMessageAsync(Options options) { var consumer = GetSchemaConsumer(options); var validator = new SchemaValidator() .WithSchemaConsumer(consumer); var factory = MessagingFactory.CreateFromConnectionString(options.ServiceBusConnectionString); var subscription = factory.CreateSubscriptionClient(options.Topic, options.Subscription, ReceiveMode.PeekLock); var received = await subscription.ReceiveAsync() .ValidateAsync(validator) .ConfigureAwait(false); Console.WriteLine($"MessageId: {received.MessageId}, SequenceNumber: {received.SequenceNumber}"); var payload = default(string); using (var stream = received.GetBody <Stream>()) using (var reader = new StreamReader(stream)) { payload = await reader.ReadToEndAsync().ConfigureAwait(false); } Console.WriteLine(payload); await subscription.CompleteAsync(received.LockToken) .ConfigureAwait(false); Console.WriteLine(MessageReceived); }
public static XmlSchema IsSchemaValid(Stream stream, bool warningsAsError) { Assert.IsNotNull(stream); SchemaValidator validator = new SchemaValidator(warningsAsError); return(validator.ValidateSchema(stream)); }
public static async Task <HttpResponseMessage> Run( [HttpTrigger(AuthorizationLevel.Function, "post", Route = "servicebus/publish")] HttpRequestMessage req, [ServiceBus("%ServiceBusTopic%", Connection = "AzureServiceBusConnectionString", EntityType = EntityType.Topic)] IAsyncCollector <string> collector, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); var settings = new JsonSerializerSettings() { Formatting = Formatting.Indented, ContractResolver = new DefaultContractResolver() { NamingStrategy = new CamelCaseNamingStrategy() }, NullValueHandling = NullValueHandling.Ignore, MissingMemberHandling = MissingMemberHandling.Ignore, }; var location = Utility.GetBasePath(); var path = "default.json"; var sink = new FileSystemSchemaSink().WithBaseLocation(location); var consumer = new SchemaConsumer().WithSink(sink); var validator = new SchemaValidator().WithSchemaConsumer(consumer); var sample = new SampleClass(); var payload = await JsonConvert.SerializeObject(sample, settings) .ValidateAsStringAsync(validator, path).ConfigureAwait(false); await collector.AddAsync(payload).ConfigureAwait(false); return(req.CreateResponse(HttpStatusCode.Created)); }
public static XmlSchema IsSchemaValid(XmlReader reader, bool warningsAsError) { Assert.IsNotNull(reader); SchemaValidator validator = new SchemaValidator(warningsAsError); return(validator.ValidateSchema(reader)); }
/// <summary> /// Used to obtain access tokens for the EPiServer ServiceAPI. request an access token for a username, password couplet - Authorize /// </summary> /// <param name="json"></param> public virtual async Task<Models.TokenPostResponse> Post(string json) { var url = "token"; var req = new HttpRequestMessage(HttpMethod.Post, url); req.Content = new StringContent(json); var response = await proxy.Client.SendAsync(req); if (proxy.SchemaValidation.Enabled) { if (proxy.SchemaValidation.RaiseExceptions) { await SchemaValidator.ValidateWithExceptionAsync(Models.TokenPostResponse.GetSchema(ApiMultipleResponse.GetValueAsString(response.StatusCode)), response.Content); } } return new Models.TokenPostResponse { RawContent = response.Content, RawHeaders = response.Headers, StatusCode = response.StatusCode, ReasonPhrase = response.ReasonPhrase, SchemaValidation = new Lazy<SchemaValidationResults>(() => SchemaValidator.IsValid(Models.TokenPostResponse.GetSchema(ApiMultipleResponse.GetValueAsString(response.StatusCode)), response.Content), true) }; }
public static XmlDocument IsValidXml(string xml, bool warningsAsError) { Assert.IsNotNull(xml); SchemaValidator validator = new SchemaValidator(warningsAsError); return(validator.Validate(IsWellFormedXml(xml))); }
public SessionProvider() { var configuration = new Configuration(); configuration .DataBaseIntegration(c => { c.Dialect <MsSql2012Dialect>(); c.ConnectionString = "Server=cis;Database=test;Trusted_Connection=True;"; c.LogSqlInConsole = true; c.LogFormattedSql = true; }); configuration.CurrentSessionContext <ThreadStaticSessionContext>(); var mapper = new ModelMapper(); mapper.AddMappings(typeof(Program).Assembly.GetExportedTypes()); configuration.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities()); var validator = new SchemaValidator(configuration); validator.Validate(); _sessionFactory = configuration.BuildSessionFactory(); }
public void testStudentSnapshot15r1() { StringMapAdaptor sma = createStudentSnapshotFields(); StudentSnapshot ss = new StudentSnapshot(); ss.StudentPersonalRefId = Adk.MakeGuid(); ss.SnapDate = DateTime.Now; Mappings m = fCfg.Mappings.GetMappings("Default").Select(null, null, null); m .MapOutbound(sma, ss, new DefaultValueBuilder(sma), SifVersion.SIF15r1); Console.WriteLine(ss.ToXml()); int?onTimeGradYear = ss.OnTimeGraduationYear; Assertion.Assert("onTimeGraduationYear is null", onTimeGradYear.HasValue); Assertion.AssertEquals("OnTimeGraduationYear", 2000, onTimeGradYear.Value); SchemaValidator sv = USSchemaValidator.NewInstance(SifVersion.SIF15r1); // 3) Validate the file bool validated = sv.Validate(ss, SifVersion.SIF15r1); // 4) If validation failed, write the object out for tracing purposes if (!validated) { sv.PrintProblems(Console.Out); Assertion.Fail("Schema Validation Failed:"); } }
public static T WriteParseAndReturn<T>(T o, SifVersion version, SchemaValidator validator, bool echoOut) where T : SifElement { T returnVal; if ( o is SifMessagePayload ) { o.SifVersion = version; } SifWriter echo = null; if ( echoOut ) { // Write the object to System.out Console.WriteLine( "Writing object : " + o.ElementDef.Name + " using SIFVersion: " + version.ToString() ); echo = new SifWriter( Console.Out ); echo.Write( o, version ); } // Write the object to a file Console.WriteLine( "Writing to file... test.xml" ); using ( Stream fos = File.Open( "test.xml", FileMode.Create, FileAccess.Write ) ) { SifWriter writer = new SifWriter( fos ); writer.Write( o, version ); writer.Flush(); writer.Close(); fos.Close(); } if ( validator != null ) { Validate( "test.xml", validator ); } // Parse the object from the file Console.WriteLine( "Parsing from file..." ); SifParser p = SifParser.NewInstance(); using ( Stream fis = File.OpenRead( "test.xml" ) ) { returnVal = (T) p.Parse( fis, null ); fis.Close(); } // Write the parsed object to System.out returnVal.SetChanged( true ); Console.WriteLine( "Read object : " + returnVal.ElementDef.Name ); if ( echoOut ) { echo.Write( returnVal, version ); echo.Flush(); } return returnVal; }
public static void ValidateOrCreateSchema(string connString, string mapAssemblyName) { Configuration configuration = CreateConfiguration(connString, mapAssemblyName); try { SchemaValidator validator = new SchemaValidator(configuration); validator.Validate(); } catch (HibernateException) { SchemaUpdate schema = new SchemaUpdate(configuration); schema.Execute(true, true); } catch (Exception) { try { SchemaUpdate schema = new SchemaUpdate(configuration); schema.Execute(true, true); } catch (Exception) { throw; } throw; } }
private int RunDirectoryTest(SifVersion parseVersion, SifVersion writeVersion, DirectoryInfo dir, TextWriter output, SchemaValidator sv) { int errorCount = 0; foreach (DirectoryInfo childDir in dir.GetDirectories()) { errorCount += RunDirectoryTest(parseVersion, writeVersion, childDir, output, sv); } foreach (FileInfo fileInfo in dir.GetFiles("*.xml")) { if (!RunSingleTest(parseVersion, writeVersion, fileInfo.FullName, output, sv)) { errorCount++; } } output.Flush(); return errorCount; }
void AddReadContent(Class serializer, Block block, TypeNode type, StatementList statements, Identifier reader, Expression target, Expression required, Expression result, SchemaValidator validator) { // position us in the content. statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToContent")), new ExpressionList()))); Local elementName = new Local(Identifier.Empty,SystemTypes.String); statements.Add(new AssignmentStatement(elementName, new QualifiedIdentifier(reader, Identifier.For("LocalName")))); // make sure the element is not empty. If isEmpty = AddEmptyElementCheck(statements, reader); // Read the contents. statements = isEmpty.FalseBlock.Statements; statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("Read")), new ExpressionList()))); statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToContent")), new ExpressionList()))); ValidationState context = new ValidationState(); context.ErrorHandler = this.errorHandler; validator.validator.InitValidation(context); ArrayList members = null; if (validator.validator is AllElementsContentValidator) { members = validator.validator.ExpectedElements(context, false, false); AddReadAllGroup(serializer, block, type, statements, reader, target, required, result, members, validator.validator.MixedMember); } else { // There should be one root level anonymous Item0 member. SequenceNode seq = (SequenceNode)validator.RootNode; // this is a wrapper node. if (seq == null) { // perhaps it is ContentType.Empty or Mixed. if (validator.validator.ContentType == XmlSchemaContentType.Mixed || validator.validator.ContentType == XmlSchemaContentType.TextOnly){ Debug.Assert(validator.validator.MixedMember != null); statements.Add(new AssignmentStatement(GetMemberBinding(target, validator.validator.MixedMember), new MethodCall(new QualifiedIdentifier(reader, Identifier.For("ReadStringElement")), new ExpressionList()))); } return; } else { ContentNode n = seq.LeftChild; AddReadContentNode(n, block, statements, reader, target, required, result, validator); } } // consume final end tag statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("ReadEndTag")), new ExpressionList(elementName)))); }
void AddReadContentNode(ContentNode n, Block block, StatementList statements, Identifier reader, Expression target, Expression required, Expression result, SchemaValidator validator) { if (n.TypeNode == null) { Debug.Assert(n is SequenceNode); // In the class inheritance case we have two independent left and right children inside // a parent sequence that has no unified type or member. SequenceNode s = (SequenceNode)n; AddReadContentNode(s.LeftChild, block, statements, reader, target, required, result, validator); AddReadContentNode(s.RightChild, block, statements, reader, target, required, result, validator); return; } TypeNode ct = n.TypeNode; Debug.Assert(ct != null); if (n.Member != null && !(n.Member is Method)) { target = GetMemberBinding(target, n.Member); ct = target.Type; } // todo: might be content model AND mixed, in which case we have to pass the MixedMember // to AddReadTuple, AddReadChoice and AddReadStream. if (ct.Template == SystemTypes.GenericBoxed){ ct = Checker.GetCollectionElementType(ct); } if (ct is TupleType) { AddReadTuple(block, ct as TupleType, statements, reader, target, required, result); } else if (ct is TypeUnion) { AddReadChoice(block, ct as TypeUnion, statements, reader, target, required, result); } else if (IsStream(ct)) { AddReadStream(block, ct, statements, reader, target, result); } else if (ct is TypeAlias) { AddReadAlias(block, ct as TypeAlias, statements, reader, target, required, result); } else { Identifier name = Checker.GetDefaultElementName(ct); AddReadRequiredChild(block, statements, name, ct, target, reader, result, required, true, false); } }
void AddWriteContent(TypeNode type, StatementList statements, TypeNode referringType, Identifier writer, Expression source, SchemaValidator validator) { if (validator.validator is AllElementsContentValidator) { ValidationState context = new ValidationState(); context.ErrorHandler = this.errorHandler; validator.validator.InitValidation(context); ArrayList members = validator.validator.ExpectedElements(context, false, false); foreach (NamedNode childNode in members) { if (childNode.TypeNode == null) continue; // type resolution error. Expression src = GetMemberBinding(source, childNode.Member, childNode.TypeNode); AddWriteElement(statements, referringType, writer, childNode.Name, src, childNode.TypeNode, false); } } else { // Note: there is a SequenceNode wrapper we need to remove and throw away. SequenceNode seq = validator.RootNode as SequenceNode; if (seq != null) { // if seq is null then it's ContentType.Empty or Mixed and mixed is handled at the end. ContentNode n = seq.LeftChild; AddWriteContentNode(n, statements, referringType, writer, source); } } Member mixed = validator.validator.MixedMember; if (mixed != null) { MemberBinding mb = GetMemberBinding(source, mixed); if (mb.Type != null) AddWriteString(statements, referringType, writer, mb); } }
//================= reader methods ========================================== void AddReadAttributes(TypeNode type, StatementList statements, Identifier reader, Expression target, SchemaValidator validator) { if (validator.Attributes != null) { Block whileBody = new Block(new StatementList()); Literal trueLit = Literal.True; MethodCall movenext = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToNextAttribute")), new ExpressionList()); BinaryExpression condition = new BinaryExpression(movenext, trueLit, NodeType.Eq); While w = new While(condition, whileBody); statements.Add(w); Block lastElseBlock = null; Local nameLocal = new Local(SystemTypes.String); whileBody.Statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName")))); Local nsLocal = new Local(SystemTypes.String); whileBody.Statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI")))); foreach (SchemaAttDef ad in validator.Attributes) { // todo: any way to do tokenized compares? BinaryExpression nameEqual = new BinaryExpression(nameLocal, new Literal(ad.Name.Name, SystemTypes.String), NodeType.Eq); BinaryExpression nsEqual = new BinaryExpression(nsLocal, new Literal(ad.Name.Prefix != null ? ad.Name.Prefix.Name : "", SystemTypes.String), NodeType.Eq); Block elseBlock = new Block(new StatementList()); If ifExpr = new If(new BinaryExpression(nameEqual, nsEqual, NodeType.And), new Block(new StatementList()), elseBlock); if (lastElseBlock != null) { lastElseBlock.Statements.Add(ifExpr); } else { whileBody.Statements.Add(ifExpr); } lastElseBlock = elseBlock; // body of if test, parse the attribute value as the specified type. Debug.Assert(ad.Member is Field || ad.Member is Property); AddReadSimpleType(Checker.GetMemberType(ad.Member), ifExpr.TrueBlock.Statements, reader, GetMemberBinding(target, ad.Member), null, true); } //todo: report unknown attributes? } }
private void runSchemaValidatorTest(string reportFileName) { string testsDll = "mock-assembly.dll"; TestSuiteBuilder builder = new TestSuiteBuilder(); Test suite = builder.Build( new TestPackage( testsDll ) ); TestResult result = suite.Run(NullListener.NULL, TestFilter.Empty); new XmlResultWriter(reportFileName).SaveTestResult(result); SchemaValidator validator = new SchemaValidator(reportFileName, schemaFile.Path); Assert.IsTrue(validator.Validate(), "validate failed"); }
void AddWriteAttributes(StatementList statements, TypeNode referringType, Identifier writer, Expression source, SchemaValidator validator) { if (validator.Attributes != null) { foreach (SchemaAttDef ad in validator.Attributes) { Identifier name = ad.Name; Expression src = GetMemberBinding(source, ad.Member); if (src.Type == null) continue; // type resolution error. if (!AddWriteSimpleAttribute(src.Type, name, statements, referringType, writer, src)) { // throw exception, attribute has complex type! } } } }
public static XmlDocument IsValidXml(string xml, bool warningsAsError) { Assert.IsNotNull(xml); SchemaValidator validator = new SchemaValidator(warningsAsError); return validator.Validate(IsWellFormedXml(xml)); }
public static XmlDocument IsValid(string fileName, bool warningsAsError) { Assert.IsNotNull(fileName); SchemaValidator validator = new SchemaValidator(warningsAsError); return validator.Validate(IsWellFormed(fileName)); }
public static XmlSchema IsSchemaValid(Stream stream, bool warningsAsError) { Assert.IsNotNull(stream); SchemaValidator validator = new SchemaValidator(warningsAsError); return validator.ValidateSchema(stream); }
public static XmlSchema IsSchemaValid(XmlReader reader, bool warningsAsError) { Assert.IsNotNull(reader); SchemaValidator validator = new SchemaValidator(warningsAsError); return validator.ValidateSchema(reader); }
public static XmlDocument IsValid(TextReader reader, bool warningsAsError) { Assert.IsNotNull(reader); SchemaValidator validator = new SchemaValidator(warningsAsError); return validator.Validate(IsWellFormed(reader)); }
private bool RunSingleTest( SifVersion parseVersion, SifVersion writeVersion, string fileName, TextWriter output, SchemaValidator sv) { sv.Clear(); if (VERBOSE) { output.Write("Running test on " + fileName + "\r\n"); } // 1) Read the object into memory SifElement se = null; try { se = AdkObjectParseHelper.ParseFile(fileName, parseVersion); } catch (AdkException adke) { // Parsing failed. However, since this unit test is a complete // test of all available objects, just emit the problem and allow // the test to continue (with a notification of false) output .WriteLine("Error parsing file " + fileName + "\r\n - " + adke); output.WriteLine(); return false; } catch (Exception re) { output.WriteLine("Error parsing file " + fileName + "\r\n - " + re); output.WriteLine(); return false; } // if (VERBOSE) // { // SifWriter writer = new SifWriter(output); // writer.Write(se,parseVersion); // output.Flush(); // } // Before we can validate with the schema, we need to ensure that the // data object is wrapped in a SIF_Message elements, because the SIF // Schema makes that assumption SifMessagePayload smp = SchemaValidator.MakeSIFMessagePayload(se); String tmpFileName = fileName + "." + writeVersion.ToString() + ".adk"; // 2) Write the message out to a file SchemaValidator.WriteObject(writeVersion, tmpFileName, smp); // 3) Validate the file bool validated = sv.Validate(tmpFileName); // 4) If validation failed, write the object out for tracing purposes if (!validated) { if (VERBOSE) { SifWriter outWriter = new SifWriter(output); outWriter.Write(se, writeVersion ); outWriter.Flush(); } output.WriteLine("Validation failed on " + tmpFileName ); sv.PrintProblems(output); return false; } // 5) Read the object again into memory try { se = AdkObjectParseHelper.ParseFile(fileName, parseVersion); } catch (AdkException adke) { // Parsing failed. However, since this unit test is a complete // test of all available objects, just emit the problem and allow // the test to continue (with a notification of false) output.WriteLine("Error parsing file " + fileName + ": " + adke.Message ); return false; } catch (Exception re) { output.Write("Error parsing file " + fileName + ": " + re.Message + "\r\n"); return false; } return validated; }
private void runSchemaValidatorTest(string reportFileName) { string testsDll = "mock-assembly.dll"; TestSuiteBuilder builder = new TestSuiteBuilder(); Test suite = builder.Build( new TestPackage( testsDll ) ); TestResult result = suite.Run(NullListener.NULL); XmlResultVisitor visitor = new XmlResultVisitor(reportFileName, result); result.Accept(visitor); visitor.Write(); SchemaValidator validator = new SchemaValidator(reportFileName, schemaFile.Path); Assert.IsTrue(validator.Validate(), "validate failed"); }
private void runSchemaValidatorTest(string reportFileName, CultureInfo testCulture) { // Preserve current culture CultureInfo previousCulture = Thread.CurrentThread.CurrentCulture; // Enable test culture Thread.CurrentThread.CurrentCulture = testCulture; try { string testsDll = "mock-assembly.dll"; TestSuiteBuilder builder = new TestSuiteBuilder(); Test suite = builder.Build( new TestPackage( testsDll ) ); TestResult result = suite.Run(NullListener.NULL); XmlResultVisitor visitor = new XmlResultVisitor(reportFileName, result); result.Accept(visitor); visitor.Write(); SchemaValidator validator = new SchemaValidator(reportFileName, schemaFile.Path); Assert.IsTrue(validator.Validate(), "validate failed"); } finally { // Restore previous culture Thread.CurrentThread.CurrentCulture = previousCulture; } }
/** * Creates an instance of a schema validation test using the specified SIF * Version * * @param version * @throws Exception */ public ValidationTest(SifVersion version) { fVersion = version; fSchemaValidator = USSchemaValidator.NewInstance( version ); fOutput = Console.Out; }