Validation complains when default namespace set too late

Hmmh. This is problematic... mostly because the way things work, namespace for the element basically changes due to declaration (unless I forgot details of how writer-side validation works).
This because validation call for element itself is done before element and namespace output.

This is assumed based on sample code:

• Using non-repairing writer
• Expecting element to be in CORPUS_NAMESPACE

If so, code would be incorrect; as code implies that the element is not to be in any namespace.
If it should be in the namespace, it should call one of alternative writeStartElement methods, where expected namespace (URI) is passed explicitly. In non-repairing mode, the full (3-arg) variant is probably what is needed.

So, it may be a bug in sample code, but only if my understanding of the code is correct.

Well, for validation purposes, namespace write methods are essentially ignored (at least as far Woodstox does things): what matters is the call to writeStartElement and writeAttribute.
And in fact write call itself is mostly ignored in namespace-repairing mode. I wish Stax API spec was not so incomplete – it is somewhat hard to definitely say what is really meant; and writer-side is the most underdocumented of the whole thing. That is to say, there is so much room for interpretation that it is easy to disagree on its reading (kind of like lawyers arguing over meant semantics of 300 years old legal text).

Anyway: can you point me to the schema you are trying to validate against? I should be able to quickly verify what is going on here; it sounds a lot like a bug to me. I don't see anything wrong with your code per se, but it does depend on what schema it's to match.

Here's the schema.

Ok, reading through earlier code, it sounds like exception comes with a later call, probably writeStartElement() for "build".
Since that call is not included I can't be sure, but it sounds like that call is also missing namespace URI?

Maybe you are thinking that single-argument call would use default namespace? This is not the case, as far as I understand; rather, it is equivalent to specifying namespace URI of "".
As such, write methods that do not take namespace URI should never be used in namespace-aware processing.

Tatu,

Yes, indeed, the subsequent elements use the single element. Look at the edited description, the call is there.

But if things are as you say, I should be opening another, far more serious, JIRA.

Look again at

XMLStreamWriter writer = getXmlWriter(fos);

        writer.writeStartDocument("utf-8", "1.0");

        writer.writeStartElement("model");
        writer.writeDefaultNamespace(METADATA_NAMESPACE);
        // change for new word class mechanism
        writer.writeAttribute("version", "2");

        writer.writeStartElement( "build");

What XML should it produce?

By your argument:

<?xml?>
<model xmlns="urn:my-namespace">
<build xmlns="">
...
</model>

It does not produce that. It produces:

 <model xmlns="urn:my-namespace">
<build>
...

My whole complaint here is that code that produces the correct, valid, XML gets validation exceptions.

I think I see where confusions comes from, finally. Thank you for updating description.

So: let me try to rephrase things a bit:

• In regards to XML writing Stax API, non-namespace method write methods will either: (a) not do any checking whatsoever (in non-repairing mode), or (b) assume namespace to be "" (in repairing mode). In former case Woodstox writer may not keep track of the fact there was an actual namespace.
• Validation system is only based on direct write methds, and completely ignore any namespace writing methods. There also is no separate repairing/non-repairing modes (because validator can not repair anything)

So, yes, code as written does produce valid XML, but does not lead to sequence of calls that passes expected information to Validation API.

There are two complementary ways to address this I think. Either to keep track of default namespace information and make sure it gets passed to validation API (for non-namespace methods). Or make sure that you only use namespace methods when processing namespace-containing documents.
But beyond keeping track of information, additional problem of sequence of calls; validation would have to be moved after writeStartElement and any namespace-writing methods; determined dynamically from getting some other call. That is possible, just quite a bit of extra work.

I wish Stax API specified what seems logical to me: non-namespace methods should only be used when documents do not use namespaces. It seems implicit from the way API is written – reader-side has 2 modes; writer-side does not have separate modes, but has 3 somewhat overlapping methods. If this was specified, number of options would be limited to just 1.

Does above make sense?

I'm stuck on the following. Why is there such a thing as 'writeDefaultNamespace' at all if writeStartElement(String) is really only supposed to be used with no namespaces at all? To me, calling writeStartElement("", elementname, NAMESPACE) is very clumsy looking.

The author of that IBM article sure didn't seem to think that he was taking advantage of some repairing mode

Now, perhaps you're going to tell me that the point of writeDefaultNamespace is to let me use the two element form in this case. Validation still fails if I try THAT.

My suggestion is as follows: if the style of my failing example is really invalid except in some sort of 'auto-repairing' mode, then throw an exception from any attempt to turn validation on when auto-repairing is on. I don't have any problem with saying that you can't have both at the same time. However, if you take that like, it seems to me that you should do whatever it takes to make the sequence 'three-arg start', 'writeDefaultNamespace', 'two-arg start' work correctly with validation.

Is there no committee or JSR process for StaX that this could be debated with?

Ok, it has been a while since I added notes but here is just one more: validation mode for output is not even covered by Stax API. It is Stax2 addition.

I am not against improving handling, to the degree it is done by changing the way validator works. Due to backwards compatibility issues, no changes can be done for actual XML writing.
And although my head hurts trying to read through description (due to inherent complexity of combination of XML Namespaces and under-specified STAX API; not because of any of comment authors here. ), I think you have a valid point.

But I wonder if we should start a new issue if and when we get back to addressing this?

One more minor clarification: yes, if explicit namespace URI is being passed, validator needs to use that namespace URI. And validation definitely needs to be available in namespace-repairing mode, as well as in non-repairing mode.

I will leave discussion on what forms without namespace URI should mean, mostly because I just don't see Stax API specifying its behavior. Woodstox consistently interprets it to mean that URI would be "", and that prefix is missing (because that is only prefix that can map to empty namespace URI).

But most importantly for this issue, I need a unit test that exhibits a bug. At this point I do not see one.