Attachment #233765 for bug #411382

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Denise Smith - 2.6 - initial implementation
 ******************************************************************************/
package org.eclipse.persistence.oxm.json;

import javax.json.stream.JsonGenerator;

import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
import org.eclipse.persistence.oxm.record.JsonGeneratorRecord;

public class JsonGeneratorResult extends ExtendedResult{

    private JsonGenerator generator;
    
    public JsonGeneratorResult(JsonGenerator generator){
        this.generator = generator;
    }

    @Override
    public org.eclipse.persistence.oxm.record.MarshalRecord createRecord() {
        JsonGeneratorRecord record = new JsonGeneratorRecord(generator);
        return record;
    }    

}

Lines 159-165 public class JsonBuilderRecord extends MarshalRecord <XMLMarshaller> { Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonBuilderRecord.java (-10 / +17 lines)
159	position = rootLevel;	159	position = rootLevel;
160	} else {	160	} else {
161	if(isLastEventStart){	161	if(isLastEventStart){
162	position.setComplex(true);	162	setComplex(position, true);
163	}	163	}
164	Level level = new Level(true, position);	164	Level level = new Level(true, position);
165	position = level;	165	position = level;
Lines 172-177 public class JsonBuilderRecord extends MarshalRecord <XMLMarshaller> { Link Here
172	popAndSetInParentBuilder();	172	popAndSetInParentBuilder();
173	}	173	}
174		174
		175	private void setComplex(Level level, boolean complex){
		176	boolean isAlreadyComplex = level.isComplex;
		177	level.setComplex(complex);
		178	if(complex && !isAlreadyComplex){
		179	if(complex && level.jsonObjectBuilder == null){
		180	level.jsonObjectBuilder = Json.createObjectBuilder();
		181	}
		182	}
		183	}
		184
