Attachment 233635 Details for Bug 411377 – Work in progress

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

[patch] Work in progress

bug411377_trunk_updated.patch (text/plain), 79.01 KB, created by Denise Smith

on 2013-07-19 16:16:51 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Denise Smith

Created: 2013-07-19 16:16:51 EDT

Size: 79.01 KB

patch

obsolete

> .../XMLCompositeCollectionMappingNodeValue.java    |   3 +-
> .../persistence/internal/oxm/XMLMarshaller.java    |   5 +-
> .../internal/oxm/record/ExtendedResult.java        |  32 +
> .../oxm/record/json/JsonStructureReader.java       | 118 +--
> .../org/eclipse/persistence/oxm/XMLMarshaller.java |  24 +-
> .../oxm/json/JsonArrayBuilderResult.java           |  42 ++
> .../oxm/json/JsonObjectBuilderResult.java          |  43 ++
> .../oxm/record/JSONFormattedWriterRecord.java      |   6 +-
> .../persistence/oxm/record/JSONWriterRecord.java   |  15 +-
> .../oxm/record/JsonObjectBuilderWriterRecord.java  | 814 +++++++++++++++++++++
> .../mappings/anycollection/employee.json           |   6 +-
> .../anycollection/write-only-employee.json         |   4 +-
> .../jaxb/javadoc/xmlidref/xmlidrefcontainment.json |   2 +-
> .../testing/jaxb/JAXBWithJSONTestCases.java        |  23 +-
> .../javadoc/xmlidref/XmlIdRefContainmentTest.java  |   3 +
> .../jaxb/json/JSONMarshalUnmarshalTestCases.java   |  21 +
> .../testing/jaxb/json/JSONTestCases.java           |  53 ++
> .../jaxb/json/characters/UsAsciiTestCases.java     |  29 +
> .../padding/JAXBElementJSONPaddingTestCases.java   |   4 +
> .../JAXBElementListJSONPaddingTestCases.java       |   3 +
> .../json/padding/JSONWithNullNameTestCases.java    |   4 +
> .../JSONWithPaddingSimpleListTestCases.java        |   3 +
> .../padding/JSONWithPaddingSimpleTestCases.java    |   4 +
> .../json/padding/JSONWithUnsetNameTestCases.java   |   4 +
> .../XmlVariableNodeNullValueTestCases.java         |  11 +
>
> 30 files changed, 1151 insertions(+), 146 deletions(-)
>
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLCompositeCollectionMappingNodeValue.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLCompositeCollectionMappingNodeValue.java
>index 6698fdb..b363aad 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLCompositeCollectionMappingNodeValue.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLCompositeCollectionMappingNodeValue.java
>@@ -88,7 +88,7 @@ public class XMLCompositeCollectionMappingNodeValue extends XMLRelationshipMappi
>         } else {
>         	return marshalRecord.emptyCollection(xPathFragment, namespaceResolver, xmlCompositeCollectionMapping.getWrapperNullPolicy() != null);
>         }
>-        marshalRecord.startCollection(); 
>+        
>         
>         int size =marshalRecord.getCycleDetectionStack().size(); 
>         //when writing the collection need to see if any of the objects we are writing are in the parent collection inverse ref
>@@ -98,6 +98,7 @@ public class XMLCompositeCollectionMappingNodeValue extends XMLRelationshipMappi
>         		return false;
>         	}
>          }
>+        marshalRecord.startCollection(); 
>         iterator = cp.iteratorFor(collection);
>         while (cp.hasNext(iterator)) {
>             Object objectValue = cp.next(iterator, session);
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java
>index 21c2a78..012a01f 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLMarshaller.java
>@@ -42,6 +42,7 @@ import org.eclipse.persistence.internal.core.sessions.CoreAbstractSession;
> import org.eclipse.persistence.internal.oxm.mappings.Descriptor;
> import org.eclipse.persistence.internal.oxm.mappings.Field;
> import org.eclipse.persistence.internal.oxm.record.AbstractMarshalRecord;
>+import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
> import org.eclipse.persistence.internal.oxm.record.namespaces.PrefixMapperNamespaceResolver;
> import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
> import org.eclipse.persistence.oxm.JSONWithPadding;
>@@ -1014,7 +1015,9 @@ public abstract class XMLMarshaller<
>         } else if (result instanceof SAXResult) {
>             SAXResult saxResult = (SAXResult) result;
>             marshal(object, saxResult.getHandler());
>-        } else {
>+        } else if (result instanceof ExtendedResult){           
>+            marshal(object, ((ExtendedResult)result).createRecord(), session, xmlDescriptor, isXMLRoot);
>+        }else {
>             if (result.getClass().equals(staxResultClass)) {
>                 try {
>                     Object xmlStreamWriter = PrivilegedAccessHelper.invokeMethod(staxResultGetStreamWriterMethod, result);
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/ExtendedResult.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/ExtendedResult.java
>new file mode 100644
>index 0000000..eaaa1df
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/ExtendedResult.java
>@@ -0,0 +1,32 @@
>+/*******************************************************************************
>+ * 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.internal.oxm.record;
>+
>+import javax.xml.transform.Result;
>+
>+public abstract class ExtendedResult implements Result {
>+
>+    private String systemId;
>+
>+    public abstract org.eclipse.persistence.oxm.record.MarshalRecord createRecord();
>+    
>+    @Override
>+    public void setSystemId(String systemId) {
>+        this.systemId = systemId;        
>+    }
>+
>+    @Override
>+    public String getSystemId() {
>+        return systemId;
>+    }
>+}
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/json/JsonStructureReader.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/json/JsonStructureReader.java
>index 16f2c70..0db4751 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/json/JsonStructureReader.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/record/json/JsonStructureReader.java
>@@ -40,70 +40,35 @@ import javax.xml.namespace.QName;
> 
> import org.eclipse.persistence.exceptions.XMLMarshalException;
> import org.eclipse.persistence.internal.oxm.CollectionGroupingElementNodeValue;
>-import org.eclipse.persistence.internal.oxm.ConversionManager;
> import org.eclipse.persistence.internal.oxm.Constants;
> import org.eclipse.persistence.internal.oxm.ContainerValue;
> import org.eclipse.persistence.internal.oxm.MappingNodeValue;
>-import org.eclipse.persistence.internal.oxm.MediaType;
> import org.eclipse.persistence.internal.oxm.NamespaceResolver;
> import org.eclipse.persistence.internal.oxm.NodeValue;
> import org.eclipse.persistence.internal.oxm.Root;
> import org.eclipse.persistence.internal.oxm.Unmarshaller;
> import org.eclipse.persistence.internal.oxm.XPathFragment;
>-import org.eclipse.persistence.internal.oxm.mappings.Field;
>-import org.eclipse.persistence.internal.oxm.record.AbstractUnmarshalRecord;
> import org.eclipse.persistence.internal.oxm.record.SAXUnmarshallerHandler;
> import org.eclipse.persistence.internal.oxm.record.UnmarshalRecord;
> import org.eclipse.persistence.internal.oxm.XPathNode;
>-import org.eclipse.persistence.internal.oxm.record.XMLReaderAdapter;
> import org.eclipse.persistence.internal.oxm.record.deferred.DeferredContentHandler;
>-import org.eclipse.persistence.oxm.mappings.nullpolicy.AbstractNullPolicy;
> import org.eclipse.persistence.oxm.record.XMLRootRecord;
>-import org.xml.sax.ErrorHandler;
> import org.xml.sax.InputSource;
> import org.xml.sax.SAXException;
> import org.xml.sax.helpers.AttributesImpl;
> 
>-public class JsonStructureReader extends XMLReaderAdapter {
>+public class JsonStructureReader extends JsonPReader {
> 
>-    private static final String TRUE = "true";
>-    private static final String FALSE = "false";
>-    private String attributePrefix = null;
>-    private NamespaceResolver namespaces = null;
>-    private boolean includeRoot;
>-    private String textWrapper;
>-    private Class unmarshalClass;
>-    private boolean isInCollection;
>     private JsonStructure jsonStructure;
>     private JsonAttributes attributes = new JsonAttributes();
> 
>-
>     public JsonStructureReader(Unmarshaller u) {
>         this(u, null);        
>     }
>     
>     public JsonStructureReader(Unmarshaller u, Class clazz) {
>-        this(u.getAttributePrefix(), u.getNamespaceResolver(), u.getNamespaceResolver() != null, u.isIncludeRoot(), u.getNamespaceSeparator(), u.getErrorHandler(), u.getValueWrapper(), clazz);
>-    }
>-
>-    private JsonStructureReader(String attrPrefix, NamespaceResolver nr,boolean namespaceAware, boolean includeRoot,Character namespaceSeparator, ErrorHandler errorHandler, String textWrapper, Class unmarshalClass) {
>-        this.attributePrefix = attrPrefix;
>-        if (attributePrefix == Constants.EMPTY_STRING) {
>-            attributePrefix = null;
>-        }
>-        namespaces = nr;
>-        this.namespaceAware = namespaceAware;
>-        if (namespaceSeparator == null) {
>-            this.namespaceSeparator = Constants.DOT;
>-        } else {
>-            this.namespaceSeparator = namespaceSeparator;
>-        }
>-        this.includeRoot = includeRoot;
>-        this.setErrorHandler(errorHandler);
>-        this.textWrapper = textWrapper;
>-        this.unmarshalClass = unmarshalClass;
>+        super(u.getAttributePrefix(), u.getNamespaceResolver(), u.getNamespaceResolver() != null, u.isIncludeRoot(), u.getNamespaceSeparator(), u.getErrorHandler(), u.getValueWrapper(), clazz);
>     }
>-    
> 
>     public void setJsonStructure(JsonStructure jsonStructure) {
>         this.jsonStructure = jsonStructure;
>@@ -152,17 +117,6 @@ public class JsonStructureReader extends XMLReaderAdapter {
>         }
>     }
> 
>-    @Override
>-    public void parse(String systemId) {
>-        try {
>-            parse(new InputSource(systemId));
>-        } catch (IOException e) {
>-            throw XMLMarshalException.unmarshalException(e);
>-        } catch (SAXException e) {
>-            throw XMLMarshalException.unmarshalException(e);
>-        }
>-    }
>-
>     public void parseRoot(JsonValue jsonValue) throws SAXException {
>         if (namespaces != null) {
>             Map<String, String> namespacePairs = namespaces.getPrefixesToNamespaces();
>@@ -453,74 +407,6 @@ public class JsonStructureReader extends XMLReaderAdapter {
> 
>     }
> 
>-    public boolean isNullRepresentedByXsiNil(AbstractNullPolicy nullPolicy) {
>-        return true;
>-    }
>-
>-    private void startCollection() {
>-        isInCollection = true;
>-    }
>-
>-    private void endCollection() {
>-        isInCollection = false;
>-    }
>-
>-    public boolean isInCollection() {
>-        return isInCollection;
>-    }
>-
>-    private boolean isTextValue(String localName) {
>-        XPathNode currentNode = ((UnmarshalRecord) contentHandler).getXPathNode();
>-        if (currentNode == null) {
>-            return textWrapper != null && textWrapper.equals(localName);
>-        }
>-
>-        return ((currentNode.getNonAttributeChildrenMap() == null || currentNode.getNonAttributeChildrenMap().size() == 0 || (currentNode.getNonAttributeChildrenMap().size() == 1 && currentNode.getTextNode() != null))&& textWrapper != null && textWrapper.equals(localName));
>-    }
>-
>-    @Override
>-    public Object convertValueBasedOnSchemaType(Field xmlField, Object value, ConversionManager conversionManager, AbstractUnmarshalRecord record) {
>-        if (xmlField.getSchemaType() != null) {
>-            if (Constants.QNAME_QNAME.equals(xmlField.getSchemaType())) {
>-                String stringValue = (String) value;
>-                int indexOpen = stringValue.indexOf('{');
>-                int indexClose = stringValue.indexOf('}');
>-                String uri = null;
>-                String localName = null;
>-                if (indexOpen > -1 && indexClose > -1) {
>-                    uri = stringValue.substring(indexOpen + 1, indexClose);
>-                    localName = stringValue.substring(indexClose + 1);
>-                } else {
>-                    QName obj = (QName) xmlField.convertValueBasedOnSchemaType(stringValue, conversionManager, record);
>-                    localName = obj.getLocalPart();
>-                    uri = obj.getNamespaceURI();
>-                }
>-                if (uri != null) {
>-                    return new QName(uri, localName);
>-                } else {
>-                    return new QName(localName);
>-                }
>-            } else {
>-                Class fieldType = xmlField.getType();
>-                if (fieldType == null) {
>-                    fieldType = xmlField.getJavaClass(xmlField.getSchemaType());
>-                }
>-                return conversionManager.convertObject(value, fieldType, xmlField.getSchemaType());
>-            }
>-        }
>-        return value;
>-    }
>-
>-    /**
>-     * INTERNAL: The MediaType associated with this reader
>-     * 
>-     * @return
>-     */
>-    @Override
>-    public MediaType getMediaType() {
>-        return Constants.APPLICATION_JSON;
>-    }
>-
>     private static class JsonAttributes extends IndexedAttributeList {
> 
>         private JsonValue value;
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/XMLMarshaller.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/XMLMarshaller.java
>index f085f90..22c59b0 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/XMLMarshaller.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/XMLMarshaller.java
>@@ -12,6 +12,7 @@
>  ******************************************************************************/
> package org.eclipse.persistence.oxm;
> 
>+import java.util.Collection;
> import java.util.Properties;
> 
> import javax.xml.transform.Result;
>@@ -23,6 +24,7 @@ import org.eclipse.persistence.internal.oxm.Root;
> import org.eclipse.persistence.internal.oxm.TreeObjectBuilder;
> import org.eclipse.persistence.internal.oxm.XMLObjectBuilder;
> import org.eclipse.persistence.internal.oxm.XPathEngine;
>+import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
> import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
> import org.eclipse.persistence.internal.sessions.AbstractSession;
> import org.eclipse.persistence.oxm.documentpreservation.DocumentPreservationPolicy;
>@@ -139,8 +141,26 @@ public class XMLMarshaller extends org.eclipse.persistence.internal.oxm.XMLMarsh
>             }
>         }else{
>             Class objectClass = object.getClass();
>-            session = context.getSession(objectClass);
>-            xmlDescriptor = getDescriptor(objectClass, session);
>+            if(result instanceof ExtendedResult){
>+                MarshalRecord writerRecord = ((ExtendedResult)result).createRecord();
>+                if(object instanceof Collection){
>+                    writerRecord.startCollection();
>+                    for(Object o : (Collection) object) {                        
>+                        marshal(o, writerRecord);
>+                    }
>+                    writerRecord.endCollection();
>+                    return;
>+                }else{
>+                    marshal(object, writerRecord);
>+                    return;
>+                }
>+            }
>+            if(session == null || xmlDescriptor == null){
>+                session = context.getSession(objectClass);
>+                xmlDescriptor = getDescriptor(objectClass, session);
>+            }
>+            
>+            
>         }
> 
>         //if this is a simple xml root, the session and descriptor will be null
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonArrayBuilderResult.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonArrayBuilderResult.java
>new file mode 100644
>index 0000000..fc48290
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonArrayBuilderResult.java
>@@ -0,0 +1,42 @@
>+/*******************************************************************************
>+ * 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.Json;
>+import javax.json.JsonArrayBuilder;
>+import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
>+import org.eclipse.persistence.oxm.record.JsonObjectBuilderWriterRecord;
>+
>+
>+public class JsonArrayBuilderResult extends ExtendedResult{
>+
>+    private JsonArrayBuilder jsonArrayBuilder;
>+        
>+    public JsonArrayBuilderResult(){
>+        this.jsonArrayBuilder = Json.createArrayBuilder();
>+    }
>+    
>+    public JsonArrayBuilderResult(JsonArrayBuilder jsonArrayBuilder){
>+        this.jsonArrayBuilder = jsonArrayBuilder;
>+    }
>+
>+    @Override
>+    public org.eclipse.persistence.oxm.record.MarshalRecord createRecord() {       
>+         return new JsonObjectBuilderWriterRecord(jsonArrayBuilder);
>+    }
>+
>+    public JsonArrayBuilder getJsonArrayBuilder() {
>+        return jsonArrayBuilder;
>+    }
>+
>+}
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonObjectBuilderResult.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonObjectBuilderResult.java
>new file mode 100644
>index 0000000..d801b9d
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/json/JsonObjectBuilderResult.java
>@@ -0,0 +1,43 @@
>+/*******************************************************************************
>+ * 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.Json;
>+import javax.json.JsonObjectBuilder;
>+import org.eclipse.persistence.internal.oxm.record.ExtendedResult;
>+//import org.eclipse.persistence.internal.oxm.record.MarshalRecord;
>+import org.eclipse.persistence.oxm.record.JsonObjectBuilderWriterRecord;
>+
>+
>+public class JsonObjectBuilderResult extends ExtendedResult{
>+
>+    private JsonObjectBuilder jsonObjectBuilder;
>+    
>+    public JsonObjectBuilderResult(){        
>+        this.jsonObjectBuilder = Json.createObjectBuilder();
>+    }
>+    
>+    public JsonObjectBuilderResult(JsonObjectBuilder jsonObjectBuilder){
>+        this.jsonObjectBuilder = jsonObjectBuilder;
>+    }
>+
>+    @Override
>+    public org.eclipse.persistence.oxm.record.MarshalRecord createRecord() {       
>+         return new JsonObjectBuilderWriterRecord(jsonObjectBuilder);
>+    }
>+
>+    public JsonObjectBuilder getJsonObjectBuilder() {
>+        return jsonObjectBuilder;
>+    }
>+
>+}
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONFormattedWriterRecord.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONFormattedWriterRecord.java
>index 981f0a1..6de938c 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONFormattedWriterRecord.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONFormattedWriterRecord.java
>@@ -15,7 +15,6 @@ package org.eclipse.persistence.oxm.record;
> import java.io.IOException;
> import java.io.Writer;
> 
>-import org.eclipse.persistence.exceptions.JAXBException;
> import org.eclipse.persistence.exceptions.XMLMarshalException;
> import org.eclipse.persistence.internal.oxm.Constants;
> import org.eclipse.persistence.internal.oxm.NamespaceResolver;
>@@ -122,10 +121,7 @@ public class JSONFormattedWriterRecord extends JSONWriterRecord {
>                 }
>             }
>             if(xPathFragment.nameIsText()){
>-               if(position != null && position.isCollection() && position.isEmptyCollection()) {
>-            	    if(!charactersAllowed){
>-              		     throw JAXBException.jsonValuePropertyRequired("[");   
>-              	    }
>+               if(position != null && position.isCollection() && position.isEmptyCollection()) {            	    
>                     writer.write('[');
>                     writer.write(' ');
>                     position.setEmptyCollection(false);
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONWriterRecord.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONWriterRecord.java
>index 38831e8..977b7bc 100644
>--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONWriterRecord.java
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JSONWriterRecord.java
>@@ -21,7 +21,6 @@ import java.util.Stack;
> 
> import javax.xml.namespace.QName;
> 
>-import org.eclipse.persistence.exceptions.JAXBException;
> import org.eclipse.persistence.exceptions.XMLMarshalException;
> import org.eclipse.persistence.internal.core.helper.CoreClassConstants;
> import org.eclipse.persistence.internal.core.helper.CoreConversionManager;
>@@ -237,10 +236,7 @@ public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> {
>                 }
>             }
>             if(xPathFragment.nameIsText()){
>-                if(position != null && position.isCollection() && position.isEmptyCollection()) {
>-                	if(!charactersAllowed){
>-                		 throw JAXBException.jsonValuePropertyRequired("[");   
>-                	}
>+                if(position != null && position.isCollection() && position.isEmptyCollection()) {                	
>                     writer.write('[');                    
>                     position.setEmptyCollection(false);
>                     position.setNeedToOpenComplex(false);
>@@ -367,6 +363,8 @@ public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> {
>         } else {
>             levels.peek().setCollection(true);
>             levels.peek().setEmptyCollection(true);
>+            charactersAllowed = false;
>+            isStartElementOpen = false;
>         }
>     }
>     
>@@ -410,14 +408,19 @@ public class JSONWriterRecord extends MarshalRecord<XMLMarshaller> {
>      */
>      public void characters(String value, boolean isString, boolean isAttribute) {
>     	  boolean textWrapperOpened = false;
>+    	  Level position = levels.peek();
>           if(!charactersAllowed){    
>         	   if(textWrapperFragment != null){
>+        	       if(!isStartElementOpen && position.isFirst()){
>+        	           position.needToOpenComplex = true;
>+        	           position.needToOpenComplex = true;
>+        	       }
>         		   openStartElement(textWrapperFragment, namespaceResolver);
>         		   textWrapperOpened = true;
>         	   }
>     	   }
>     	 
>-           Level position = levels.peek();
>+           position = levels.peek();
>            position.setNeedToOpenComplex(false);
>            try {
>         	   if(isString){
>diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonObjectBuilderWriterRecord.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonObjectBuilderWriterRecord.java
>new file mode 100644
>index 0000000..a80815c
>--- /dev/null
>+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/JsonObjectBuilderWriterRecord.java
>@@ -0,0 +1,814 @@
>+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.Json;
>+import javax.json.JsonArrayBuilder;
>+import javax.json.JsonObjectBuilder;
>+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;
>+
>+
>+//TODO replace NULL string with addNUll
>+//TODO element method
>+public class JsonObjectBuilderWriterRecord extends MarshalRecord <XMLMarshaller> {
>+
>+    private Level position;
>+    private JsonObjectBuilder rootJsonObjectBuilder;
>+    private JsonArrayBuilder rootJsonArrayBuilder;
>+    private CharacterEscapeHandler characterEscapeHandler;
>+
>+    private String attributePrefix;
>+    private boolean isRootArray;
>+    private static final String NULL="null";
>+    private boolean isLastEventStart;
>+        
>+    public JsonObjectBuilderWriterRecord(){
>+        super();
>+        isLastEventStart = false;
>+    }
>+    
>+    public JsonObjectBuilderWriterRecord(JsonObjectBuilder jsonObjectBuilder){
>+        this();
>+        rootJsonObjectBuilder = jsonObjectBuilder;
>+    }
>+    
>+    public JsonObjectBuilderWriterRecord(JsonArrayBuilder jsonArrayBuilder){
>+        this();
>+        rootJsonArrayBuilder = jsonArrayBuilder;
>+    }
>+    
>+    /**
>+     * 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){
>+            position.setEmptyCollection(false);
>+            
>+            Level newLevel = new Level(false, position);
>+            newLevel.setItemInCollection(true);
>+            position = newLevel;
>+            
>+            isLastEventStart = true;
>+        }else{
>+            Level rootLevel = new Level(false, null);
>+            position = rootLevel;
>+            if(rootJsonObjectBuilder == null){
>+                rootJsonObjectBuilder = Json.createObjectBuilder();
>+            }  
>+            
>+            rootLevel.setJsonObjectBuilder(rootJsonObjectBuilder);
>+        }
>+    }
>+
>+    @Override
>+    public void endDocument() {
>+        if(position != null){
>+            if(position.isItemInCollection() && position.parentLevel != null){
>+                popAndSetInParentBuilder();
>+            }else{
>+                //this is the root level list case
>+                position = position.parentLevel;
>+            }            
>+        }
>+    }
>+    
>+    private void popAndSetInParentBuilder(){
>+        Level removedLevel = position;
>+        Level parentLevel = position.parentLevel;
>+        position = position.parentLevel;
>+        if(removedLevel.isCollection && removedLevel.isEmptyCollection() && removedLevel.keyName == null){
>+            return;
>+        }
>+      
>+        if(parentLevel != null){                  
>+            if(parentLevel.isCollection){
>+                if(removedLevel.isCollection){
>+                    parentLevel.getJsonArrayBuilder().add(removedLevel.getJsonArrayBuilder());
>+                }else{                   
>+                    parentLevel.getJsonArrayBuilder().add(removedLevel.getJsonObjectBuilder());
>+                }
>+            }else{
>+                if(removedLevel.isCollection){                    
>+                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonArrayBuilder());
>+                }else{
>+                    parentLevel.getJsonObjectBuilder().add(removedLevel.getKeyName(), removedLevel.getJsonObjectBuilder());
>+                }
>+            }
>+        }
>+        
>+    }    
>+    
>+    public void startCollection() {
>+        if(position == null){
>+             isRootArray = true;              
>+             Level rootLevel = new Level(true, null);
>+             if(rootJsonArrayBuilder == null){
>+                  rootJsonArrayBuilder = Json.createArrayBuilder();
>+             }
>+             rootLevel.setJsonArrayBuilder(rootJsonArrayBuilder);
>+             position = rootLevel;
>+        } else {            
>+            if(isLastEventStart){
>+                position.setComplex(true);           
>+            }            
>+            Level level = new Level(true, position);            
>+            position = level;
>+        }      
>+        isLastEventStart = false;
>+    }
>+    
>+    @Override
>+    public void endCollection() {
>+         popAndSetInParentBuilder();    
>+    }
>+    
>+    @Override    
>+    public void openStartElement(XPathFragment xPathFragment, NamespaceResolver namespaceResolver) {
>+        super.openStartElement(xPathFragment, namespaceResolver);
>+        if(position != null){
>+            Level newLevel = new Level(false, position);
>+            
>+            if(position.isCollection){
>+                newLevel.itemInCollection = true;            
>+            }            
>+          
>+            if(isLastEventStart){ 
>+                //this means 2 startevents in a row so the last this is a complex object
>+                position.setComplex(true);                                
>+            }
>+                      
>+            String keyName = getKeyName(xPathFragment);
>+           
>+            if(position.isCollection && position.isEmptyCollection() ){
>+                position.setKeyName(keyName);
>+            }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();
>+                     position.setComplex(false);
>+                     position.parentLevel.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());                     
>+                 }else{ 
>+                     if(isLastEventStart){
>+                         position.setComplex(true);                  
>+                     }                 
>+                     String keyName =  getKeyName(xPathFragment);
>+                     if(keyName != null){
>+                        position.getJsonObjectBuilder().add(keyName, Json.createArrayBuilder());
>+                     }
>+                 }
>+                 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){
>+                position.setComplex(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;
>+            currentLevel.setComplex(true);          
>+        }
>+        if(currentLevel.isCollection()){
>+            currentLevel.setEmptyCollection(false);
>+            addValueToArrayBuilder(currentLevel.getJsonArrayBuilder(), value, schemaType);            
>+        } else {
>+            JsonObjectBuilder builder = currentLevel.getJsonObjectBuilder();                   
>+            addValueToObjectBuilder(builder, keyName, value, schemaType);          
>+        }
>+        isLastEventStart = false;
>+        if(textWrapperOpened){    
>+             endElement(textWrapperFragment, namespaceResolver);
>+        }    
>+    }
>+    
>+    private void addValueToObjectBuilder(JsonObjectBuilder jsonObjectBuilder, String keyName, Object value, QName schemaType){
>+        if(value == NULL){
>+            jsonObjectBuilder.addNull(keyName);
>+        }else if(value instanceof Integer){
>+            jsonObjectBuilder.add(keyName, (Integer)value);  
>+        }else if(value instanceof BigDecimal){
>+            jsonObjectBuilder.add(keyName, (BigDecimal)value);   
>+        }else if(value instanceof BigInteger){
>+            jsonObjectBuilder.add(keyName, (BigInteger)value);               
>+        }else if(value instanceof Boolean){
>+            jsonObjectBuilder.add(keyName, (Boolean)value);
>+        }else if(value instanceof Character){
>+            jsonObjectBuilder.add(keyName, (Character)value);  
>+        }else if(value instanceof Double){
>+            jsonObjectBuilder.add(keyName, (Double)value);
>+        }else if(value instanceof Float){
>+            jsonObjectBuilder.add(keyName, (Float)value);
>+        }else if(value instanceof Long){
>+            jsonObjectBuilder.add(keyName, (Long)value);
>+        }else if(value instanceof String){
>+            jsonObjectBuilder.add(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));
>+                    jsonObjectBuilder.add(keyName, (BigDecimal)convertedNumberValue);
>+            }else{
>+                jsonObjectBuilder.add(keyName, convertedValue);
>+            }
>+                
>+        }
>+    }
>+    
>+    private void addValueToArrayBuilder(JsonArrayBuilder jsonArrayBuilder, Object value, QName schemaType){
>+        if(value == NULL){
>+            jsonArrayBuilder.addNull();
>+        }else if(value instanceof Integer){
>+            jsonArrayBuilder.add((Integer)value);  
>+        }else if(value instanceof BigDecimal){
>+            jsonArrayBuilder.add((BigDecimal)value);   
>+        }else if(value instanceof BigInteger){
>+            jsonArrayBuilder.add((BigInteger)value);               
>+        }else if(value instanceof Boolean){                
>+            jsonArrayBuilder.add((Boolean)value);
>+        }else if(value instanceof Character){
>+            jsonArrayBuilder.add((Character)value);  
>+        }else if(value instanceof Double){
>+            jsonArrayBuilder.add((Double)value);
>+        }else if(value instanceof Float){
>+            jsonArrayBuilder.add((Float)value);
>+        }else if(value instanceof Long){
>+            jsonArrayBuilder.add((Long)value);
>+        }else if(value instanceof String){
>+            jsonArrayBuilder.add((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));
>+                    jsonArrayBuilder.add((BigDecimal)convertedNumberValue);
>+            }else{
>+                jsonArrayBuilder.add(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);
>+             
>+             JsonObjectBuilderWriterRecord.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 {           
>+             JsonObjectBuilderWriterRecord.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 JsonObjectBuilder jsonObjectBuilder;
>+        private JsonArrayBuilder jsonArrayBuilder;
>+        private boolean isComplex;
>+        private boolean itemInCollection;
>+        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;
>+            if(isCollection && jsonArrayBuilder == null){
>+                jsonArrayBuilder = Json.createArrayBuilder();
>+            }
>+        }
>+
>+        public String getKeyName() {
>+            return keyName;
>+        }
>+
>+        public void setKeyName(String keyName) {
>+            this.keyName = keyName;
>+        }
>+
>+        public JsonObjectBuilder getJsonObjectBuilder() {
>+            return jsonObjectBuilder;
>+        }
>+
>+        public void setJsonObjectBuilder(JsonObjectBuilder jsonObjectBuilder) {
>+            this.jsonObjectBuilder = jsonObjectBuilder;
>+        }
>+
>+        public JsonArrayBuilder getJsonArrayBuilder() {
>+            return jsonArrayBuilder;
>+        }
>+
>+        public void setJsonArrayBuilder(JsonArrayBuilder jsonArrayBuilder) {
>+            this.jsonArrayBuilder = jsonArrayBuilder;
>+        }
>+
>+        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;
>+            if(isComplex && jsonObjectBuilder == null){
>+                jsonObjectBuilder = Json.createObjectBuilder();
>+            }
>+        }
>+
>+        public boolean isItemInCollection() {
>+            return itemInCollection;
>+        }
>+
>+        public void setItemInCollection(boolean itemInCollection) {
>+            this.itemInCollection = itemInCollection;
>+        }
>+    }
>+
>+
>+}
>diff --git a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/employee.json b/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/employee.json
>index 00a122d..c7c9654 100644
>--- a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/employee.json
>+++ b/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/employee.json
>@@ -1,7 +1,9 @@
> {"employee":{
>   "things":{
>      "junk":{
>-       "stuff":"Some Stuff"
>+       "stuff":{
>+          "value":["Some Stuff"]
>+	}
>     }
>   }
>-}}
>+}}
>\ No newline at end of file
>diff --git a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/write-only-employee.json b/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/write-only-employee.json
>index 4fe0135..d191cf2 100644
>--- a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/write-only-employee.json
>+++ b/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/externalizedmetadata/mappings/anycollection/write-only-employee.json
>@@ -1,7 +1,9 @@
> {"employee":{
>   "things":{
>     "write-only":{
>-      "stuff":"Some Stuff"
>+      "stuff":{
>+         "value":["Some Stuff"]
>+	 }
>     }
>   }
> }}
>\ No newline at end of file
>diff --git a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/xmlidrefcontainment.json b/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/xmlidrefcontainment.json
>index 460e770..86d2029 100644
>--- a/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/xmlidrefcontainment.json
>+++ b/moxy/eclipselink.moxy.test/resource/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/xmlidrefcontainment.json
>@@ -1,6 +1,6 @@
> {"customer-data":{
> 	"customer":{
>-	        "customerID":"Alice",
>+	        "@customerID":"Alice",
> 		"name":"Alice Jane",
> 		"customerID":"Alice"
> 		},
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java
>index 9735084..f6153eb 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/JAXBWithJSONTestCases.java
>@@ -23,8 +23,12 @@ import java.util.ArrayList;
> import java.util.List;
> 
> import javax.json.Json;
>+import javax.json.JsonObject;
>+import javax.json.JsonObjectBuilder;
> import javax.json.JsonReader;
> import javax.json.JsonStructure;
>+import javax.json.JsonWriter;
>+import javax.json.stream.JsonParser;
> import javax.xml.bind.JAXBElement;
> import javax.xml.bind.Marshaller;
> import javax.xml.bind.Unmarshaller;
>@@ -37,6 +41,7 @@ import org.eclipse.persistence.jaxb.JAXBContext;
> import org.eclipse.persistence.jaxb.MarshallerProperties;
> import org.eclipse.persistence.jaxb.UnmarshallerProperties;
> import org.eclipse.persistence.oxm.MediaType;
>+import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
> import org.eclipse.persistence.oxm.json.JsonStructureSource;
> import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;
> import org.xml.sax.InputSource;
>@@ -235,7 +240,7 @@ public abstract class JAXBWithJSONTestCases extends JAXBTestCases {
>             jsonToObjectTest(testObject);
>         }
>     }
>-       
>+    
>     public void testJSONUnmarshalFromURL() throws Exception {
>     	if(isUnmarshalTest()){
>     		getJSONUnmarshaller().setProperty(UnmarshallerProperties.MEDIA_TYPE, getJSONUnmarshalMediaType());
>@@ -309,6 +314,22 @@ public abstract class JAXBWithJSONTestCases extends JAXBTestCases {
>         log(sw.toString());
>         compareStringToControlFile("testJSONMarshalToStringWriter_FORMATTED", sw.toString(), getWriteControlJSONFormatted(),shouldRemoveWhitespaceFromControlDocJSON());
>     }
>+    public void testJSONMarshalToBuilderResult() throws Exception{
>+        getJSONMarshaller().setProperty(MarshallerProperties.MEDIA_TYPE, "application/json");
>+
>+        JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
>+        JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
>+        getJSONMarshaller().marshal(getWriteControlObject(), result);
>+        JsonObject jsonObject = jsonObjectBuilder.build();
>+        
>+        StringWriter sw = new StringWriter();
>+        JsonWriter writer= Json.createWriter(sw);
>+        writer.writeObject(jsonObject);
>+        writer.close();
>+        
>+        log(sw.toString());
>+        compareStringToControlFile("**testJSONMarshalToStringWriter**", sw.toString());
>+    }
> 
>     protected void compareStringToControlFile(String test, String testString) {
>     	compareStringToControlFile(test, testString, getWriteControlJSON());
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/XmlIdRefContainmentTest.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/XmlIdRefContainmentTest.java
>index 7bec5ec..dd46a10 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/XmlIdRefContainmentTest.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/javadoc/xmlidref/XmlIdRefContainmentTest.java
>@@ -14,6 +14,7 @@ package org.eclipse.persistence.testing.jaxb.javadoc.xmlidref;
> 
> //Example 2
> 
>+import org.eclipse.persistence.jaxb.MarshallerProperties;
> import org.eclipse.persistence.testing.jaxb.JAXBWithJSONTestCases;
> 
> public class XmlIdRefContainmentTest extends JAXBWithJSONTestCases{
>@@ -31,6 +32,8 @@ public class XmlIdRefContainmentTest extends JAXBWithJSONTestCases{
> 		classes[2] = Shipping.class;
> 		classes[3] = CustomerData.class;
> 		setClasses(classes);
>+		jaxbMarshaller.setProperty(MarshallerProperties.JSON_ATTRIBUTE_PREFIX, "@");
>+		jaxbUnmarshaller.setProperty(MarshallerProperties.JSON_ATTRIBUTE_PREFIX, "@");
> 	}
> 
> 	protected Object getControlObject() {
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONMarshalUnmarshalTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONMarshalUnmarshalTestCases.java
>index aa905bc..1fb0190 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONMarshalUnmarshalTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONMarshalUnmarshalTestCases.java
>@@ -20,10 +20,15 @@ import java.net.URL;
> import java.util.ArrayList;
> import java.util.List;
> 
>+import javax.json.Json;
>+import javax.json.JsonReader;
>+import javax.json.JsonStructure;
> import javax.xml.bind.JAXBElement;
> import javax.xml.transform.stream.StreamSource;
> 
> import org.eclipse.persistence.jaxb.JAXBContext;
>+import org.eclipse.persistence.jaxb.UnmarshallerProperties;
>+import org.eclipse.persistence.oxm.json.JsonStructureSource;
> import org.eclipse.persistence.testing.jaxb.JAXBTestCases.MyStreamSchemaOutputResolver;
> import org.xml.sax.InputSource;
> 
>@@ -53,6 +58,22 @@ public abstract class JSONMarshalUnmarshalTestCases extends JSONTestCases{
> 		inputStream.close();
> 		jsonToObjectTest(testObject);
> 	}
>+	
>+	public void testJSONUnmarshalFromJsonStructureSource() throws Exception {
>+       
>+        InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(controlJSONLocation);    
>+        JsonReader reader = Json.createReader(inputStream);
>+        JsonStructure jsonStructure = reader.read();     
>+        JsonStructureSource source = new JsonStructureSource(jsonStructure);
>+            
>+        Object testObject = null;
>+        if(getUnmarshalClass() != null){               
>+            testObject = jsonUnmarshaller.unmarshal(source, getUnmarshalClass());
>+        }else{
>+            testObject = jsonUnmarshaller.unmarshal(source);
>+        }
>+        jsonToObjectTest(testObject);        
>+    }
> 
> 	public void testJSONUnmarshalFromInputSource() throws Exception {	
>          InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(controlJSONLocation);
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONTestCases.java
>index d9685b6..c4bc79e 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/JSONTestCases.java
>@@ -13,11 +13,21 @@
> package org.eclipse.persistence.testing.jaxb.json;
> 
> import java.io.ByteArrayOutputStream;
>+import java.io.OutputStream;
>+import java.io.OutputStreamWriter;
> import java.io.StringWriter;
>+import java.nio.charset.Charset;
> import java.util.Collection;
> import java.util.Iterator;
> import java.util.Map;
> 
>+import javax.json.Json;
>+import javax.json.JsonArray;
>+import javax.json.JsonArrayBuilder;
>+import javax.json.JsonObject;
>+import javax.json.JsonObjectBuilder;
>+import javax.json.JsonWriter;
>+import javax.json.JsonWriterFactory;
> import javax.xml.bind.JAXBContext;
> import javax.xml.bind.JAXBElement;
> import javax.xml.bind.Marshaller;
>@@ -27,6 +37,8 @@ import org.eclipse.persistence.jaxb.JAXBContextFactory;
> import org.eclipse.persistence.jaxb.MarshallerProperties;
> 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.JsonObjectBuilderResult;
> import org.eclipse.persistence.testing.oxm.OXTestCase;
> 
> public abstract class JSONTestCases extends OXTestCase{
>@@ -172,7 +184,48 @@ public abstract class JSONTestCases extends OXTestCase{
> 	        compareStringToControlFile("testJSONMarshalToOutputStream", new String(os.toByteArray()));
> 	        os.close();
> 	    }
>+	 
>+     public void testJSONMarshalToBuilderResult() throws Exception{
>+           Object writeControlObject = getWriteControlObject();
>+           if(writeControlObject instanceof Collection || writeControlObject.getClass().isArray()){
>+               marshalToArrayBuilderResult();
>+           }else{
>+               marshalToObjectBuilderResult();
>+           }
>+     }  
>+	 
>+	   public void marshalToObjectBuilderResult() throws Exception{
>+	       
>+	        JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
>+	        JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
>+	        jsonMarshaller.marshal(getWriteControlObject(), result);
> 
>+	        JsonObject jsonObject = jsonObjectBuilder.build();	        
>+	        StringWriter sw = new StringWriter();
>+	        
>+	        JsonWriter writer= Json.createWriter(sw);
>+	        writer.writeObject(jsonObject);
>+	        writer.close();
>+	        log(sw.toString());
>+	        compareStringToControlFile("**testJSONMarshalToBuilderResult**", sw.toString());
>+	    }
>+
>+    public void marshalToArrayBuilderResult() throws Exception{
>+           
>+           JsonArrayBuilder jsonArrayBuilder = Json.createArrayBuilder();
>+           JsonArrayBuilderResult result = new JsonArrayBuilderResult(jsonArrayBuilder);
>+           jsonMarshaller.marshal(getWriteControlObject(), result);
>+
>+           JsonArray jsonArray = jsonArrayBuilder.build();          
>+           StringWriter sw = new StringWriter();
>+           JsonWriter writer= Json.createWriter(sw);
>+           writer.writeArray(jsonArray);
>+           writer.close();
>+           
>+           log(sw.toString());
>+           compareStringToControlFile("**testJSONMarshalToBuilderResult**", sw.toString());
>+       }
>+	   
> 	 public void testJSONMarshalToOutputStream_FORMATTED() throws Exception{
> 	    jsonMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
> 	    ByteArrayOutputStream os = new ByteArrayOutputStream();
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/characters/UsAsciiTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/characters/UsAsciiTestCases.java
>index f26970c..3768e4f 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/characters/UsAsciiTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/characters/UsAsciiTestCases.java
>@@ -12,10 +12,18 @@
>  ******************************************************************************/
> package org.eclipse.persistence.testing.jaxb.json.characters;
> 
>+import java.io.ByteArrayOutputStream;
>+import java.io.OutputStreamWriter;
>+import java.nio.charset.Charset;
> import java.util.Map;
> 
>+import javax.json.Json;
>+import javax.json.JsonObject;
>+import javax.json.JsonObjectBuilder;
>+import javax.json.JsonWriter;
> import javax.xml.bind.Marshaller;
> 
>+import org.eclipse.persistence.oxm.json.JsonObjectBuilderResult;
> import org.eclipse.persistence.testing.jaxb.json.JSONMarshalUnmarshalTestCases;
> 
> public class UsAsciiTestCases  extends JSONMarshalUnmarshalTestCases {
>@@ -43,5 +51,26 @@ public class UsAsciiTestCases  extends JSONMarshalUnmarshalTestCases {
>         control.characters.add('b');
>         return control;
>     }
>+    
>+    public void marshalToObjectBuilderResult() throws Exception{
>+        
>+        JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
>+        JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
>+        jsonMarshaller.marshal(getWriteControlObject(), result);
>+
>+        JsonObject jsonObject = jsonObjectBuilder.build();                
>+        ByteArrayOutputStream out = new ByteArrayOutputStream();
>+        Charset charset = Charset.forName("US-ASCII");
>+
>+        JsonWriter writer = Json.createWriterFactory(null).createWriter(out, charset);
>+        
>+        writer.writeObject(jsonObject);
>+        writer.close();
>+       
>+        String s = out.toString();
>+       
>+        log(s);
>+        compareStringToControlFile("**testJSONMarshalToBuilderResult**", s);
>+    }
> 
> }
>\ No newline at end of file
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementJSONPaddingTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementJSONPaddingTestCases.java
>index 516cf1d..aa1c544 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementJSONPaddingTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementJSONPaddingTestCases.java
>@@ -45,4 +45,8 @@ public class JAXBElementJSONPaddingTestCases extends JAXBWithJSONTestCases{
> 	public boolean isUnmarshalTest (){
> 		return false;
> 	}
>+	
>+	public void testJSONMarshalToBuilderResult() throws Exception{     
>+    }
>+    
> }
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementListJSONPaddingTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementListJSONPaddingTestCases.java
>index dfaa15e..2ce04f6 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementListJSONPaddingTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JAXBElementListJSONPaddingTestCases.java
>@@ -57,4 +57,7 @@ public class JAXBElementListJSONPaddingTestCases extends JSONTestCases{
> 	public boolean isUnmarshalTest (){
> 		return false;
> 	}
>+	
>+	public void testJSONMarshalToBuilderResult() throws Exception{     
>+    }
> }
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithNullNameTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithNullNameTestCases.java
>index 9a47089..2ab553b 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithNullNameTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithNullNameTestCases.java
>@@ -42,4 +42,8 @@ public class JSONWithNullNameTestCases extends JAXBWithJSONTestCases{
> 	public boolean isUnmarshalTest (){
> 		return false;
> 	}
>+	
>+	public void testJSONMarshalToBuilderResult() throws Exception{     
>+    }
>+    
> }
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleListTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleListTestCases.java
>index 6a37451..6a485ec 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleListTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleListTestCases.java
>@@ -55,6 +55,9 @@ public class JSONWithPaddingSimpleListTestCases extends JSONTestCases{
> 		return false;
> 	}
> 	
>+	public void testJSONMarshalToBuilderResult() throws Exception{     
>+    }
>+	
> //	public boolean shouldRemoveWhitespaceFromControlDocJSON(){
> 	//	return false;
> 	//}
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleTestCases.java
>index b9613dd..3f9ae6a 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithPaddingSimpleTestCases.java
>@@ -48,4 +48,8 @@ public class JSONWithPaddingSimpleTestCases extends JAXBWithJSONTestCases{
> 	public boolean isUnmarshalTest (){		
> 		return false;
> 	}
>+	
>+	public void testJSONMarshalToBuilderResult() throws Exception{     
>+    }
>+    
> }
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithUnsetNameTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithUnsetNameTestCases.java
>index 420576f..26c0e38 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithUnsetNameTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/json/padding/JSONWithUnsetNameTestCases.java
>@@ -42,4 +42,8 @@ public class JSONWithUnsetNameTestCases extends JAXBWithJSONTestCases{
> 	public boolean isUnmarshalTest (){
> 		return false;
> 	}
>+	
>+	public void testJSONMarshalToBuilderResult() throws Exception{     
>+    }
>+    
> }
>diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/xmlvariablenode/XmlVariableNodeNullValueTestCases.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/xmlvariablenode/XmlVariableNodeNullValueTestCases.java
>index 0af0edd..4301659 100644
>--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/xmlvariablenode/XmlVariableNodeNullValueTestCases.java
>+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/xmlvariablenode/XmlVariableNodeNullValueTestCases.java
>@@ -86,6 +86,17 @@ public class XmlVariableNodeNullValueTestCases extends JAXBWithJSONTestCases{
> 		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();

Actions: View | Diff

Attachments on bug 411377: 232906 | 233631 | 233635 | 233675 | 233682 | 233709 | 233732 | 233733