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;
}