175	@Override	185	@Override
176	public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {	186	public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
177	super.openStartElement(xPathFragment, namespaceResolver);	187	super.openStartElement(xPathFragment, namespaceResolver);
Lines 180-186 public class JsonBuilderRecord extends MarshalRecord <XMLMarshaller> { Link Here
180		190
181	if(isLastEventStart){	191	if(isLastEventStart){
182	//this means 2 startevents in a row so the last this is a complex object	192	//this means 2 startevents in a row so the last this is a complex object
183	position.setComplex(true);	193	setComplex(position, true);
184	}	194	}
185		195
186	String keyName = getKeyName(xPathFragment);	196	String keyName = getKeyName(xPathFragment);
Lines 283-293 public class JsonBuilderRecord extends MarshalRecord <XMLMarshaller> { Link Here
283		293
284	if(xPathFragment.isSelfFragment() \|\| xPathFragment.nameIsText()){	294	if(xPathFragment.isSelfFragment() \|\| xPathFragment.nameIsText()){
285	String keyName = position.getKeyName();	295	String keyName = position.getKeyName();
286	position.setComplex(false);	296	setComplex(position, false);
287	position.parentLevel.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());	297	position.parentLevel.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());
288	}else{	298	}else{
289	if(isLastEventStart){	299	if(isLastEventStart){
290	position.setComplex(true);	300	setComplex(position, true);
291	}	301	}
292	String keyName = getKeyName(xPathFragment);	302	String keyName = getKeyName(xPathFragment);
293	if(keyName != null){	303	if(keyName != null){
Lines 329-335 public class JsonBuilderRecord extends MarshalRecord <XMLMarshaller> { Link Here
329	public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {	339	public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
330	if(position != null){	340	if(position != null){
331	if(isLastEventStart){	341	if(isLastEventStart){
332	position.setComplex(true);	342	setComplex(position, true);
333	}	343	}
334	if(position.isComplex){	344	if(position.isComplex){
335	popAndSetInParentBuilder();	345	popAndSetInParentBuilder();
Lines 446-452 public class JsonBuilderRecord extends MarshalRecord <XMLMarshaller> { Link Here
446	String keyName = position.getKeyName();	456	String keyName = position.getKeyName();
447	if(!position.isComplex){	457	if(!position.isComplex){
448	currentLevel = position.parentLevel;	458	currentLevel = position.parentLevel;
449	currentLevel.setComplex(true);	459	setComplex(currentLevel, true);
450	}	460	}
451	if(currentLevel.isCollection()){	461	if(currentLevel.isCollection()){
452	currentLevel.setEmptyCollection(false);	462	currentLevel.setEmptyCollection(false);
Lines 803-811 public class JsonBuilderRecord extends MarshalRecord <XMLMarshaller> { Link Here
803		813
804	public void setComplex(boolean isComplex) {	814	public void setComplex(boolean isComplex) {
805	this.isComplex = isComplex;	815	this.isComplex = isComplex;
806	if(isComplex && jsonObjectBuilder == null){
807	jsonObjectBuilder = Json.createObjectBuilder();
808	}
809	}	816	}
810		817
811	}	818	}




/*******************************************************************************
 * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Denise Smith - 2.6 - initial implementation
 ******************************************************************************/
package org.eclipse.persistence.oxm.record;

import java.io.IOException;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;

import javax.json.stream.JsonGenerator;
import javax.xml.namespace.QName;

import org.eclipse.persistence.exceptions.XMLMarshalException;
import org.eclipse.persistence.internal.core.helper.CoreClassConstants;
import org.eclipse.persistence.internal.core.helper.CoreConversionManager;
import org.eclipse.persistence.internal.oxm.CharacterEscapeHandler;
import org.eclipse.persistence.internal.oxm.Constants;
import org.eclipse.persistence.internal.oxm.ConversionManager;
import org.eclipse.persistence.internal.oxm.NamespaceResolver;
import org.eclipse.persistence.internal.oxm.ObjectBuilder;
import org.eclipse.persistence.internal.oxm.Root;
import org.eclipse.persistence.internal.oxm.XMLBinaryDataHelper;
import org.eclipse.persistence.internal.oxm.XMLMarshaller;
import org.eclipse.persistence.internal.oxm.XPathFragment;
import org.eclipse.persistence.internal.oxm.XMLConversionManager;
import org.eclipse.persistence.internal.oxm.mappings.Descriptor;
import org.eclipse.persistence.internal.oxm.record.ExtendedContentHandler;
import org.eclipse.persistence.internal.oxm.record.XMLFragmentReader;
import org.w3c.dom.Attr;
import org.w3c.dom.Node;
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.ext.LexicalHandler;

public class JsonGeneratorRecord extends MarshalRecord <XMLMarshaller> {

    private Level position;    
    private JsonGenerator jsonGenerator;
    private CharacterEscapeHandler characterEscapeHandler;

    private String attributePrefix;
    private boolean isRootArray;
    private static final String NULL="null";
    private boolean isLastEventStart;
        
    public JsonGeneratorRecord(JsonGenerator generator){
        super();       
        this.jsonGenerator = generator;
    }
    
    /**
     * INTERNAL:
     */
    public void setMarshaller(XMLMarshaller marshaller) {
        super.setMarshaller(marshaller);
        attributePrefix = marshaller.getAttributePrefix();
        if (marshaller.getValueWrapper() != null) {
            textWrapperFragment = new XPathFragment();
            textWrapperFragment.setLocalName(marshaller.getValueWrapper());
        }
        characterEscapeHandler = marshaller.getCharacterEscapeHandler();
    }
    
    @Override
    public void startDocument(String encoding, String version) {      
        if(isRootArray){  
            if(position == null){
                startCollection();
            }                            
            position.setEmptyCollection(false); 
            Level newLevel = new Level(false, position);
            position = newLevel;
            isLastEventStart = true;
        }else{
            Level rootLevel = new Level(false, null);
            position = rootLevel;
            setComplex(position, true);
        }
    }

    @Override
    public void endDocument() {        
        if(position != null){
            jsonGenerator.writeEnd(); 
            position = position.parentLevel;
        }
    }
    
    private void popAndSetInParentBuilder(){
        if(!(position.isCollection && position.isEmptyCollection() && position.getKeyName() == null)){
            jsonGenerator.writeEnd(); 
        }
        position = position.parentLevel;      
    }    
    
    public void startCollection() {
        if(position == null){
             isRootArray = true;              
             Level rootLevel = new Level(true, null); 
             position = rootLevel;
             jsonGenerator.writeStartArray();
        } else {            
            if(isLastEventStart){
                setComplex(position, true);         
            }            
            Level level = new Level(true, position);            
            position = level;
        }      
        isLastEventStart = false;
    }
    
    @Override
    public void endCollection() {        
         popAndSetInParentBuilder();    
    }

    private void setComplex(Level level, boolean complex){
        boolean isAlreadyComplex = level.isComplex;
        level.setComplex(complex);
        if(complex && !isAlreadyComplex){
            Level parentLevel = level.parentLevel;
            if((parentLevel != null && parentLevel.isCollection && !parentLevel.isEmptyCollection()) || level.keyName == null){
                jsonGenerator.writeStartObject();                    
            }else{
                jsonGenerator.writeStartObject(level.keyName);
            }
        }
    }
    
    @Override    
    public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
        super.openStartElement(xPathFragment, namespaceResolver);
        if(position != null){
            Level newLevel = new Level(false, position);            
            
            if(isLastEventStart){                              
                //this means 2 startevents in a row so the last this is a complex object
                setComplex(position, true);
            }
                      
            String keyName = getKeyName(xPathFragment);
           
            if(position.isCollection && position.isEmptyCollection() ){
                position.setKeyName(keyName);
                jsonGenerator.writeStartArray(keyName);
                position.setEmptyCollection(false);
            }else{
                newLevel.setKeyName(keyName);    
            }
            position = newLevel;   
            isLastEventStart = true;
        }
    }
    
    protected String getKeyName(XPathFragment xPathFragment){
        String keyName = xPathFragment.getLocalName(); 
       
        if(isNamespaceAware()){
            if(xPathFragment.getNamespaceURI() != null){
                String prefix = null;
                if(getNamespaceResolver() !=null){
                    prefix = getNamespaceResolver().resolveNamespaceURI(xPathFragment.getNamespaceURI());
                } else if(namespaceResolver != null){
                    prefix = namespaceResolver.resolveNamespaceURI(xPathFragment.getNamespaceURI());
                }
                if(prefix != null && !prefix.equals(Constants.EMPTY_STRING)){
                    keyName = prefix + getNamespaceSeparator() +  keyName;                           
                }
            }
        } 
        if(xPathFragment.isAttribute() && attributePrefix != null){
            keyName = attributePrefix + keyName;
        }

        return keyName;
    }

    public void attribute(XPathFragment xPathFragment, NamespaceResolver namespaceResolver,  Object value, QName schemaType){
        if(xPathFragment.getNamespaceURI() != null && xPathFragment.getNamespaceURI() == javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI){
            return;
        }
        xPathFragment.setAttribute(true);
        openStartElement(xPathFragment, namespaceResolver);
        characters(schemaType, value, null, false, true);
        endElement(xPathFragment, namespaceResolver);
    }
    
    /**
     * INTERNAL:
     */
    @Override
    public void marshalWithoutRootElement(ObjectBuilder treeObjectBuilder, Object object, Descriptor descriptor, Root root, boolean isXMLRoot){
        if(treeObjectBuilder != null){
            addXsiTypeAndClassIndicatorIfRequired(descriptor, null, descriptor.getDefaultRootElementField(), root, object, isXMLRoot, true);
            treeObjectBuilder.marshalAttributes(this, object, session);
        }         
     }
    
    /**
     * INTERNAL:
     * The character used to separate the prefix and uri portions when namespaces are present 
     * @since 2.4
     */
    public char getNamespaceSeparator(){        
        return marshaller.getNamespaceSeparator();
    }
    
    /**
     * INTERNAL:
     * The optional fragment used to wrap the text() mappings
     * @since 2.4
     */
    public XPathFragment getTextWrapperFragment() {
        return textWrapperFragment;
    }
    
    @Override
    public boolean isWrapperAsCollectionName() {
        return marshaller.isWrapperAsCollectionName();
    }
    
    @Override
    public void element(XPathFragment frag) {
        isLastEventStart = false;
    }
    
    /**
     * Handle marshal of an empty collection.  
     * @param xPathFragment
     * @param namespaceResolver
     * @param openGrouping if grouping elements should be marshalled for empty collections
     * @return
     */    
    public boolean emptyCollection(XPathFragment xPathFragment, NamespaceResolver namespaceResolver, boolean openGrouping) {

         if(marshaller.isMarshalEmptyCollections()){
             super.emptyCollection(xPathFragment, namespaceResolver, true);
             
             if (null != xPathFragment) {
                 
                 if(xPathFragment.isSelfFragment() || xPathFragment.nameIsText()){
                     String keyName = position.getKeyName();
                     setComplex(position, false);
                     jsonGenerator.writeStartArray(keyName);
                     jsonGenerator.writeEnd();
                 }else{ 
                     if(isLastEventStart){
                         setComplex(position, true);
                     }                 
                     String keyName =  getKeyName(xPathFragment);
                     if(keyName != null){
                         jsonGenerator.writeStartArray(keyName);
                         jsonGenerator.writeEnd();
                     }
                 }
                 isLastEventStart = false;   
             }
                  
             return true;
         }else{
             return super.emptyCollection(xPathFragment, namespaceResolver, openGrouping);
         }
    }

    @Override
    public void attribute(XPathFragment xPathFragment,NamespaceResolver namespaceResolver, String value) {
        attribute(xPathFragment, namespaceResolver, value, null);
    }

    @Override
    public void attribute(String namespaceURI, String localName, String qName, String value) {
        XPathFragment xPathFragment = new XPathFragment();
        xPathFragment.setNamespaceURI(namespaceURI);
        xPathFragment.setAttribute(true);
        xPathFragment.setLocalName(localName);

        openStartElement(xPathFragment, namespaceResolver);
        characters(null, value, null, false, true);

        endElement(xPathFragment, namespaceResolver);
        
    }

    @Override
    public void closeStartElement() {}

    @Override
    public void endElement(XPathFragment xPathFragment,NamespaceResolver namespaceResolver) {
        if(position != null){            
            if(isLastEventStart){
                setComplex(position, true);
            }
            if(position.isComplex){
                popAndSetInParentBuilder();
            }else{
                position = position.parentLevel;
            }            
            isLastEventStart = false;
        }
    }

    @Override
    public void characters(String value) {
        writeValue(value, null, false);
    }

    @Override
    public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA){          
        characters(schemaType, value, mimeType, isCDATA, false);
     }
    
    public void characters(QName schemaType, Object value, String mimeType, boolean isCDATA, boolean isAttribute){
        if(mimeType != null) {
            if(value instanceof List){
               value = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesListForBinaryValues((List)value, marshaller, mimeType);
           }else{

            value = XMLBinaryDataHelper.getXMLBinaryDataHelper().getBytesForBinaryValue(value, marshaller, mimeType).getData();
           }
        }         
        if(schemaType != null && Constants.QNAME_QNAME.equals(schemaType)){
            String convertedValue = getStringForQName((QName)value);
            writeValue(convertedValue, null, isAttribute);
        } 
        else if(value.getClass() == String.class){          
            //if schemaType is set and it's a numeric or boolean type don't treat as a string
            if(schemaType != null && isNumericOrBooleanType(schemaType)){
                Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);
                Object convertedValue = ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, theClass, schemaType);
                writeValue(convertedValue, schemaType, isAttribute);
            }else if(isCDATA){
                cdata((String)value);
            }else{
                writeValue((String)value, null, isAttribute);                
            }
       }else{
           Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          

           if(schemaType == null || theClass == null){
               if(value.getClass() == CoreClassConstants.BOOLEAN || CoreClassConstants.NUMBER.isAssignableFrom(value.getClass())){
                   writeValue(value, schemaType, isAttribute);
               }else{
                   String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
                   writeValue(convertedValue, schemaType, isAttribute);
               }
           }else if(schemaType != null && !isNumericOrBooleanType(schemaType)){
               //if schemaType exists and is not boolean or number do write quotes (convert to string)
               String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
               writeValue(convertedValue, schemaType, isAttribute);
           } else if(isCDATA){
               String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
               cdata(convertedValue);
           }else{
               writeValue(value, schemaType, isAttribute);           
           }
       }        
    }
    
    
    private boolean isNumericOrBooleanType(QName schemaType){
        if(schemaType == null){
            return false;
        }else if(schemaType.equals(Constants.BOOLEAN_QNAME)
                || schemaType.equals(Constants.INTEGER_QNAME)
                || schemaType.equals(Constants.INT_QNAME)
                || schemaType.equals(Constants.BYTE_QNAME)
                || schemaType.equals(Constants.DECIMAL_QNAME)
                || schemaType.equals(Constants.FLOAT_QNAME)
                || schemaType.equals(Constants.DOUBLE_QNAME)
                || schemaType.equals(Constants.SHORT_QNAME)
                || schemaType.equals(Constants.LONG_QNAME)
                || schemaType.equals(Constants.NEGATIVE_INTEGER_QNAME)
                || schemaType.equals(Constants.NON_NEGATIVE_INTEGER_QNAME)
                || schemaType.equals(Constants.NON_POSITIVE_INTEGER_QNAME)
                || schemaType.equals(Constants.POSITIVE_INTEGER_QNAME)
                || schemaType.equals(Constants.UNSIGNED_BYTE_QNAME)
                || schemaType.equals(Constants.UNSIGNED_INT_QNAME)
                || schemaType.equals(Constants.UNSIGNED_LONG_QNAME)
                || schemaType.equals(Constants.UNSIGNED_SHORT_QNAME)
        ){
            return true;
        }
        return false;
    }
    
    public void writeValue(Object value, QName schemaType, boolean isAttribute) {
        
        if (characterEscapeHandler != null && value instanceof String) {
            try {
                StringWriter stringWriter = new StringWriter();
                characterEscapeHandler.escape(((String)value).toCharArray(), 0, ((String)value).length(), isAttribute, stringWriter);
                value = stringWriter.toString();
            } catch (IOException e) {
                throw XMLMarshalException.marshalException(e);
            }
        }
        
        boolean textWrapperOpened = false;                       
        if(!isLastEventStart){
             openStartElement(textWrapperFragment, namespaceResolver);
             textWrapperOpened = true;
        }
      
        Level currentLevel = position;
        String keyName = position.getKeyName();
        if(!position.isComplex){           
            currentLevel = position.parentLevel;         
        }
        addValue(currentLevel, keyName, value, schemaType);
        isLastEventStart = false;
        if(textWrapperOpened){    
             endElement(textWrapperFragment, namespaceResolver);
        }    
    }
    private void addValue(Level currentLevel, String keyName, Object value, QName schemaType){        
        if(currentLevel.isCollection()){
            currentLevel.setEmptyCollection(false);
            addValueToArray(value, schemaType);            
        } else {
            addValueToObject(keyName, value, schemaType);
            
        }
    }
    
    private void addValueToObject(String keyName, Object value, QName schemaType){
        
        if(value == NULL){
            jsonGenerator.writeNull(keyName);            
        }else if(value instanceof Integer){
            jsonGenerator.write(keyName, (Integer)value);             
        }else if(value instanceof BigDecimal){            
            jsonGenerator.write(keyName, (BigDecimal)value);
        }else if(value instanceof BigInteger){
            jsonGenerator.write(keyName, (BigInteger)value);
        }else if(value instanceof Boolean){
            jsonGenerator.write(keyName, (Boolean)value);
        }else if(value instanceof Character){
            jsonGenerator.write(keyName, (Character)value);;  
        }else if(value instanceof Double){
            jsonGenerator.write(keyName, (Double)value);
        }else if(value instanceof Float){
            jsonGenerator.write(keyName, (Float)value);
        }else if(value instanceof Long){
            jsonGenerator.write(keyName, (Long)value);
        }else if(value instanceof String){
            jsonGenerator.write(keyName, (String)value);
        }else{
            String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
            Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
            if((schemaType == null || theClass == null) && (CoreClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
                //if it's still a number and falls through the cracks we dont want "" around the value
                    BigDecimal convertedNumberValue = ((BigDecimal) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.BIGDECIMAL, schemaType));
                    jsonGenerator.write(keyName, (BigDecimal)convertedNumberValue);
            }else{
                jsonGenerator.write(keyName, convertedValue);                
            }
                
        }
    }
    
    private void addValueToArray(Object value, QName schemaType){
        if(value == NULL){            
            jsonGenerator.writeNull();
        }else if(value instanceof Integer){
            jsonGenerator.write((Integer)value);             
        }else if(value instanceof BigDecimal){
            jsonGenerator.write((BigDecimal)value);
        }else if(value instanceof BigInteger){
            jsonGenerator.write((BigInteger)value);
        }else if(value instanceof Boolean){                            
            jsonGenerator.write((Boolean)value);
        }else if(value instanceof Character){
            jsonGenerator.write((Character)value);
        }else if(value instanceof Double){
            jsonGenerator.write((Double)value);
        }else if(value instanceof Float){
            jsonGenerator.write((Float)value);
        }else if(value instanceof Long){
            jsonGenerator.write((Long)value);
        }else if(value instanceof String){
            jsonGenerator.write((String)value);            
        }else{
            String convertedValue = ((String) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.STRING, schemaType));
            Class theClass = (Class) ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager()).getDefaultXMLTypes().get(schemaType);          
            if((schemaType == null || theClass == null) && (CoreClassConstants.NUMBER.isAssignableFrom(value.getClass()))){
                //if it's still a number and falls through the cracks we dont want "" around the value
                    BigDecimal convertedNumberValue = ((BigDecimal) ((ConversionManager) session.getDatasourcePlatform().getConversionManager()).convertObject(value, CoreClassConstants.BIGDECIMAL, schemaType));
                    jsonGenerator.write((BigDecimal)convertedNumberValue);            

            }else{
                jsonGenerator.write(convertedValue);                
            }
        }
    }
    
    @Override
    public void cdata(String value) {
        characters(value);        
    }

    @Override
    public void node(Node node, NamespaceResolver resolver, String uri, String name) {
       
        if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
            Attr attr = (Attr) node;
            String resolverPfx = null;
            if (getNamespaceResolver() != null) {
                resolverPfx = this.getNamespaceResolver().resolveNamespaceURI(attr.getNamespaceURI());
            }
            String namespaceURI = attr.getNamespaceURI();
            // If the namespace resolver contains a prefix for the attribute's URI,
            // use it instead of what is set on the attribute
            if (resolverPfx != null) {
                attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, resolverPfx+Constants.COLON+attr.getLocalName(), attr.getNodeValue());
            } else {
                attribute(attr.getNamespaceURI(), Constants.EMPTY_STRING, attr.getName(), attr.getNodeValue());
                // May need to declare the URI locally
                if (attr.getNamespaceURI() != null) {
                    attribute(javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI, Constants.EMPTY_STRING, javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON + attr.getPrefix(), attr.getNamespaceURI());
                    this.getNamespaceResolver().put(attr.getPrefix(), attr.getNamespaceURI());
                }
            }
        } else if (node.getNodeType() == Node.TEXT_NODE) {
            writeValue(node.getNodeValue(), null, false);
        } else {
            try {
                JsonObjectBuilderRecordContentHandler wrcHandler = new JsonObjectBuilderRecordContentHandler();
                
                XMLFragmentReader xfragReader = new XMLFragmentReader(namespaceResolver);
                xfragReader.setContentHandler(wrcHandler);
                xfragReader.setProperty("http://xml.org/sax/properties/lexical-handler", wrcHandler);
                xfragReader.parse(node, uri, name);
            } catch (SAXException sex) {
                throw XMLMarshalException.marshalException(sex);
            }
        }
        
    }        
    
    protected String getStringForQName(QName qName){
        if(null == qName) {
            return null;
        }
        CoreConversionManager xmlConversionManager = getSession().getDatasourcePlatform().getConversionManager();

        return (String) xmlConversionManager.convertObject(qName, String.class);       
    }

    /**
     * INTERNAL:
     */
     public void namespaceDeclarations(NamespaceResolver namespaceResolver) {
     }

     public void namespaceDeclaration(String prefix, String namespaceURI){
     }
     
     public void defaultNamespaceDeclaration(String defaultNamespace){
     }
     
    /**
     * INTERNAL:
     */
     public void nilComplex(XPathFragment xPathFragment, NamespaceResolver namespaceResolver){
         XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver);
         closeStartGroupingElements(groupingFragment);
         openStartElement(xPathFragment, namespaceResolver);
         characters(NULL);
         endElement(xPathFragment, namespaceResolver);
     }

    /**
     * INTERNAL:
     */
     public void nilSimple(NamespaceResolver namespaceResolver){
         XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver);         
         characters(NULL);        
         closeStartGroupingElements(groupingFragment);
     }

     /**
      * Used when an empty simple value should be written
      * @since EclipseLink 2.4
      */
     public void emptySimple(NamespaceResolver namespaceResolver){
         nilSimple(namespaceResolver);
     }
     
     public void emptyAttribute(XPathFragment xPathFragment,NamespaceResolver namespaceResolver){
         XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver);
         openStartElement(xPathFragment, namespaceResolver);
         characters(NULL);
         endElement(xPathFragment, namespaceResolver);
         closeStartGroupingElements(groupingFragment);
     }

     /**
      * Used when an empty complex item should be written
      * @since EclipseLink 2.4
      */
     public void emptyComplex(XPathFragment xPathFragment, NamespaceResolver namespaceResolver){
         XPathFragment groupingFragment = openStartGroupingElements(namespaceResolver);
         closeStartGroupingElements(groupingFragment);
         openStartElement(xPathFragment, namespaceResolver);
         endElement(xPathFragment, namespaceResolver);
     }
    
    
     
     /**
      * This class will typically be used in conjunction with an XMLFragmentReader.
      * The XMLFragmentReader will walk a given XMLFragment node and report events
      * to this class - the event's data is then written to the enclosing class'
      * writer.
      *
      * @see org.eclipse.persistence.internal.oxm.record.XMLFragmentReader
      */
     protected class JsonObjectBuilderRecordContentHandler implements ExtendedContentHandler, LexicalHandler {

         JsonObjectBuilderRecordContentHandler() {
         }

         // --------------------- CONTENTHANDLER METHODS --------------------- //
         public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
                 XPathFragment xPathFragment = new XPathFragment(localName);
                 xPathFragment.setNamespaceURI(namespaceURI);
                 openStartElement(xPathFragment, namespaceResolver);
                 handleAttributes(atts);
         }

         public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
             XPathFragment xPathFragment = new XPathFragment(localName);
             xPathFragment.setNamespaceURI(namespaceURI);
             
             JsonGeneratorRecord.this.endElement(xPathFragment, namespaceResolver);        
         }

         public void startPrefixMapping(String prefix, String uri) throws SAXException {
         }

         public void characters(char[] ch, int start, int length) throws SAXException {
             String characters = new String (ch, start, length);
             characters(characters);
         }

         public void characters(CharSequence characters) throws SAXException {           
             JsonGeneratorRecord.this.characters(characters.toString());      
         }

         // --------------------- LEXICALHANDLER METHODS --------------------- //
         public void comment(char[] ch, int start, int length) throws SAXException {
         }

         public void startCDATA() throws SAXException {
         }

         public void endCDATA() throws SAXException {
         }

         // --------------------- CONVENIENCE METHODS --------------------- //
            protected void handleAttributes(Attributes atts) {
             for (int i=0, attsLength = atts.getLength(); i<attsLength; i++) {
                 String qName = atts.getQName(i);
                 if((qName != null && (qName.startsWith(javax.xml.XMLConstants.XMLNS_ATTRIBUTE + Constants.COLON) || qName.equals(javax.xml.XMLConstants.XMLNS_ATTRIBUTE)))) {
                     continue;
                 }
                 attribute(atts.getURI(i), atts.getLocalName(i), qName, atts.getValue(i));
             }
         }

         protected void writeComment(char[] chars, int start, int length) {        
         }
        
         protected void writeCharacters(char[] chars, int start, int length) {
             try {
                 characters(chars, start, length);
             } catch (SAXException e) {
                 throw XMLMarshalException.marshalException(e);
             }           
         }
         // --------------- SATISFY CONTENTHANDLER INTERFACE --------------- //
         public void endPrefixMapping(String prefix) throws SAXException {}
         public void processingInstruction(String target, String data) throws SAXException {}
         public void setDocumentLocator(Locator locator) {}
         public void startDocument() throws SAXException {}
         public void endDocument() throws SAXException {}
         public void skippedEntity(String name) throws SAXException {}
         public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {}

         // --------------- SATISFY LEXICALHANDLER INTERFACE --------------- //
         public void startEntity(String name) throws SAXException {}
         public void endEntity(String name) throws SAXException {}
         public void startDTD(String name, String publicId, String systemId) throws SAXException {}
         public void endDTD() throws SAXException {}
         @Override
         public void setNil(boolean isNil) {}

     }

     
     /**
     * Instances of this class are used to maintain state about the current
     * level of the JSON message being marshalled.
     */
    protected static class Level {
        
        private boolean isCollection;
        private boolean emptyCollection;
        private String keyName;                
        private boolean isComplex;
        private Level parentLevel;
        
        public Level(boolean isCollection, Level parentLevel) {
            setCollection(isCollection);
            emptyCollection = true;
            this.parentLevel = parentLevel;
        }

        public boolean isCollection() {
            return isCollection;
        }

        public void setCollection(boolean isCollection) {
            this.isCollection = isCollection;            
        }

        public String getKeyName() {
            return keyName;
        }

        public void setKeyName(String keyName) {
            this.keyName = keyName;
        }
      
        public boolean isEmptyCollection() {
            return emptyCollection;
        }

        public void setEmptyCollection(boolean emptyCollection) {
            this.emptyCollection = emptyCollection;
        }
        public boolean isComplex() {
            return isComplex;
        }

        public void setComplex(boolean isComplex) {
            this.isComplex = isComplex;                     
        }        
    }

}




import javax.json.JsonReader;
import javax.json.JsonStructure;
import javax.json.JsonWriter;
import javax.json.stream.JsonGenerator;
import javax.json.stream.JsonParser;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.Marshaller;

import org.eclipse.persistence.jaxb.MarshallerProperties;
import org.eclipse.persistence.jaxb.UnmarshallerProperties;
import org.eclipse.persistence.oxm.MediaType;
import org.eclipse.persistence.oxm.json.JsonGeneratorResult;
import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
import org.eclipse.persistence.oxm.json.JsonStructureSource;
import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;

        log(sw.toString());
        compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());
    }
    
    public void testJSONMarshalToBuilderResult() throws Exception{
        getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");


        writer.close();
        
        log(sw.toString());
        compareStringToControlFile("**testJSONMarshalToBuilderResult**", sw.toString());
    }

    public void testJSONMarshalToGeneratorResult() throws Exception{
        getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");

        StringWriter sw = new StringWriter();
        JsonGenerator generator= Json.createGenerator(sw);
        JsonGeneratorResult result = new JsonGeneratorResult(generator);
        try{
            getJSONMarshaller().marshal(getWriteControlObject(), result);
        } catch(Exception e) {
            assertMarshalException(e);
            return;
        }
        generator.flush();
        log(sw.toString());
        compareStringToControlFile("**testJSONMarshalToGeneratorResult**", sw.toString());
    }

    
    protected void compareStringToControlFile(String test, String testString) {
    	compareStringToControlFile(test, testString, getWriteControlJSON());
    }

Lines 148-152 public class ChoiceCollectionMappingTestCases extends JAXBWithJSONTestCases { Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/choicecollection/ChoiceCollectionMappingTestCases.java (-1 / +3 lines)
148	public void testJSONMarshalToBuilderResult() throws Exception{	148	public void testJSONMarshalToBuilderResult() throws Exception{
149	//Currently not supported, 101.1 will get written as 101.0999984741211	149	//Currently not supported, 101.1 will get written as 101.0999984741211
150	}	150	}
151		151	public void testJSONMarshalToGeneratorResult() throws Exception{
		152	//Currently not supported, 101.1 will get written as 101.0999984741211
		153	}
152	}	154	}




import javax.json.JsonObjectBuilder;
import javax.json.JsonWriter;
import javax.json.JsonWriterFactory;
import javax.json.stream.JsonGenerator;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.Marshaller;

import org.eclipse.persistence.jaxb.UnmarshallerProperties;
import org.eclipse.persistence.oxm.XMLContext;
import org.eclipse.persistence.oxm.json.JsonArrayBuilderResult;
import org.eclipse.persistence.oxm.json.JsonGeneratorResult;
import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
import org.eclipse.persistence.testing.oxm.OXTestCase;


           log(sw.toString());
           compareStringToControlFile("**testJSONMarshalToBuilderResult**", sw.toString());
       }
    
    public void testJSONMarshalToGeneratorResult() throws Exception{
        
        StringWriter sw = new StringWriter();
        JsonGenerator jsonGenerator = Json.createGenerator(sw);
        JsonGeneratorResult result = new JsonGeneratorResult(jsonGenerator);
        jsonMarshaller.marshal(getWriteControlObject(), result);
        jsonGenerator.flush();
        
        log(sw.toString());
        compareStringToControlFile("**testJSONMarshalToBuilderResult**", sw.toString());
    }
	   
	 public void testJSONMarshalToOutputStream_FORMATTED() throws Exception{
	    jsonMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

Lines 52-59 public class UsAsciiTestCases extends JSONMarshalUnmarshalTestCases { Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/characters/UsAsciiTestCases.java (-1 / +5 lines)
52	return control;	52	return control;
53	}	53	}
54		54
55	public void marshalToObjectBuilderResult() throws Exception{	55	public void testJSONMarshalToBuilderResult() throws Exception{
56	//Currently not supported	56	//Currently not supported
57	}	57	}
58		58
		59	public void testJSONMarshalToGeneratorResult() throws Exception{
		60	//Currently not supported
		61
		62	}
59	}	63	}

Lines 49-52 public class JAXBElementJSONPaddingTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementJSONPaddingTestCases.java (+2 lines)
49	public void testJSONMarshalToBuilderResult() throws Exception{	49	public void testJSONMarshalToBuilderResult() throws Exception{
50	}	50	}
51		51
		52	public void testJSONMarshalToGeneratorResult() throws Exception{
		53	}
52	}	54	}

Lines 60-63 public class JAXBElementListJSONPaddingTestCases extends JSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementListJSONPaddingTestCases.java (+3 lines)
60		60
61	public void testJSONMarshalToBuilderResult() throws Exception{	61	public void testJSONMarshalToBuilderResult() throws Exception{
62	}	62	}
		63
		64	public void testJSONMarshalToGeneratorResult() throws Exception{
		65	}
63	}	66	}

Lines 45-49 public class JSONWithNullNameTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithNullNameTestCases.java (+3 lines)
45		45
46	public void testJSONMarshalToBuilderResult() throws Exception{	46	public void testJSONMarshalToBuilderResult() throws Exception{
47	}	47	}
		48
		49	public void testJSONMarshalToGeneratorResult() throws Exception{
		50	}
48		51
49	}	52	}

Lines 49-54 public class JSONWithNullObjectTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithNullObjectTestCases.java (+3 lines)
49	public void testJSONMarshalToBuilderResult() throws Exception{	49	public void testJSONMarshalToBuilderResult() throws Exception{
50	}	50	}
51		51
		52	public void testJSONMarshalToGeneratorResult() throws Exception{
		53	}
		54
52	@Override	55	@Override
53	public void assertMarshalException(Exception exception) throws Exception {	56	public void assertMarshalException(Exception exception) throws Exception {
54	Exception nestedException = (Exception) exception.getCause();	57	Exception nestedException = (Exception) exception.getCause();

Lines 58-63 public class JSONWithPaddingSimpleListTestCases extends JSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleListTestCases.java (+3 lines)
58	public void testJSONMarshalToBuilderResult() throws Exception{	58	public void testJSONMarshalToBuilderResult() throws Exception{
59	}	59	}
60		60
		61	public void testJSONMarshalToGeneratorResult() throws Exception{
		62	}
		63
61	// public boolean shouldRemoveWhitespaceFromControlDocJSON(){	64	// public boolean shouldRemoveWhitespaceFromControlDocJSON(){
62	// return false;	65	// return false;
63	//}	66	//}

Lines 51-55 public class JSONWithPaddingSimpleTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleTestCases.java (+3 lines)
51		51
52	public void testJSONMarshalToBuilderResult() throws Exception{	52	public void testJSONMarshalToBuilderResult() throws Exception{
53	}	53	}
		54
		55	public void testJSONMarshalToGeneratorResult() throws Exception{
		56	}
54		57
55	}	58	}

Lines 46-49 public class JSONWithUnsetNameTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithUnsetNameTestCases.java (+2 lines)
46	public void testJSONMarshalToBuilderResult() throws Exception{	46	public void testJSONMarshalToBuilderResult() throws Exception{
47	}	47	}
48		48
		49	public void testJSONMarshalToGeneratorResult() throws Exception{
		50	}
49	}	51	}

Lines 13-23 Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/rootlevellist/JsonObjectInArrayBuilderTestCases.java (+31 lines)
13	package org.eclipse.persistence.testing.jaxb.json.rootlevellist;	13	package org.eclipse.persistence.testing.jaxb.json.rootlevellist;
14		14
15	import java.io.StringWriter;	15	import java.io.StringWriter;
		16	import java.util.ArrayList;
		17	import java.util.List;
16		18
17	import javax.json.Json;	19	import javax.json.Json;
18	import javax.json.JsonArray;	20	import javax.json.JsonArray;
19	import javax.json.JsonArrayBuilder;	21	import javax.json.JsonArrayBuilder;
20	import javax.json.JsonWriter;	22	import javax.json.JsonWriter;
		23	import javax.json.stream.JsonGenerator;
21	import javax.xml.bind.JAXBContext;	24	import javax.xml.bind.JAXBContext;
22	import javax.xml.bind.Marshaller;	25	import javax.xml.bind.Marshaller;
23		26
Lines 26-31 import org.eclipse.persistence.jaxb.JAXBMarshaller; Link Here
26	import org.eclipse.persistence.jaxb.MarshallerProperties;	29	import org.eclipse.persistence.jaxb.MarshallerProperties;
27	import org.eclipse.persistence.oxm.MediaType;	30	import org.eclipse.persistence.oxm.MediaType;
28	import org.eclipse.persistence.oxm.json.JsonArrayBuilderResult;	31	import org.eclipse.persistence.oxm.json.JsonArrayBuilderResult;
		32	import org.eclipse.persistence.oxm.json.JsonGeneratorResult;
29	import org.eclipse.persistence.testing.oxm.OXTestCase;	33	import org.eclipse.persistence.testing.oxm.OXTestCase;
30		34
31	public class JsonObjectInArrayBuilderTestCases extends OXTestCase {	35	public class JsonObjectInArrayBuilderTestCases extends OXTestCase {
Lines 64-69 public class JsonObjectInArrayBuilderTestCases extends OXTestCase { Link Here
64	String controlString = "[{\"name\":\"FOO\"},{\"name\":\"FOO2\"}]";	68	String controlString = "[{\"name\":\"FOO\"},{\"name\":\"FOO2\"}]";
65	assertEquals(controlString, sw.toString());	69	assertEquals(controlString, sw.toString());
66	}	70	}
		71
		72	public void testMarshalToGeneratorResult() throws Exception{
		73	JAXBContext ctx = JAXBContextFactory.createContext(new Class[]{WithoutXmlRootElementRoot.class}, null);
		74	Marshaller jsonMarshaller = ctx.createMarshaller();
		75	jsonMarshaller.setProperty(MarshallerProperties.MEDIA_TYPE, MediaType.APPLICATION_JSON);
		76	jsonMarshaller.setProperty(MarshallerProperties.JSON_INCLUDE_ROOT, false);
		77
		78	StringWriter sw = new StringWriter();
		79	JsonGenerator jsonGenerator = Json.createGenerator(sw);
		80	JsonGeneratorResult result = new JsonGeneratorResult(jsonGenerator);
		81
		82	WithoutXmlRootElementRoot foo = new WithoutXmlRootElementRoot();
		83	foo.setName("FOO");
		84
		85	WithoutXmlRootElementRoot foo2 = new WithoutXmlRootElementRoot();
		86	foo2.setName("FOO2");
		87
		88	List<WithoutXmlRootElementRoot> things = new ArrayList<WithoutXmlRootElementRoot>();
		89	things.add(foo);
		90	things.add(foo2);
		91	jsonMarshaller.marshal(things, result);
		92	jsonGenerator.flush();
		93
		94	log(sw.toString());
		95	String controlString = "[{\"name\":\"FOO\"},{\"name\":\"FOO2\"}]";
		96	assertEquals(controlString, sw.toString());
		97	}
67		98
68	public void testMarshalToArrayBuilderResultWithRoot() throws Exception{	99	public void testMarshalToArrayBuilderResultWithRoot() throws Exception{
69	JAXBContext ctx = JAXBContextFactory.createContext(new Class[]{WithXmlRootElementRoot.class}, null);	100	JAXBContext ctx = JAXBContextFactory.createContext(new Class[]{WithXmlRootElementRoot.class}, null);




		return r;
	}

	public void assertMarshalException(Exception exception) throws Exception {
	    Throwable nested = exception.getCause();// getLinkedException();
        assertTrue(nested instanceof XMLMarshalException);
        if(((XMLMarshalException)nested).getErrorCode() == XMLMarshalException.NULL_VALUE_NOT_ALLOWED_FOR_VARIABLE){
            return;
        }    
        fail("Expected exception did not occur.");
			return;
		}
		fail("An XMLMarshalException should have occurred");
	}
	
    public void testJSONMarshalToOutputStream() throws Exception{
    	try{
     		super.testJSONMarshalToOutputStream();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
    }
    
    public void testJSONMarshalToBuilderResult() throws Exception{
        try{
            super.testJSONMarshalToBuilderResult();
        }catch(JAXBException e){
            if(verifyException(e)){
                return;
            }
        }
        fail("An XMLMarshalException should have occurred");
    }
    
    public void testJSONMarshalToStringWriter_FORMATTED() throws Exception{
    	try{
     		super.testJSONMarshalToStringWriter_FORMATTED();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
    }
    
    public void testJSONMarshalToOutputStream_FORMATTED() throws Exception{
    	try{
     		super.testJSONMarshalToOutputStream_FORMATTED();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
    }
    
    public void testJSONMarshalToStringWriter() throws Exception{
    	try{
     		super.testJSONMarshalToStringWriter();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
    }
    
    public void testObjectToOutputStream() throws Exception {
    	try{
     		super.testObjectToOutputStream();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
    }
    
    private boolean verifyException(JAXBException e){
    	Throwable nested = e.getLinkedException();
		assertTrue(nested instanceof XMLMarshalException);
		if(((XMLMarshalException)nested).getErrorCode() == XMLMarshalException.NULL_VALUE_NOT_ALLOWED_FOR_VARIABLE){
			return true;
		}
		if(((XMLMarshalException)nested).getErrorCode() == XMLMarshalException.MARSHAL_EXCEPTION){
			Throwable internalException = ((XMLMarshalException)nested).getInternalException(); 
			assertTrue(internalException instanceof XMLMarshalException);
			if(((XMLMarshalException)internalException).getErrorCode() == XMLMarshalException.NULL_VALUE_NOT_ALLOWED_FOR_VARIABLE){
				return true;
			}
		}
		return false;
    }
    public void testObjectToOutputStreamASCIIEncoding() throws Exception {
    	try{
     		super.testObjectToOutputStreamASCIIEncoding();
		}catch(JAXBException e){			
		    if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
   
    }
    
    public void testObjectToXMLDocument() throws Exception {
    	try{
     		super.testObjectToXMLDocument();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
   
    }

    public void testObjectToXMLStreamWriter() throws Exception {
    	try{
     		super.testObjectToXMLStreamWriter();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
   
    }
    
    public void testObjectToXMLStreamWriterRecord() throws Exception {
    	try{
     		super.testObjectToXMLStreamWriterRecord();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
   
    }
    
    public void testObjectToXMLEventWriter() throws Exception {
    	try{
     		super.testObjectToXMLEventWriter();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
   
    }
    public void testObjectToContentHandler() throws Exception {
    	try{
     		super.testObjectToContentHandler();
		}catch(JAXBException e){
			if(verifyException(e)){
		    	return;
		    }
		}
		fail("An XMLMarshalException should have occurred");
   
    }    
}

Return to bug 411382

Added Link Here

(-)a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonGeneratorResult.java (+34 lines)
1	/*******************************************************************************
2	* Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.
3	* This program and the accompanying materials are made available under the
4	* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
5	* which accompanies this distribution.
6	* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
7	* and the Eclipse Distribution License is available at
8	* http://www.eclipse.org/org/documents/edl-v10.php.
9	*
10	* Contributors:
11	* Denise Smith - 2.6 - initial implementation
12	******************************************************************************/
13	package org.eclipse.persistence.oxm.json;
14
15	import javax.json.stream.JsonGenerator;
16
17	import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
18	import org.eclipse.persistence.oxm.record.JsonGeneratorRecord;
19
20	public class JsonGeneratorResult extends ExtendedResult{
21
22	private JsonGenerator generator;
23
24	public JsonGeneratorResult(JsonGenerator generator){
25	this.generator = generator;
26	}
27
28	@Override
29	public org.eclipse.persistence.oxm.record.MarshalRecord createRecord() {
30	JsonGeneratorRecord record = new JsonGeneratorRecord(generator);
31	return record;
32	}
33
34	}

Lines 28-33 import javax.json.JsonObjectBuilder; Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java (-1 / +22 lines)
28	import javax.json.JsonReader;	28	import javax.json.JsonReader;
29	import javax.json.JsonStructure;	29	import javax.json.JsonStructure;
30	import javax.json.JsonWriter;	30	import javax.json.JsonWriter;
		31	import javax.json.stream.JsonGenerator;
31	import javax.json.stream.JsonParser;	32	import javax.json.stream.JsonParser;
32	import javax.xml.bind.JAXBElement;	33	import javax.xml.bind.JAXBElement;
33	import javax.xml.bind.Marshaller;	34	import javax.xml.bind.Marshaller;
Lines 41-46 import org.eclipse.persistence.jaxb.JAXBContext; Link Here
41	import org.eclipse.persistence.jaxb.MarshallerProperties;	42	import org.eclipse.persistence.jaxb.MarshallerProperties;
42	import org.eclipse.persistence.jaxb.UnmarshallerProperties;	43	import org.eclipse.persistence.jaxb.UnmarshallerProperties;
43	import org.eclipse.persistence.oxm.MediaType;	44	import org.eclipse.persistence.oxm.MediaType;
		45	import org.eclipse.persistence.oxm.json.JsonGeneratorResult;
44	import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;	46	import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
45	import org.eclipse.persistence.oxm.json.JsonStructureSource;	47	import org.eclipse.persistence.oxm.json.JsonStructureSource;
46	import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;	48	import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;
Lines 314-319 public abstract class JAXBWithJSONTestCases extends JAXBTestCases { Link Here
314	log(sw.toString());	316	log(sw.toString());
315	compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());	317	compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());
316	}	318	}
		319
317	public void testJSONMarshalToBuilderResult() throws Exception{	320	public void testJSONMarshalToBuilderResult() throws Exception{
318	getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");	321	getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
319		322
Lines 333-341 public abstract class JAXBWithJSONTestCases extends JAXBTestCases { Link Here
333	writer.close();	336	writer.close();
334		337
335	log(sw.toString());	338	log(sw.toString());
336	compareStringToControlFile("testJSONMarshalToStringWriter", sw.toString());	339	compareStringToControlFile("testJSONMarshalToBuilderResult", sw.toString());
337	}	340	}
338		341
		342	public void testJSONMarshalToGeneratorResult() throws Exception{
		343	getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
		344
		345	StringWriter sw = new StringWriter();
		346	JsonGenerator generator= Json.createGenerator(sw);
		347	JsonGeneratorResult result = new JsonGeneratorResult(generator);
		348	try{
		349	getJSONMarshaller().marshal(getWriteControlObject(), result);
		350	} catch(Exception e) {
		351	assertMarshalException(e);
		352	return;
		353	}
		354	generator.flush();
		355	log(sw.toString());
		356	compareStringToControlFile("testJSONMarshalToGeneratorResult", sw.toString());
		357	}
		358
		359
339	protected void compareStringToControlFile(String test, String testString) {	360	protected void compareStringToControlFile(String test, String testString) {
340	compareStringToControlFile(test, testString, getWriteControlJSON());	361	compareStringToControlFile(test, testString, getWriteControlJSON());
341	}	362	}

Lines 28-33 import javax.json.JsonObject; Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONTestCases.java (+14 lines)
28	import javax.json.JsonObjectBuilder;	28	import javax.json.JsonObjectBuilder;
29	import javax.json.JsonWriter;	29	import javax.json.JsonWriter;
30	import javax.json.JsonWriterFactory;	30	import javax.json.JsonWriterFactory;
		31	import javax.json.stream.JsonGenerator;
31	import javax.xml.bind.JAXBContext;	32	import javax.xml.bind.JAXBContext;
32	import javax.xml.bind.JAXBElement;	33	import javax.xml.bind.JAXBElement;
33	import javax.xml.bind.Marshaller;	34	import javax.xml.bind.Marshaller;
Lines 38-43 import org.eclipse.persistence.jaxb.MarshallerProperties; Link Here
38	import org.eclipse.persistence.jaxb.UnmarshallerProperties;	39	import org.eclipse.persistence.jaxb.UnmarshallerProperties;
39	import org.eclipse.persistence.oxm.XMLContext;	40	import org.eclipse.persistence.oxm.XMLContext;
40	import org.eclipse.persistence.oxm.json.JsonArrayBuilderResult;	41	import org.eclipse.persistence.oxm.json.JsonArrayBuilderResult;
		42	import org.eclipse.persistence.oxm.json.JsonGeneratorResult;
41	import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;	43	import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
42	import org.eclipse.persistence.testing.oxm.OXTestCase;	44	import org.eclipse.persistence.testing.oxm.OXTestCase;
43		45
Lines 225-230 public abstract class JSONTestCases extends OXTestCase{ Link Here
225	log(sw.toString());	227	log(sw.toString());
226	compareStringToControlFile("testJSONMarshalToBuilderResult", sw.toString());	228	compareStringToControlFile("testJSONMarshalToBuilderResult", sw.toString());
227	}	229	}
		230
		231	public void testJSONMarshalToGeneratorResult() throws Exception{
		232
		233	StringWriter sw = new StringWriter();
		234	JsonGenerator jsonGenerator = Json.createGenerator(sw);
		235	JsonGeneratorResult result = new JsonGeneratorResult(jsonGenerator);
		236	jsonMarshaller.marshal(getWriteControlObject(), result);
		237	jsonGenerator.flush();
		238
		239	log(sw.toString());
		240	compareStringToControlFile("testJSONMarshalToBuilderResult", sw.toString());
		241	}
228		242
229	public void testJSONMarshalToOutputStream_FORMATTED() throws Exception{	243	public void testJSONMarshalToOutputStream_FORMATTED() throws Exception{
230	jsonMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);	244	jsonMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

Lines 63-229 public class XmlVariableNodeNullValueTestCases extends JAXBWithJSONTestCases{ Link Here

(-)a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/xmlvariablenode/XmlVariableNodeNullValueTestCases.java (-162 / +7 lines)
63	return r;	63	return r;
64	}	64	}
65		65
66	public void objectToXMLStringWriter(Object objectToWrite) throws Exception {	66	public void assertMarshalException(Exception exception) throws Exception {
67	try{	67	Throwable nested = exception.getCause();// getLinkedException();
68	super.objectToXMLStringWriter(objectToWrite);	68	assertTrue(nested instanceof XMLMarshalException);
69	}catch(JAXBException e){	69	if(((XMLMarshalException)nested).getErrorCode() == XMLMarshalException.NULL_VALUE_NOT_ALLOWED_FOR_VARIABLE){
70	Throwable nested = e.getLinkedException();	70	return;
71	assertTrue(nested instanceof XMLMarshalException);	71	}
72	assertEquals(XMLMarshalException.NULL_VALUE_NOT_ALLOWED_FOR_VARIABLE,((XMLMarshalException)nested).getErrorCode());	72	fail("Expected exception did not occur.");
73	return;
74	}
75	fail("An XMLMarshalException should have occurred");
76	}
77
78	public void testJSONMarshalToOutputStream() throws Exception{
79	try{
80	super.testJSONMarshalToOutputStream();
81	}catch(JAXBException e){
82	if(verifyException(e)){
83	return;
84	}
85	}
86	fail("An XMLMarshalException should have occurred");
87	}
88
89	public void testJSONMarshalToBuilderResult() throws Exception{
90	try{
91	super.testJSONMarshalToBuilderResult();
92	}catch(JAXBException e){
93	if(verifyException(e)){
94	return;
95	}
96	}
97	fail("An XMLMarshalException should have occurred");
98	}
99
100	public void testJSONMarshalToStringWriter_FORMATTED() throws Exception{
101	try{
102	super.testJSONMarshalToStringWriter_FORMATTED();
103	}catch(JAXBException e){
104	if(verifyException(e)){
105	return;
106	}
107	}
108	fail("An XMLMarshalException should have occurred");
109	}
110
111	public void testJSONMarshalToOutputStream_FORMATTED() throws Exception{
112	try{
113	super.testJSONMarshalToOutputStream_FORMATTED();
114	}catch(JAXBException e){
115	if(verifyException(e)){
116	return;
117	}
118	}
119	fail("An XMLMarshalException should have occurred");
120	}
121
122	public void testJSONMarshalToStringWriter() throws Exception{
123	try{
124	super.testJSONMarshalToStringWriter();
125	}catch(JAXBException e){
126	if(verifyException(e)){
127	return;
128	}
129	}
130	fail("An XMLMarshalException should have occurred");
131	}
132
133	public void testObjectToOutputStream() throws Exception {
134	try{
135	super.testObjectToOutputStream();
136	}catch(JAXBException e){
137	if(verifyException(e)){
138	return;
139	}
140	}
141	fail("An XMLMarshalException should have occurred");
142	}
143
144	private boolean verifyException(JAXBException e){
145	Throwable nested = e.getLinkedException();
146	assertTrue(nested instanceof XMLMarshalException);
147	if(((XMLMarshalException)nested).getErrorCode() == XMLMarshalException.NULL_VALUE_NOT_ALLOWED_FOR_VARIABLE){
148	return true;
149	}
150	if(((XMLMarshalException)nested).getErrorCode() == XMLMarshalException.MARSHAL_EXCEPTION){
151	Throwable internalException = ((XMLMarshalException)nested).getInternalException();
152	assertTrue(internalException instanceof XMLMarshalException);
153	if(((XMLMarshalException)internalException).getErrorCode() == XMLMarshalException.NULL_VALUE_NOT_ALLOWED_FOR_VARIABLE){
154	return true;
155	}
156	}
157	return false;
158	}
159	public void testObjectToOutputStreamASCIIEncoding() throws Exception {
160	try{
161	super.testObjectToOutputStreamASCIIEncoding();
162	}catch(JAXBException e){
163	if(verifyException(e)){
164	return;
165	}
166	}
167	fail("An XMLMarshalException should have occurred");
168
169	}
170
171	public void testObjectToXMLDocument() throws Exception {
172	try{
173	super.testObjectToXMLDocument();
174	}catch(JAXBException e){
175	if(verifyException(e)){
176	return;
177	}
178	}
179	fail("An XMLMarshalException should have occurred");
180
181	}
182
183	public void testObjectToXMLStreamWriter() throws Exception {
184	try{
185	super.testObjectToXMLStreamWriter();
186	}catch(JAXBException e){
187	if(verifyException(e)){
188	return;
189	}
190	}
191	fail("An XMLMarshalException should have occurred");
192
193	}
194
195	public void testObjectToXMLStreamWriterRecord() throws Exception {
196	try{
197	super.testObjectToXMLStreamWriterRecord();
198	}catch(JAXBException e){
199	if(verifyException(e)){
200	return;
201	}
202	}
203	fail("An XMLMarshalException should have occurred");
204
205	}
206
207	public void testObjectToXMLEventWriter() throws Exception {
208	try{
209	super.testObjectToXMLEventWriter();
210	}catch(JAXBException e){
211	if(verifyException(e)){
212	return;
213	}
214	}
215	fail("An XMLMarshalException should have occurred");
216
217	}	73	}
218	public void testObjectToContentHandler() throws Exception {
219	try{
220	super.testObjectToContentHandler();
221	}catch(JAXBException e){
222	if(verifyException(e)){
223	return;
224	}
225	}
226	fail("An XMLMarshalException should have occurred");
227
228	}
229	}	74	}