JSLib/tests/odata-atom-tests.js - olingo-odata3-js - Git at Google

 /// <reference path="../src/odata-utils.js" />
 /// <reference path="../src/odata-handler.js" />
 /// <reference path="../src/odata-atom.js" />
 /// <reference path="../src/odata-xml.js" />
 /// <reference path="common/djstest.js" />

 // Copyright (c) Microsoft Open Technologies, Inc.  All rights reserved.
 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal  in the Software without restriction, including without limitation the rights  to use, copy,
 // modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 // WARRANTIES OF MERCHANTABILITY,  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 // odata-atom-tests.js

 (function (window, undefined) {

     module("Unit");

     var parseMetadataHelper = function (text) {
         var response = { statusCode: 200, body: text, headers: { "Content-Type": "application/xml"} };
         OData.metadataHandler.read(response, {});
         return response.data;
     };

     var resetFoodData = function () {
         $.ajax({ url: "./endpoints/FoodStoreDataServiceV2.svc/ResetData", async: false, type: "POST" });
     };

     var customerSampleMetadataText = '' +
     '<edmx:Edmx Version="1.0" xmlns:edmx="http://schemas.microsoft.com/ado/2007/06/edmx">\r\n' +
     '<edmx:DataServices xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" m:DataServiceVersion="2.0">\r\n' +
     '<Schema Namespace="Ns" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns="http://schemas.microsoft.com/ado/2006/04/edm">\r\n' +
     '    <EntityType Name="Customer">\r\n' +
     '    <Key><PropertyRef Name="ID" /></Key>\r\n' +
     '     <Property Name="ID" Type="Edm.Int32" Nullable="false" />\r\n' +
     '     <Property Name="Name" Type="Edm.String" Nullable="true" m:FC_TargetPath="SyndicationSummary" m:FC_ContentKind="xhtml" m:FC_KeepInContent="false" />\r\n' +
     '     <Property Name="LastName" Type="Edm.String" Nullable="true" m:FC_TargetPath="foo/bar/@baz" m:FC_NsUri="htp://prefix" m:FC_NsPrefix="prefix" m:FC_KeepInContent="false" />\r\n' +
     '     <Property Name="FavoriteNumber" Type="Edm.Int32" Nullable="true" m:FC_TargetPath="favorite/number" m:FC_NsUri="htp://prefix" m:FC_NsPrefix="prefix" m:FC_KeepInContent="false" />\r\n' +
     '     <Property Name="Address" Type="Ns.Address" Nullable="false" \r\n' +
     '       m:FC_TargetPath="foo/bar/@city" m:FC_NsUri="htp://prefix" m:FC_NsPrefix="prefix" m:FC_SourcePath="City" m:FC_KeepInContent="false" \r\n' +
     '       m:FC_TargetPath_1="foo/bar" m:FC_NsUri_1="htp://prefix" m:FC_NsPrefix_1="prefix" m:FC_SourcePath_1="Street" m:FC_KeepInContent_1="false" />\r\n' +
     '    </EntityType>\r\n' +
     '    <ComplexType Name="Address">\r\n' +
     '     <Property Name="Street" Type="Edm.String" Nullable="true" />\r\n' +
     '     <Property Name="City" Type="Edm.String" Nullable="true" />\r\n' +
     '    </ComplexType>\r\n' +
     '    <EntityContainer Name="SampleContext" m:IsDefaultEntityContainer="true">\r\n' +
     '     <EntitySet Name="Customers" EntityType="Ns.Customer" />\r\n' +
     '    </EntityContainer>\r\n' +
     '</Schema>\r\n' +
     '</edmx:DataServices></edmx:Edmx>';

     var foodServiceV2FoodsSampleText = '' +
     '<feed xml:base="http://localhost/tests/endpoints/FoodStoreDataServiceV2.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom">' +
     '  <title type="text">Foods</title>' +
     '  <id>http://localhost/tests/endpoints/FoodStoreDataServiceV2.svc/Foods</id>' +
     '  <updated>2010-12-28T23:09:54Z</updated>' +
     '  <link rel="self" title="Foods" href="Foods" />' +
     '  <entry>' +
     '    <id>http://localhost/tests/endpoints/FoodStoreDataServiceV2.svc/Foods(0)</id>' +
     '    <title type="text">flour</title>' +
     '    <updated>2010-12-28T23:09:54Z</updated>' +
     '    <author><name /></author>' +
     '    <link rel="edit" title="Food" href="Foods(0)" />' +
     '    <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Category" type="application/atom+xml;type=entry" title="Category" href="Foods(0)/Category" />' +
     '    <category term="DataJS.Tests.V2.Food" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />' +
     '    <content type="application/xml">' +
     '      <m:properties>' +
     '        <d:FoodID m:type="Edm.Int32">0</d:FoodID>' +
     '        <d:Name>flour</d:Name>' +
     '        <d:ServingSize m:type="Edm.Decimal">1</d:ServingSize>' +
     '        <d:MeasurementUnit>Cup</d:MeasurementUnit>' +
     '        <d:ProteinGrams m:type="Edm.Byte">3</d:ProteinGrams>' +
     '        <d:FatGrams m:type="Edm.Int16">1</d:FatGrams>' +
     '        <d:CarbohydrateGrams m:type="Edm.Int32">20</d:CarbohydrateGrams>' +
     '        <d:CaloriesPerServing m:type="Edm.Int64">140</d:CaloriesPerServing>' +
     '        <d:IsAvailable m:type="Edm.Boolean">true</d:IsAvailable>' +
     '        <d:ExpirationDate m:type="Edm.DateTime">2010-12-25T12:00:00</d:ExpirationDate>' +
     '        <d:ItemGUID m:type="Edm.Guid">27272727-2727-2727-2727-272727272727</d:ItemGUID>' +
     '        <d:Weight m:type="Edm.Single">10</d:Weight>' +
     '        <d:AvailableUnits m:type="Edm.SByte">1</d:AvailableUnits>' +
     '        <d:Packaging m:type="DataJS.Tests.V2.Package">' +
     '          <d:Type m:null="true" />' +
     '          <d:Color></d:Color>' +
     '          <d:NumberPerPackage m:type="Edm.Int32">2147483647</d:NumberPerPackage>' +
     '          <d:RequiresRefridgeration m:type="Edm.Boolean">false</d:RequiresRefridgeration>' +
     '          <d:ShipDate m:type="Edm.DateTime">0001-01-01T00:00:00</d:ShipDate>' +
     '          <d:PackageDimensions m:type="DataJS.Tests.V2.Dimensions">' +
     '            <d:Length m:type="Edm.Decimal">79228162514264337593543950335</d:Length>' +
     '            <d:Height m:type="Edm.Int16">32767</d:Height>' +
     '            <d:Width m:type="Edm.Int64">9223372036854775807</d:Width>' +
     '            <d:Volume m:type="Edm.Double">1.7976931348623157E+308</d:Volume>' +
     '          </d:PackageDimensions>' +
     '        </d:Packaging>' +
     '      </m:properties>' +
     '    </content>' +
     '    <cooked:cooked cooked:length="2" cooked:height="1" cooked:width="3" xmlns:cooked="http://www.example.org/cooked/">' +
     '      <cooked:volume>6</cooked:volume>' +
     '    </cooked:cooked>' +
     '    <pr:price pr:value="0.19999" xmlns:pr="http://www.example.org/price/"></pr:price>' +
     '  </entry>' +
     '  <entry>' +
     '    <id>http://localhost/tests/endpoints/FoodStoreDataServiceV2.svc/Foods(1)</id>' +
     '    <title type="text">sugar</title>' +
     '    <updated>2010-12-28T23:09:54Z</updated>' +
     '    <author>' +
     '      <name />' +
     '    </author>' +
     '    <link rel="edit" title="Food" href="Foods(1)" />' +
     '    <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Category" type="application/atom+xml;type=entry" title="Category" href="Foods(1)/Category" />' +
     '    <category term="DataJS.Tests.V2.Food" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />' +
     '    <content type="application/xml">' +
     '      <m:properties>' +
     '        <d:FoodID m:type="Edm.Int32">1</d:FoodID>' +
     '        <d:Name>sugar</d:Name>' +
     '        <d:ServingSize m:type="Edm.Decimal">1</d:ServingSize>' +
     '        <d:MeasurementUnit>tsp</d:MeasurementUnit>' +
     '        <d:ProteinGrams m:type="Edm.Byte">0</d:ProteinGrams>' +
     '        <d:FatGrams m:type="Edm.Int16">0</d:FatGrams>' +
     '        <d:CarbohydrateGrams m:type="Edm.Int32">4</d:CarbohydrateGrams>' +
     '        <d:CaloriesPerServing m:type="Edm.Int64">16</d:CaloriesPerServing>' +
     '        <d:IsAvailable m:type="Edm.Boolean">false</d:IsAvailable>' +
     '        <d:ExpirationDate m:type="Edm.DateTime">2011-12-28T00:00:00</d:ExpirationDate>' +
     '        <d:ItemGUID m:type="Edm.Guid">ffffffff-ffff-ffff-ffff-ffffffffffff</d:ItemGUID>' +
     '        <d:Weight m:type="Edm.Single">0.1</d:Weight>' +
     '        <d:AvailableUnits m:type="Edm.SByte">0</d:AvailableUnits>' +
     '        <d:Packaging m:type="DataJS.Tests.V2.Package">' +
     '          <d:Type xml:space="preserve"> </d:Type>' +
     '          <d:Color>BLUE</d:Color>' +
     '          <d:NumberPerPackage m:type="Edm.Int32">-2147483648</d:NumberPerPackage>' +
     '          <d:RequiresRefridgeration m:type="Edm.Boolean">true</d:RequiresRefridgeration>' +
     '          <d:ShipDate m:type="Edm.DateTime">0001-01-01T00:00:00</d:ShipDate>' +
     '          <d:PackageDimensions m:type="DataJS.Tests.V2.Dimensions">' +
     '            <d:Length m:type="Edm.Decimal">-79228162514264337593543950335</d:Length>' +
     '            <d:Height m:type="Edm.Int16">-32768</d:Height>' +
     '            <d:Width m:type="Edm.Int64">-9223372036854775808</d:Width>' +
     '            <d:Volume m:type="Edm.Double">-1.7976931348623157E+308</d:Volume>' +
     '          </d:PackageDimensions>' +
     '        </d:Packaging>' +
     '        <d:CookedSize m:type="DataJS.Tests.V2.CookedDimensions" m:null="true" />' +
     '      </m:properties>' +
     '    </content>' +
     '    <cooked:cooked cooked:length="" cooked:height="" cooked:width="" xmlns:cooked="http://www.example.org/cooked/">' +
     '      <cooked:volume></cooked:volume>' +
     '    </cooked:cooked>' +
     '    <pr:price pr:value="0.2" xmlns:pr="http://www.example.org/price/"></pr:price>' +
     '  </entry>' +
     '</feed>';

     var foodServiceV2MetadataText = '' +
     '<edmx:Edmx Version="1.0" xmlns:edmx="http://schemas.microsoft.com/ado/2007/06/edmx">' +
     '  <edmx:DataServices xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" m:DataServiceVersion="2.0">' +
     '    <Schema Namespace="DataJS.Tests.V2" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns="http://schemas.microsoft.com/ado/2007/05/edm">' +
     '      <EntityType Name="Category">' +
     '        <Key>' +
     '          <PropertyRef Name="CategoryID" />' +
     '        </Key>' +
     '        <Property Name="CategoryID" Type="Edm.Int32" Nullable="false" />' +
     '        <Property Name="Name" Type="Edm.String" Nullable="true" m:FC_TargetPath="SyndicationTitle" m:FC_ContentKind="text" m:FC_KeepInContent="true" />' +
     '        <NavigationProperty Name="Foods" Relationship="DataJS.Tests.V2.Category_Foods" FromRole="Category" ToRole="Foods" />' +
     '      </EntityType>' +
     '      <EntityType Name="PreparedFood" BaseType="DataJS.Tests.V2.Food">' +
     '        <Property Name="Instructions" Type="Edm.String" Nullable="true" />' +
     '        <Property Name="NumberOfIngredients" Type="Edm.Single" Nullable="false" />' +
     '      </EntityType>' +
     '      <EntityType Name="Food">' +
     '        <Key>' +
     '          <PropertyRef Name="FoodID" />' +
     '        </Key>' +
     '        <Property Name="FoodID" Type="Edm.Int32" Nullable="false" />' +
     '        <Property Name="Name" Type="Edm.String" Nullable="true" m:FC_TargetPath="SyndicationTitle" m:FC_ContentKind="text" m:FC_KeepInContent="true" />' +
     '        <Property Name="UnitPrice" Type="Edm.Double" Nullable="false" m:FC_TargetPath="price/@value" m:FC_NsUri="http://www.example.org/price/" m:FC_NsPrefix="pr" m:FC_KeepInContent="false" />' +
     '        <Property Name="ServingSize" Type="Edm.Decimal" Nullable="false" />' +
     '        <Property Name="MeasurementUnit" Type="Edm.String" Nullable="true" />' +
     '        <Property Name="ProteinGrams" Type="Edm.Byte" Nullable="false" />' +
     '        <Property Name="FatGrams" Type="Edm.Int16" Nullable="false" />' +
     '        <Property Name="CarbohydrateGrams" Type="Edm.Int32" Nullable="false" />' +
     '        <Property Name="CaloriesPerServing" Type="Edm.Int64" Nullable="false" />' +
     '        <Property Name="IsAvailable" Type="Edm.Boolean" Nullable="false" />' +
     '        <Property Name="ExpirationDate" Type="Edm.DateTime" Nullable="false" />' +
     '        <Property Name="ItemGUID" Type="Edm.Guid" Nullable="false" />' +
     '        <Property Name="Weight" Type="Edm.Single" Nullable="false" />' +
     '        <Property Name="AvailableUnits" Type="Edm.SByte" Nullable="false" />' +
     '        <Property Name="Packaging" Type="DataJS.Tests.V2.Package" Nullable="false" />' +
     '        <Property Name="CookedSize" Type="DataJS.Tests.V2.CookedDimensions" Nullable="false" m:FC_TargetPath="cooked/volume" m:FC_NsUri="http://www.example.org/cooked/" m:FC_NsPrefix="cooked" m:FC_SourcePath="Volume" m:FC_KeepInContent="false" m:FC_TargetPath_1="cooked/@width" m:FC_NsUri_1="http://www.example.org/cooked/" m:FC_NsPrefix_1="cooked" m:FC_SourcePath_1="Width" m:FC_KeepInContent_1="false" m:FC_TargetPath_2="cooked/@height" m:FC_NsUri_2="http://www.example.org/cooked/" m:FC_NsPrefix_2="cooked" m:FC_SourcePath_2="Height" m:FC_KeepInContent_2="false" m:FC_TargetPath_3="cooked/@length" m:FC_NsUri_3="http://www.example.org/cooked/" m:FC_NsPrefix_3="cooked" m:FC_SourcePath_3="Length" m:FC_KeepInContent_3="false" />' +
     '        <NavigationProperty Name="Category" Relationship="DataJS.Tests.V2.Food_Category" FromRole="Food" ToRole="Category" />' +
     '      </EntityType>' +
     '      <ComplexType Name="Package">' +
     '        <Property Name="Type" Type="Edm.String" Nullable="true" />' +
     '        <Property Name="Color" Type="Edm.String" Nullable="true" />' +
     '        <Property Name="NumberPerPackage" Type="Edm.Int32" Nullable="false" />' +
     '        <Property Name="RequiresRefridgeration" Type="Edm.Boolean" Nullable="false" />' +
     '        <Property Name="ShipDate" Type="Edm.DateTime" Nullable="false" />' +
     '        <Property Name="PackageDimensions" Type="DataJS.Tests.V2.Dimensions" Nullable="false" />' +
     '      </ComplexType>' +
     '      <ComplexType Name="Dimensions">' +
     '        <Property Name="Length" Type="Edm.Decimal" Nullable="false" />' +
     '        <Property Name="Height" Type="Edm.Int16" Nullable="false" />' +
     '        <Property Name="Width" Type="Edm.Int64" Nullable="false" />' +
     '        <Property Name="Volume" Type="Edm.Double" Nullable="false" />' +
     '      </ComplexType>' +
     '      <ComplexType Name="CookedDimensions">' +
     '        <Property Name="Length" Type="Edm.Decimal" Nullable="false" />' +
     '        <Property Name="Height" Type="Edm.Int16" Nullable="false" />' +
     '        <Property Name="Width" Type="Edm.Int64" Nullable="false" />' +
     '        <Property Name="Volume" Type="Edm.Double" Nullable="false" />' +
     '      </ComplexType>' +
     '      <Association Name="Category_Foods">' +
     '        <End Role="Category" Type="DataJS.Tests.V2.Category" Multiplicity="*" />' +
     '        <End Role="Foods" Type="DataJS.Tests.V2.Food" Multiplicity="*" />' +
     '      </Association>' +
     '      <Association Name="Food_Category">' +
     '        <End Role="Food" Type="DataJS.Tests.V2.Food" Multiplicity="*" />' +
     '        <End Role="Category" Type="DataJS.Tests.V2.Category" Multiplicity="0..1" />' +
     '      </Association>' +
     '      <EntityContainer Name="FoodContainer" m:IsDefaultEntityContainer="true">' +
     '        <EntitySet Name="Categories" EntityType="DataJS.Tests.V2.Category" />' +
     '        <EntitySet Name="Foods" EntityType="DataJS.Tests.V2.Food" />' +
     '        <AssociationSet Name="Category_Foods" Association="DataJS.Tests.Category_Foods">' +
     '          <End Role="Category" EntitySet="Categories" />' +
     '          <End Role="Foods" EntitySet="Foods" />' +
     '        </AssociationSet>' +
     '        <AssociationSet Name="Food_Category" Association="DataJS.Tests.V2.Food_Category">' +
     '          <End Role="Food" EntitySet="Foods" />' +
     '          <End Role="Category" EntitySet="Categories" />' +
     '        </AssociationSet>' +
     '        <FunctionImport Name="ResetData" m:HttpMethod="POST" />' +
     '        <FunctionImport Name="FoodsAvailable" ReturnType="Collection(Edm.String)" m:HttpMethod="GET" />' +
     '        <FunctionImport Name="PackagingTypes" ReturnType="Collection(DataJS.Tests.V2.Package)" m:HttpMethod="GET" />' +
     '      </EntityContainer>' +
     '    </Schema>' +
     '  </edmx:DataServices>' +
     '</edmx:Edmx>';

     djstest.addTest(function applyEntryCustomizationToEntryTest() {
         var metadata = parseMetadataHelper(customerSampleMetadataText);
         var data = { __metadata: { type: "Ns.Customer" }, Name: "Name", LastName: "Last Name", Address: { Street: "Street Value", City: "City Value" }, FavoriteNumber: 123 };
         var request = { data: data, headers: { "Content-Type": "application/atom+xml"} };
         OData.atomHandler.write(request, { metadata: metadata });

         djstest.assert(request.body !== null, "request.body !== null");
         djstest.assert(request.body.indexOf("<a:summary type=\"xhtml\">Name</a:summary>") !== -1, 'request.body.indexOf("<a:summary>Name</a:summary>") !== -1');
         djstest.assert(request.body.indexOf('baz="Last Name"') !== -1, 'request.body.indexOf(baz="Last Name") !== -1');
         djstest.assert(request.body.indexOf('city="City Value"') !== -1, 'request.body.indexOf(city="City Value") !== -1');
         djstest.assert(request.body.indexOf('<prefix:foo ') !== -1, "request.body.indexOf('<prefix:foo ') !== -1");
         djstest.assert(request.body.indexOf('term="Ns.Customer"') !== -1, "request.body.indexOf(term='Ns.Customer') !== -1");
         djstest.assert(request.body.indexOf('>123</') !== -1, "request.body.indexOf(>123</) !== -1");

         // Try with other mapping types.
         metadata.dataServices.schema[0].entityType[0].property[1].FC_ContentKind = "html";
         request.body = undefined;
         OData.atomHandler.write(request, { metadata: metadata });
         djstest.assert(request.body.indexOf("<a:summary type=\"html\">Name</a:summary>") !== -1, 'request.body.indexOf("<a:summary type="html">Name</a:summary>") !== -1');

         // Try with a null value now.
         request.data.FavoriteNumber = null;
         request.body = null;
         OData.atomHandler.write(request, { metadata: metadata });
         djstest.assert(request.body.indexOf('>123</') === -1, "request.body.indexOf(>123</) === -1");
         djstest.assert(request.body.indexOf('m:null="true"') !== -1, "request.body.indexOf(m:null=true) !== -1");

         // Try with a null complex type now.
         request.data.FavoriteNumber = 123;
         request.data.Address = null;
         request.body = null;
         OData.atomHandler.write(request, { metadata: metadata });
         djstest.assert(request.body.indexOf('Street') === -1, "request.body.indexOf(Street) === -1");
         djstest.assert(request.body.indexOf('m:null="true"') !== -1, "request.body.indexOf(m:null=true) !== -1");

         djstest.done();
     });

     djstest.addTest(function normalizeHeadersReadTest() {
         // Verifies that headers are normalized for reading.
         // See issue at http://datajs.codeplex.com/workitem/148
         window.MockHttpClient.clear().addResponse("/foo", {
             statusCode: 200,
             body: foodServiceV2FoodsSampleText,
             headers: { "Accept": "application/json", "unknown": "u", "content-type": "application/atom+xml", "dataserviceversion": "2.0" }
         });

         OData.read("/foo", function (data, response) {
             djstest.assertAreEqual(data.results.length, 2, "data.results.length has two entries");
             djstest.assertAreEqual(response.headers.Accept, "application/json", "Accept available");
             djstest.assertAreEqual(response.headers.unknown, "u", "u unmodified");
             djstest.assertAreEqual(response.headers["Content-Type"], "application/atom+xml", "Content-Type available");
             djstest.assertAreEqual(response.headers["DataServiceVersion"], "2.0", "DataServiceVersion available");
             djstest.done();
         }, undefined, undefined, MockHttpClient);
     });

     djstest.addTest(function normalizeHeadersWriteTest() {
         // Verifies that headers are normalized for writing.
         // See issue at http://datajs.codeplex.com/workitem/148
         window.MockHttpClient.clear().addRequestVerifier("/foo", function (request) {
             djstest.assertAreEqual(request.headers["Content-Type"], "application/atom+xml", "json found");
             djstest.assert(request.body.indexOf(":bar") !== -1, "format recognized and applied as XML");
             djstest.done();
         });

         var request = {
             method: "POST",
             requestUri: "/foo",
             data: { "bar": 123 },
             headers: { "content-type": "application/atom+xml" }
         };
         OData.request(request, function (data) {
         }, undefined, undefined, MockHttpClient);
     });

     djstest.addTest(function testParsePrimitivePropertiesBasic() {
         var feed = "\
         <entry xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
                xmlns:d=\'http://schemas.microsoft.com/ado/2007/08/dataservices\' \r\n\
                xmlns:m=\'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\' \r\n\
                xmlns:atom=\'http://www.w3.org/2005/Atom\' \r\n\
                xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
                xmlns=\'http://www.w3.org/2005/Atom\'>\r\n\
            <id>http://services.odata.org/OData/OData.svc/the id</id> \r\n \
            <content type='application/xml'>\r\n \
             <m:properties xmlns=\'http://schemas.microsoft.com/ado/2007/08/dataservices\'>\r\n \
              <Boolean m:type='Edm.Boolean'>true</Boolean>\r\n \
              <Binary m:type='Edm.Binary'>01007A8A680D9E14A64EAC1242DD33C9DB05</Binary>\r\n \
              <Byte m:type='Edm.Byte'>8</Byte>\r\n \
              <DateTime m:type='Edm.DateTime'>2010-11-01T15:13:25</DateTime>\r\n \
              <Decimal m:type='Edm.Decimal'>100.10</Decimal>\r\n \
              <Guid m:type='Edm.Guid'>12345678-aaaa-bbbb-cccc-ddddeeeeffff</Guid>\r\n \
              <!-- <Time m:type='Edm.Time'>P05DT12H30M05.125S</Time> --> \r\n \
              <DateTimeOffset m:type='Edm.DateTimeOffset'>2010-11-01T15:13:25+10:00</DateTimeOffset>\r\n \
              <Double m:type='Edm.Double'>1E+10</Double>\r\n \
              <Single m:type='Edm.Single'>100.01</Single>\r\n \
              <Int16 m:type='Edm.Int16'>16</Int16>\r\n \
              <Int32 m:type='Edm.Int32'>32</Int32>\r\n \
              <Int64 m:type='Edm.Int64'>64</Int64>\r\n \
              <SByte m:type='Edm.SByte'>-8</SByte>\r\n \
             </m:properties>\r\n \
            </content>\r\n \
         </entry>\r\n";

         var response = { body: feed, headers: { "Content-Type": "application/atom+xml"} };
         OData.atomHandler.read(response, {});

         djstest.assertsExpected(1);
         ODataReadOracle.readEntryLoopback(feed, function (expectedData) {
             djstest.assertAreEqualDeep(response.data, expectedData, "Verify deserialized data");
             djstest.done();
         });
     });

     djstest.addTest(function deserializeCustomizationsNullAndXhtmlTest() {
         var payload = "<entry " +
         ' xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" \r\n' +
         " xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata' \r\n" +
         " xmlns=\"http://www.w3.org/2005/Atom\">\r\n" +
         " <id>http://localhost/tests/endpoints/FoodDataService.svc/Foods(1)</id> " +
         " <author><name>Customer #1</name></author>" +
         " <summary><b>Name</b></summary>" +
         " <category term='Ns.Customer' scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme' /> " +
         " <content type='application/xml'><m:properties><d:ID m:type='Edm.Int32'>1</d:ID>" +
         " <d:LastName m:null='true' /></m:properties></content>" +
         "</entry>";
         var metadata = parseMetadataHelper(customerSampleMetadataText);
         var response = { body: payload, headers: { "Content-Type": "application/atom+xml"} };
         OData.atomHandler.read(response, { metadata: metadata });

         djstest.assertAreEqual(response.data.LastName, null, "last name is null");
         djstest.assertAreEqual(response.data.Name, "<b xmlns=\"http://www.w3.org/2005/Atom\">Name</b>", "name includes tags");

         djstest.done();
     });

     djstest.addTest(function parseCustomizationSampleTest() {
         var payload = foodServiceV2FoodsSampleText;
         var metadata = parseMetadataHelper(foodServiceV2MetadataText);
         var response = { body: payload, headers: { "Content-Type": "application/atom+xml"} };
         OData.atomHandler.read(response, { metadata: metadata });

         djstest.assert(response.data !== null, "response.data !== null");
         djstest.assert(response.data.results !== null, "response.data.results !== null");

         var r = response.data.results;
         djstest.assertAreEqual(r[0].__metadata.type, "DataJS.Tests.V2.Food", "r[0].__metadata.type");
         djstest.assertAreEqual(r[0].Name, "flour", "r[0].Name");
         djstest.assertAreEqual(r[0].UnitPrice, 0.19999, "r[0].UnitPrice");
         djstest.assertAreEqual(r[0].ServingSize, 1, "r[0].ServingSize");

         // CONSIDER: we intended to have complex type have their type annotation out-of-band, but JSON has it in-line; do we want to normalize this out everywhere?
         // djstest.assertAreEqual(r[0].Packaging.__metadata.type, "DataJS.Tests.PackageV2", "r[0].Packaging.__metadata.type");
         djstest.assertAreEqual(r[0].Packaging.Type, null, "package type for flour is null");
         djstest.assertAreEqual(r[0].Packaging.PackageDimensions.Height, 32767, "r[0].Packaging.PackageDimensions.Height");

         djstest.assertAreEqual(r[0].CookedSize.Length, 2, "r[0].CookedSize.Length");
         djstest.assertAreEqual(r[0].CookedSize.Volume, 6, "r[0].CookedSize.Volume");

         djstest.done();
     });

     djstest.addTest(function parseIntoPropertiesTest() {
         var payload = '' +
             '<entry xml:base="http://localhost/tests/endpoints/FoodStoreDataServiceV2.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom">' +
             '  <id>http://localhost/tests/endpoints/FoodStoreDataServiceV2.svc/Foods(0)</id>' +
             '  <title type="text">flour</title>' +
             '  <updated>2010-12-28T23:09:54Z</updated>' +
             '  <author><name /></author>' +
             '  <link rel="edit" title="Food" href="Foods(0)" />' +
             '  <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Category" type="application/atom+xml;type=entry" title="Category" href="Foods(0)/Category" />' +
             '  <category term="DataJS.Tests.V2.Food" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />' +
             '  <content type="application/xml">' +
             '    <m:properties>' +
             '      <d:FoodID m:type="Edm.Int32">0</d:FoodID>' +
             '      <d:Name>flour</d:Name>' +
             '      <d:ServingSize m:type="Edm.Decimal">1</d:ServingSize>' +
             '      <d:MeasurementUnit>Cup</d:MeasurementUnit>' +
             '      <d:ProteinGrams m:type="Edm.Byte">3</d:ProteinGrams>' +
             '      <d:FatGrams m:type="Edm.Int16">1</d:FatGrams>' +
             '      <d:CarbohydrateGrams m:type="Edm.Int32">20</d:CarbohydrateGrams>' +
             '      <d:CaloriesPerServing m:type="Edm.Int64">140</d:CaloriesPerServing>' +
             '      <d:IsAvailable m:type="Edm.Boolean">true</d:IsAvailable>' +
             '      <d:ExpirationDate m:type="Edm.DateTime">2010-12-25T12:00:00</d:ExpirationDate>' +
             '      <d:ItemGUID m:type="Edm.Guid">27272727-2727-2727-2727-272727272727</d:ItemGUID>' +
             '      <d:Weight m:type="Edm.Single">10</d:Weight>' +
             '      <d:AvailableUnits m:type="Edm.SByte">1</d:AvailableUnits>' +
             '      <d:Packaging m:type="DataJS.Tests.V2.Package">' +
             '        <d:Type m:null="true" />' +
             '        <d:Color></d:Color>' +
             '        <d:NumberPerPackage m:type="Edm.Int32">2147483647</d:NumberPerPackage>' +
             '        <d:RequiresRefridgeration m:type="Edm.Boolean">false</d:RequiresRefridgeration>' +
             '        <d:ShipDate m:type="Edm.DateTime">0001-01-01T00:00:00</d:ShipDate>' +
             '        <d:PackageDimensions m:type="DataJS.Tests.V2.Dimensions">' +
             '          <d:Length m:type="Edm.Decimal">79228162514264337593543950335</d:Length>' +
             '          <d:Height m:type="Edm.Int16">32767</d:Height>' +
             '          <d:Width m:type="Edm.Int64">9223372036854775807</d:Width>' +
             '          <d:Volume m:type="Edm.Double">1.7976931348623157E+308</d:Volume>' +
             '        </d:PackageDimensions>' +
             '      </d:Packaging>' +
             '    </m:properties>' +
             '  </content>' +
             '  <cooked:cooked cooked:length="2" cooked:height="1" cooked:width="3" xmlns:cooked="http://www.example.org/cooked/">' +
             '    <cooked:volume>6</cooked:volume>' +
             '  </cooked:cooked>' +
             '  <pr:price pr:value="0.19999" xmlns:pr="http://www.example.org/price/"></pr:price>' +
             '</entry>';

         var metadata = parseMetadataHelper(foodServiceV2MetadataText);
         var response = { body: payload, headers: { "Content-Type": "application/atom+xml"} };
         OData.atomHandler.read(response, { metadata: metadata });

         djstest.assert(response.data !== null, "response.data !== null");
         djstest.assertAreEqual(response.data.__metadata.type, "DataJS.Tests.V2.Food", "types match");
         djstest.assertAreEqual(response.data.UnitPrice, 0.19999, "Price is as expected");
         djstest.assertAreEqual(response.data.__metadata.properties.UnitPrice.type, "Edm.Double", "Price was marked as a double");

         djstest.assertAreEqual(response.data.CookedSize.__metadata.properties.Length.type, "Edm.Decimal", "CookedSize.Length was marked as a decimal");

         // When properties are marked on complex type metadata, this assertion will be true as well.
         // djstest.assertAreEqual(response.data.Packaging.__metadata.Type.type, "Edm.String", "Packaging type was marked as a string");

         djstest.done();
     });

     djstest.addTest(function parseNullInlineTest() {
         // Shorter version of:
         // OData.read("/tests/endpoints/FoodStoreDataService.svc/Foods?$expand=Category&$filter=Category eq null", function(data, response) {

         var body = '' +
         '<feed xml:base="http://localhost/tests/endpoints/FoodStoreDataService.svc/" xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices" xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" xmlns="http://www.w3.org/2005/Atom">' +
         '  <entry>' +
         '    <id>http://localhost/tests/endpoints/FoodStoreDataService.svc/Foods(2)</id>' +
         '    <link rel="edit" title="Food" href="Foods(2)" />' +
         '    <link rel="http://schemas.microsoft.com/ado/2007/08/dataservices/related/Category" type="application/atom+xml;type=entry" title="Category" href="Foods(2)/Category">' +
         '      <m:inline />' +
         '    </link>' +
         '    <category term="DataJS.Tests.Food" scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />' +
         '    <content type="application/xml">' +
         '      <m:properties>' +
         '        <d:FoodID m:type="Edm.Int32">2</d:FoodID>' +
         '        <d:Name>1 Chicken Egg</d:Name>' +
         '        <d:UnitPrice m:type="Edm.Double">0.55</d:UnitPrice>' +
         '      </m:properties>' +
         '    </content>' +
         '  </entry>' +
         '</feed>';
         var response = { body: body, headers: { "Content-Type": "application/atom+xml"} };
         OData.atomHandler.read(response, {});
         var data = response.data;
         var r = data.results[0];
         djstest.assertAreEqual(r.Category, null, "r.Category is null as an empty inline entry");
         djstest.assertAreEqual(r.FoodID, 2, "r.FoodID read correctly");
         djstest.assertAreEqual(r.__metadata.properties.Category.extensions[0].name, "title", "Category title extension parsed");
         djstest.assertAreEqual(r.__metadata.properties.Category.extensions[0].value, "Category", "Category title value parsed");
         djstest.done();
     });

     djstest.addTest(function serializeEpmTest() {
         var metadata = parseMetadataHelper(foodServiceV2MetadataText);
         var data = { __metadata: { type: "DataJS.Tests.V2.Food" }, FoodID: 123, Name: "name", CookedSize: { Length: 1, Height: 2, Width: 3, Volume: 4} };
         var request = { data: data, headers: { "Content-Type": "application/atom+xml"} };
         OData.atomHandler.write(request, { metadata: metadata });
         djstest.assert(request.body.indexOf("CookedSize") === -1, "CookedSize element is missing from payload");
         djstest.assert(request.body.indexOf("length=") !== -1, "length is available as a mapped attribute");
         djstest.assert(request.body.indexOf("height=") !== -1, "height is available as a mapped attribute");
         djstest.assert(request.body.indexOf("width=") !== -1, "width is available as a mapped attribute");
         djstest.assert(request.body.indexOf("volume>") !== -1, "volume is available as a mapped element");
         djstest.done();
     });

     djstest.addTest(function writeNullComplexTypeTest() {

         // Verify that the server can be updated to set a complex value to null.
         var foodSetUrl = "./endpoints/FoodStoreDataServiceV2.svc/Foods";
         resetFoodData();

         // Without metadata, this will fail because the server version won't be set to 2.0.
         var metadata = parseMetadataHelper(foodServiceV2MetadataText);
         OData.read(foodSetUrl + "?$top=1", function (data) {
             var item = data.results[0];
             djstest.assert(item.Packaging, "item.Packaging is not null");
             item.Packaging = null;

             // The server will reject links for PUT operations.
             delete item.Category;

             OData.request({ method: "PUT", requestUri: item.__metadata.uri, data: item, headers: { "Content-Type": "application/atom+xml"} }, function (data) {
                 // Re-read the item.
                 OData.read(item.__metadata.uri, function (data) {
                     djstest.assert(data, "data was read successfully again");
                     djstest.assert(!data.Packaging, "!data.Packaging");
                     resetFoodData();
                     djstest.done();
                 }, djstest.failAndDoneCallback("Failed to read back food.", resetFoodData));
             }, djstest.failAndDoneCallback("Failed to write food"), null, null, metadata);
         }, djstest.failAndDoneCallback("Failed to read food"), null, null, metadata);
     });

     djstest.addTest(function writeNonNullLinkTest() {
         // Verify that the server can be updated to set a link to null.
         resetFoodData();
         var foodSetUrl = "./endpoints/FoodStoreDataServiceV2.svc/Foods";
         var metadata = parseMetadataHelper(foodServiceV2MetadataText);
         OData.read(foodSetUrl + "?$top=1", function (data) {
             var item = data.results[0];

             // Turn this into something different.
             delete item.__metadata.uri;
             item.FoodID = 1001;

             OData.request({ method: "POST", requestUri: foodSetUrl, data: item, headers: { "Content-Type": "application/atom+xml"} }, function (data) {
                 // Re-read the item.
                 OData.read(data.__metadata.uri + "?$expand=Category", function (data) {
                     djstest.assert(data, "data was read successfully again");
                     djstest.assert(data.Category, "data.Category");
                     djstest.assert(data.Category.Name, "data.Category.Name");
                     resetFoodData();
                     djstest.done();
                 }, djstest.failAndDoneCallback("Failed to read back food.", resetFoodData));
             }, djstest.failAndDoneCallback("Failed to add modified food"), null, null, metadata);
         }, djstest.failAndDoneCallback("Failed to read food"), null, null, metadata);
     });

     djstest.addTest(function writeNullLinkTest() {
         // Verify that the server can be updated to set a link to null.
         resetFoodData();
         var foodSetUrl = "./endpoints/FoodStoreDataServiceV2.svc/Foods";
         var metadata = parseMetadataHelper(foodServiceV2MetadataText);
         OData.read(foodSetUrl + "?$top=1", function (data) {
             var item = data.results[0];

             // Turn this into something different.
             delete item.__metadata.uri;
             item.FoodID = 1001;
             item.Category = null;

             OData.request({ method: "POST", requestUri: foodSetUrl, data: item, headers: { "Content-Type": "application/atom+xml"} }, function (data) {
                 // Re-read the item.
                 OData.read(data.__metadata.uri + "?$expand=Category", function (data) {
                     djstest.assert(data, "data was read successfully again");
                     djstest.assert(!data.Category, "data.Category");
                     resetFoodData();
                     djstest.done();
                 }, djstest.failAndDoneCallback("Failed to read back food.", resetFoodData));
             }, djstest.failAndDoneCallback("Failed to add modified food"), null, null, metadata);
         }, djstest.failAndDoneCallback("Failed to read food"), null, null, metadata);
     });

     // DATAJS INTERNAL START
     djstest.addTest(function lookupEntityTypeInSchemaTest() {
         var schemaEmpty = {};
         var schemaZero = {
             namespace: "Zero",
             entityType: [
                 { name: "Genre" },
                 { name: "Language" }
             ]
         };
         var schemaOne = {
             namespace: "One",
             entityType: [
                 { name: "Genre1" },
                 { name: "Language1" }
             ]
         };
         var edmx = { dataServices: { schema: [schemaEmpty, schemaZero, schemaOne]} };

         var lookupEntityTypeInSchema = function (name, schema) {
             return OData.lookupInMetadata(name, schema, "entityType");
         };

         djstest.assertAreEqual(
         lookupEntityTypeInSchema("Zero.Genre"),
         null, "Expected null for missing metadata");
         djstest.assertAreEqual(
             lookupEntityTypeInSchema("", schemaEmpty),
             null, "Expected null for empty type name");
         djstest.assertAreEqual(
             lookupEntityTypeInSchema("FooWar", schemaEmpty),
             null, "Expected null for mismatched name/namespace");
         djstest.assertAreEqual(
             lookupEntityTypeInSchema("Zero", schemaZero),
             null, "Expected null for unqualified type name");
         djstest.assertAreEqual(
             lookupEntityTypeInSchema("Zero.Something", schemaZero),
             null, "Expected null for mismatched type name");
         djstest.assertAreEqualDeep(
             lookupEntityTypeInSchema("Zero.Genre", schemaZero),
             { name: "Genre" }, "Found type by full name");

         djstest.assertAreEqual(
             lookupEntityTypeInSchema("Zero.Something", edmx),
             null, "Expected null for mismatched type name in edmx");
         djstest.assertAreEqualDeep(
             lookupEntityTypeInSchema("Zero.Genre", edmx),
             { name: "Genre" }, "Found type by full name in edmx");
         djstest.assertAreEqualDeep(
             lookupEntityTypeInSchema("One.Genre1", edmx),
             { name: "Genre1" }, "Found type by full name in edmx");

         djstest.assertAreEqual(
             OData.lookupInMetadata("One.Genre1", edmx, "complexType"),
             null, "Expected null for a complex type lookup of an entity type.");

         djstest.done();
     });

     djstest.addTest(function testLookupEntityType() {
         var schemaZero = {
             namespace: "Zero",
             entityType: [
                 { name: "Genre" },
                 { name: "Language" }
             ]
         };
         var schemaOne = {
             namespace: "One",
             entityType: [
                 { name: "Genre1" },
                 { name: "Language1" }
             ]
         };
         var schemaTwo = {
             namespace: "Two",
             entityType: [
                 { name: "Genre2" },
                 { name: "Language2" }
             ]
         };
         var edmx = { dataServices: { schema: [schemaZero, schemaOne]} };
         var metadata = [edmx, schemaTwo];

         djstest.assertAreEqual(
             OData.lookupEntityType("Zero.Something", metadata),
             null, "Expected null for mismatched type name in metadata");
         djstest.assertAreEqualDeep(
             OData.lookupEntityType("Zero.Genre", null),
             null, "Expected null for missing metadata");
         djstest.assertAreEqualDeep(
             OData.lookupEntityType(null, metadata),
             null, "Expected null for missing name");
         djstest.assertAreEqualDeep(
             OData.lookupEntityType("Zero.Genre", metadata),
             { name: "Genre" }, "Found type by full name in metadata");
         djstest.assertAreEqualDeep(
             OData.lookupEntityType("One.Genre1", metadata),
             { name: "Genre1" }, "Found type by full name in metadata");
         djstest.assertAreEqualDeep(
             OData.lookupEntityType("One.Genre1", edmx),
             { name: "Genre1" }, "Found type by full name in edmx");
         djstest.assertAreEqualDeep(
             OData.lookupEntityType("Two.Genre2", metadata),
             { name: "Genre2" }, "Found type by full name in metadata");

         djstest.done();
     });

     djstest.addTest(function testParseSimpleServiceDocument() {
         var serviceDocString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
            <workspace>\r\n\
               <atom:title>Default</atom:title> \r\n\
               <collection href=\"Products\">\r\n\
                 <atom:title>Products</atom:title> \r\n\
               </collection>\r\n\
               <collection href=\"Categories\">\r\n\
                 <atom:title>Categories</atom:title> \r\n\
               </collection>\r\n\
               <collection href=\"Suppliers\">\r\n\
                 <atom:title>Suppliers</atom:title> \r\n\
               </collection>\r\n\
             </workspace>\r\n\
          </service>\r\n";

         var serviceDoc = OData.atomParser(OData.atomHandler, serviceDocString, {});

         djstest.assertAreEqual(serviceDoc.workspaces.length, 1, "Incorrect number of workspaces");

         var workspace = serviceDoc.workspaces[0];
         djstest.assertAreEqual(workspace.title, "Default", "Incorrect service doc title");

         var expectedCollections = [
             { expectedHref: "http://services.odata.org/OData/OData.svc/Products", expectedTitle: "Products" },
             { expectedHref: "http://services.odata.org/OData/OData.svc/Categories", expectedTitle: "Categories" },
             { expectedHref: "http://services.odata.org/OData/OData.svc/Suppliers", expectedTitle: "Suppliers" }
         ];

         djstest.assertAreEqual(workspace.collections.length, expectedCollections.length, "Incorrect number of collections in workspace");

         var i, len;
         for (i = 0, len = expectedCollections.length; i < len; i++) {
             djstest.assertAreEqual(workspace.collections[i].href, expectedCollections[i].expectedHref, "Incorrect href on collection");
             djstest.assertAreEqual(workspace.collections[i].title, expectedCollections[i].expectedTitle, "Incorrect title on collection");
         }

         djstest.done();
     });

     djstest.addTest(function testServiceDocMustHaveAtLeastOneWorkspaceElement() {
         // Construct a service doc with no workspaces and verify that the parser throws.
         var serviceDocString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
          </service>\r\n";

         djstest.expectException(function () {
             var serviceDoc = OData.atomParser(OData.atomHandler, serviceDocString, {});
         }, "Parsing service doc with no workspaces");

         djstest.done();
     });

     djstest.addTest(function testServiceDocMayHaveMoreThanOneWorkspaceElement() {
         var serviceDocString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
            <workspace>\r\n\
               <atom:title>Default</atom:title> \r\n\
               <collection href=\"Products\">\r\n\
                 <atom:title>Products</atom:title> \r\n\
               </collection>\r\n\
               <collection href=\"Categories\">\r\n\
                 <atom:title>Categories</atom:title> \r\n\
               </collection>\r\n\
               <collection href=\"Suppliers\">\r\n\
                 <atom:title>Suppliers</atom:title> \r\n\
               </collection>\r\n\
             </workspace>\r\n\
             <workspace>\r\n\
               <atom:title>Second Workspace</atom:title> \r\n\
               <collection href=\"Collection1\">\r\n\
                 <atom:title>Collection Number 1</atom:title> \r\n\
               </collection>\r\n\
               <collection href=\"Collection2\">\r\n\
                 <atom:title>Collection Number 2</atom:title> \r\n\
               </collection>\r\n\
             </workspace>\r\n\
          </service>\r\n";

         var serviceDoc = OData.atomParser(OData.atomHandler, serviceDocString, {});

         djstest.assertAreEqual(serviceDoc.workspaces.length, 2, "Incorrect number of workspaces");

         var workspace = serviceDoc.workspaces[0];
         djstest.assertAreEqual(workspace.title, "Default", "Incorrect service doc title");

         var expectedCollections;
         expectedCollections = [
             { expectedHref: "http://services.odata.org/OData/OData.svc/Products", expectedTitle: "Products" },
             { expectedHref: "http://services.odata.org/OData/OData.svc/Categories", expectedTitle: "Categories" },
             { expectedHref: "http://services.odata.org/OData/OData.svc/Suppliers", expectedTitle: "Suppliers" }
         ];

         djstest.assertAreEqual(workspace.collections.length, expectedCollections.length, "Incorrect number of collections in workspace");

         var i, len;
         for (i = 0, len = expectedCollections.length; i < len; i++) {
             djstest.assertAreEqual(workspace.collections[i].href, expectedCollections[i].expectedHref, "Incorrect href on collection");
             djstest.assertAreEqual(workspace.collections[i].title, expectedCollections[i].expectedTitle, "Incorrect title on collection");
         }

         workspace = serviceDoc.workspaces[1];
         djstest.assertAreEqual(workspace.title, "Second Workspace", "Incorrect service doc title");

         expectedCollections = [
             { expectedHref: "http://services.odata.org/OData/OData.svc/Collection1", expectedTitle: "Collection Number 1" },
             { expectedHref: "http://services.odata.org/OData/OData.svc/Collection2", expectedTitle: "Collection Number 2" }
         ];

         djstest.assertAreEqual(workspace.collections.length, expectedCollections.length, "Incorrect number of collections in workspace");

         for (i = 0, len = expectedCollections.length; i < len; i++) {
             djstest.assertAreEqual(workspace.collections[i].href, expectedCollections[i].expectedHref, "Incorrect href on collection");
             djstest.assertAreEqual(workspace.collections[i].title, expectedCollections[i].expectedTitle, "Incorrect title on collection");
         }

         djstest.done();
     });

     djstest.addTest(function testCollectionTitlesAndHrefsMayBeDifferent() {
         var serviceDocString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
            <workspace>\r\n\
               <atom:title>Default</atom:title> \r\n\
               <collection href=\"abc\">\r\n\
                 <atom:title>xyz</atom:title> \r\n\
               </collection>\r\n\
               <collection href=\"blah\">\r\n\
                 <atom:title>foo</atom:title> \r\n\
               </collection>\r\n\
             </workspace>\r\n\
          </service>\r\n";

         var serviceDoc = OData.atomParser(OData.atomHandler, serviceDocString, {});

         djstest.assertAreEqual(serviceDoc.workspaces.length, 1, "Incorrect number of workspaces");

         var workspace = serviceDoc.workspaces[0];
         djstest.assertAreEqual(workspace.title, "Default", "Incorrect service doc title");

         var expectedCollections = [
             { expectedHref: "http://services.odata.org/OData/OData.svc/abc", expectedTitle: "xyz" },
             { expectedHref: "http://services.odata.org/OData/OData.svc/blah", expectedTitle: "foo" }
         ];

         djstest.assertAreEqual(workspace.collections.length, expectedCollections.length, "Incorrect number of collections in workspace");

         var i, len;
         for (i = 0, len = expectedCollections.length; i < len; i++) {
             djstest.assertAreEqual(workspace.collections[i].href, expectedCollections[i].expectedHref, "Incorrect href on collection");
             djstest.assertAreEqual(workspace.collections[i].title, expectedCollections[i].expectedTitle, "Incorrect title on collection");
         }

         djstest.done();
     });

     djstest.addTest(function testParserShouldTreatMissingWorkspaceTitleAsBlank() {
         // Per RFC 5023 Section 8.3.2.1, the workspace element MUST have a title but
         // in the interests of being permissive, we should treat this as blank.
         var serviceDocString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
            <workspace>\r\n\
               <!-- No workspace title element -->\r\n\
               <collection href=\"Products\">\r\n\
                 <atom:title>Products</atom:title> \r\n\
               </collection>\r\n\
               <collection href=\"Categories\">\r\n\
                 <atom:title>Categories</atom:title> \r\n\
               </collection>\r\n\
               <collection href=\"Suppliers\">\r\n\
                 <atom:title>Suppliers</atom:title> \r\n\
               </collection>\r\n\
             </workspace>\r\n\
          </service>\r\n";

         var serviceDoc = OData.atomParser(OData.atomHandler, serviceDocString, {});

         djstest.assertAreEqual(serviceDoc.workspaces.length, 1, "Incorrect number of workspaces");

         var workspace = serviceDoc.workspaces[0];
         djstest.assertAreEqual(workspace.title, "", "Incorrect service doc title");

         djstest.done();
     });

     djstest.addTest(function testWorkspaceMayHaveNoCollections() {
         var serviceDocString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
            <workspace>\r\n\
               <atom:title>Default</atom:title> \r\n\
             </workspace>\r\n\
          </service>\r\n";

         var serviceDoc = OData.atomParser(OData.atomHandler, serviceDocString, {});

         djstest.assertAreEqual(serviceDoc.workspaces.length, 1, "Incorrect number of workspaces");

         var workspace = serviceDoc.workspaces[0];
         var expectedCollections = [];

         djstest.assertAreEqual(workspace.collections.length, expectedCollections.length, "Incorrect number of collections in workspace");

         djstest.done();
     });

     djstest.addTest(function testCollectionMustHaveTitleElement() {
         var serviceDocString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
            <workspace>\r\n\
               <atom:title>Default</atom:title> \r\n\
               <collection href=\"Products\">\r\n\
                 <!-- No title element -->\r\n\
               </collection>\r\n\
             </workspace>\r\n\
          </service>\r\n";

         djstest.expectException(function () {
             var serviceDoc = OData.atomParser(OData.atomHandler, serviceDocString, {});
         }, "Parsing service doc with a collection with no title element");

         djstest.done();
     });

     djstest.addTest(function testCollectionMustHaveHrefAttribute() {
         var serviceDocString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
            <workspace>\r\n\
               <atom:title>Default</atom:title> \r\n\
               <!-- href attribute missing below --> \r\n\
               <collection>\r\n\
                 <atom:title>Products</atom:title> \r\n\
               </collection>\r\n\
             </workspace>\r\n\
          </service>\r\n";

         djstest.expectException(function () {
             var serviceDoc = OData.atomParser(OData.atomHandler, serviceDocString, {});
         }, "Parsing service doc with a collection with no href attribute");

         djstest.done();
     });

     djstest.addTest(function atomReadDocumentTest() {
         var emptyServiceString = "\
         <service xml:base=\"http://services.odata.org/OData/OData.svc/\" \r\n\
                  xmlns:atom=\"http://www.w3.org/2005/Atom\" \r\n\
                  xmlns:app=\"http://www.w3.org/2007/app\" \r\n\
                  xmlns=\"http://www.w3.org/2007/app\">\r\n\
           <workspace>\r\n\
             <atom:title>empty service</atom:title> \r\n\
           </workspace>\r\n\
         </service>\r\n";

         var emptyFeedString = "\
         <feed xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
               xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
            <id>feed id</id> \r\n\
            <title>empty feed</title> \r\n\
         </feed> \r\n";

         var emptyEntryString = "\
         <entry xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
               xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
            <id>entry id</id> \r\n\
            <title>empty entry</title> \r\n\
         </entry> \r\n";

         var nonAtomString = "\
         <notAtom xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
               xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
            <id>entry id</id> \r\n\
            <title>empty entry</title> \r\n\
         </notAtom> \r\n";

         var service = OData.atomReadDocument(datajs.xmlParse(emptyServiceString).documentElement);
         var feed = OData.atomReadDocument(datajs.xmlParse(emptyFeedString).documentElement);
         var entry = OData.atomReadDocument(datajs.xmlParse(emptyEntryString).documentElement);
         var nonAtom = OData.atomReadDocument(datajs.xmlParse(nonAtomString).documentElement);

         djstest.assert(service && service.workspaces.length === 1, "atomReadDocument deserialized a service document");
         djstest.assert(feed && feed.results.length === 0, "atomReadDocument deserialized a feed document");
         djstest.assert(entry && !entry.results && entry.__metadata.uri === "http://services.odata.org/OData/OData.svc/entry id", "atomReadDocument deserialized a entry document");
         djstest.assertAreEqual(nonAtom, undefined, "atomReadDocument returns undefined with non Atom input");

         djstest.done();
     });

     djstest.addTest(function atomReadFeedV1Test() {
         var simpleFeedString = "\
         <feed xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
               xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
               xmlns:m=\'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
            <id>feed id</id> \r\n\
            <title>test feed</title> \r\n\
            <entry> \r\n\
              <id>entry id</id> \r\n\
              <title>empty entry</title> \r\n\
            </entry> \r\n\
         </feed> \r\n";

         var expectedFeed = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/feed id",
                 uri_extensions: [],
                 title: "test feed",
                 title_extensions: [],
                 feed_extensions: []
             },
             results: [
                 { __metadata: {
                     uri: "http://services.odata.org/OData/OData.svc/entry id",
                     uri_extensions: []
                 }
                 }
            ]
         };

         var feed = OData.atomReadFeed(datajs.xmlParse(simpleFeedString).documentElement);

         djstest.assert(feed, "atomReadFeed didn't return a feed object for a V1 payload");
         djstest.assertAreEqualDeep(feed, expectedFeed, "atomReadFeed didn't return the expected feed");
         djstest.done();
     });

     djstest.addTest(function atomReadFeedV2Test() {
         var simpleFeedString = "\
         <feed xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
               xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
               xmlns:m=\'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
            <id>feed id</id> \r\n\
            <title>test feed</title> \r\n\
            <m:count>2</m:count> \r\n\
            <entry> \r\n\
              <id>entry id</id> \r\n\
              <title>empty entry</title> \r\n\
            </entry> \r\n\
            <link rel=\'next\' href=\'http://nexturi\'/> \r\n\
         </feed> \r\n";

         var expectedFeed = {
             __count: 2,
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/feed id",
                 uri_extensions: [],
                 title: "test feed",
                 title_extensions: [],
                 feed_extensions: [],
                 next_extensions: []
             },
             __next: "http://nexturi",
             results: [
                 { __metadata: {
                     uri: "http://services.odata.org/OData/OData.svc/entry id",
                     uri_extensions: []
                 }
                 }
            ]
         };

         var feed = OData.atomReadFeed(datajs.xmlParse(simpleFeedString).documentElement);

         djstest.assert(feed, "atomReadFeed didn't return a feed object for a V2 payload");
         djstest.assertAreEqualDeep(feed, expectedFeed, "atomReadFeed didn't return the expected feed");
         djstest.done();
     });

     djstest.addTest(function atomReadFeedWithActionsAndFunctionsTest() {
         var feed = "\r\n\
         <feed xml:base='http://services.odata.org/OData/OData.svc/' \r\n\
               xmlns:app='http://www.w3.org/2007/app' \r\n\
               xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata' \r\n\
               xmlns:me='http://myExtensions' \r\n\
               xmlns='http://www.w3.org/2005/Atom'> \r\n\
            <id>feed id</id> \r\n\
            <title>test feed</title> \r\n\
            <m:action metadata='#EntityContainer.Action1' title='Action1' target='http://service/entities(0)/action' /> \r\n\
            <m:action metadata='#EntityContainer.Action2' title='Action2' target='entities(0)/action2'/> \r\n\
            <m:action metadata='http://someService/$metadata#Container.Action1' title='Action1' target='http://someService/action' /> \r\n\
            <m:function metadata='#EntityContainer.Function1' title='Function1' target='http://service/entities(0)/function' /> \r\n\
            <m:function metadata='#EntityContainer.Function2' title='Function2' target='entities(0)/function2' /> \r\n\
            <m:function metadata='http://someService/$metadata#Container.Function1' title='Function1' target='http://someService/function' /> \r\n\
         </feed> \r\n";

         var expected = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/feed id",
                 uri_extensions: [],
                 title: "test feed",
                 title_extensions: [],
                 feed_extensions: [],
                 actions: [
                     {
                         metadata: "#EntityContainer.Action1",
                         title: "Action1",
                         target: "http://service/entities(0)/action",
                         extensions: []
                     },
                     {
                         metadata: "#EntityContainer.Action2",
                         title: "Action2",
                         target: "http://services.odata.org/OData/OData.svc/entities(0)/action2",
                         extensions: []
                     },
                     {
                         metadata: "http://someService/$metadata#Container.Action1",
                         title: "Action1",
                         target: "http://someService/action",
                         extensions: []
                     }
                 ],
                 functions: [
                     {
                         metadata: "#EntityContainer.Function1",
                         title: "Function1",
                         target: "http://service/entities(0)/function",
                         extensions: []
                     },
                     {
                         metadata: "#EntityContainer.Function2",
                         title: "Function2",
                         target: "http://services.odata.org/OData/OData.svc/entities(0)/function2",
                         extensions: []
                     },
                     {
                         metadata: "http://someService/$metadata#Container.Function1",
                         title: "Function1",
                         target: "http://someService/function",
                         extensions: []
                     }
                 ]
             },
             results: []
         };

         var response = { headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" }, body: feed };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, expected, "atomReadEntry didn't return the expected entry object");
         djstest.done();
     });

     djstest.addTest(function atomReadFeedExtensionsTest() {
         var feedWithExtensionsString = "\
          <feed xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
               xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
               xmlns:me=\'http://myExtensions' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\' attr1=\'a1\' me:attr2=\'a2\'> \r\n\
            <me:element1>e1</me:element1> \r\n\
            <me:element2> \r\n\
                <me:element21 attr3=\'a3\' me:attr4=\'a4\' >e1</me:element21> \r\n\
            </me:element2> \r\n\
            <id>feed id</id> \r\n\
            <title>test feed</title> \r\n\
         </feed> \r\n"

         var feed = OData.atomReadFeed(datajs.xmlParse(feedWithExtensionsString).documentElement);
         djstest.assert(feed, "atomReadFeed didn't return a feed object for a payload with feed extensions");
         djstest.assertAreEqual(feed.__metadata.feed_extensions.length, 4, "atomReadFeed didn't return the expected number of extensions");

         djstest.done();
     });

     djstest.addTest(function atomReadFeedLinksTest() {
         var feedLinksString = "\
         <feed xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
               xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
               xmlns:me=\'http://myExtensions\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
           <link rel=\'next\' href=\'http://nexturi\' me:attr1=\'a1\' attr2=\'a2\'/> \r\n\
           <link rel=\'self\' href=\'http://selfuri\' me:attr3=\'a1\' attr4=\'a2\'/> \r\n\
           <link rel=\'alternate\' href=\'http://otheruri\'/> \r\n\
         </feed> \r\n";

         var root = datajs.xmlParse(feedLinksString).documentElement;
         var feed = { __metadata: {} };
         datajs.xmlChildElements(root, function (child) {
             OData.atomReadFeedLink(child, feed);
         });

         djstest.assertAreEqual(feed.__next, "http://nexturi", "atomReadFeedLink didn't read the next link element");
         djstest.assertAreEqual(feed.__metadata.next_extensions.length, 2, "atomReadFeedLink didn't return the expected number of next link extensions");
         djstest.assertAreEqual(feed.__metadata.self, "http://selfuri", "atomReadFeedLink didn't read the self link element");
         djstest.assertAreEqual(feed.__metadata.self_extensions.length, 2, "atomReadFeedLink didn't return the expected number of self link extensions");

         djstest.done();
     });

     djstest.addTest(function atomReadLinkTest() {
         var linkString = "\
         <link xmlns:me=\'http://myExtensions\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\' \r\n\
               rel=\'next\' \r\n\
               href=\'http://nexturi\' \r\n\
               type=\'application/atom+xml;type=feed\' \r\n\
               me:attr1=\'a1\' \r\n\
               attr2=\'a2\'/> \r\n";

         var link = OData.atomReadLink(datajs.xmlParse(linkString).documentElement);

         djstest.assert(link, "atomReadLink didn't return a link object");
         djstest.assertAreEqual(link.href, "http://nexturi", "atomReadLink, link object href field has an unexpected value");
         djstest.assertAreEqual(link.rel, "next", "atomReadLink, link object rel field has an unexpected value");
         djstest.assertAreEqual(link.type, "application/atom+xml;type=feed", "atomReadLink, link object type field has an unexpected value");
         djstest.assertAreEqual(link.extensions.length, 2, "atomReadLink, link object extensions doesn't have the expected number of extensions");

         djstest.done();

     });

     djstest.addTest(function atomReadLinkThrowHrefMissingTest() {
         var linkString = "\
         <link xmlns:me=\'http://myExtensions\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\' \r\n\
               rel=\'next\' \r\n\
               type=\'application/atom+xml;type=feed\' \r\n\
               me:attr1=\'a1\' \r\n\
               attr2=\'a2\'/> \r\n";


         var linkRoot = datajs.xmlParse(linkString).documentElement;
         djstest.expectException(function () {
             OData.atomReadLink(linkRoot);
         }, "atomReadLink didn't throw an exception when the link doesn't have the href attribute");
         djstest.done();

     });

     djstest.addTest(function atomReadExtensionElementTest() {
         var extensionString = "\
         <me:ext xmlns:me=\'http://myExtensions\' me:attr1=\'a1\' attr2=\'a2\'> \r\n\
           <ext>e1</ext> \r\n\
         </me:ext> \r\n";

         var validateExtension = function (ext, name, namespaceURI, attributeCount, childrenCount, value) {
             djstest.assertAreEqual(ext.name, name, "atomReadExtensionElement, extension object name field has an unexpected value");
             djstest.assertAreEqual(ext.namespaceURI, namespaceURI, "atomReadExtensionElement, extension object namespaceURI field has an unexpected value");
             djstest.assertAreEqual(ext.attributes.length, attributeCount, "atomReadExtensionElement, extension object attributes doesn't have the expected number of attributes");
             djstest.assertAreEqual(ext.children.length, childrenCount, "atomReadExtensionElement, extension object attributes doesn't have the expected number of children");
             djstest.assertAreEqual(ext.value, value, "atomReadExtensionElement, extension object value field has an unexpected value");
         };

         var extension = OData.atomReadExtensionElement(datajs.xmlParse(extensionString).documentElement);
         validateExtension(extension, "ext", "http://myExtensions", 2, 1);

         extension = extension.children[0];
         validateExtension(extension, "ext", null, 0, 0, "e1");

         djstest.done();
     });

     djstest.addTest(function atomReadExtensionAttributesTest() {
         var extensionString = "\
         <me:ext xmlns:me=\'http://myExtensions\' me:attr1=\'a1\' attr2=\'a2\' /> \r\n";

         var extensionAttributes = OData.atomReadExtensionAttributes(datajs.xmlParse(extensionString).documentElement);
         djstest.assertAreEqual(extensionAttributes.length, 2, "atomReadExtensionAttribute, returned collection doesn't have the expected number of attributes");
         djstest.done();
     });

     djstest.addTest(function atomReadExtensionAttributeTest() {

         var tests = {
             "extension with namespace": {
                 i: '<me:ext xmlns:me="http://myExtensions" me:attr1="a1" />',
                 e: { name: "attr1", namespaceURI: "http://myExtensions", value: "a1" }
             },
             "extension without namespace": {
                 i: '<me:ext xmlns:me="http://myExtensions" attr2="a2" />',
                 e: { name: "attr2", namespaceURI: null, value: "a2" }
             }
         };

         for (var name in tests) {
             var test = tests[name];
             var xmlElement = datajs.xmlParse(test.i).documentElement;
             var extensions = OData.atomReadExtensionAttributes(xmlElement);

             djstest.assertAreEqualDeep(extensions[0], test.e, name + " - extension object is the expected one");
         }
         djstest.done();
     });

     djstest.addTest(function atomReadEntryTest() {
         var entryString = "\
         <entry xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
                xmlns:d2=\'http://schemas.microsoft.com/ado/2007/08/dataservices\' \r\n\
                xmlns:m2=\'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\' \r\n\
                xmlns:atom=\'http://www.w3.org/2005/Atom\' \r\n\
                xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
                xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
            <id>the id</id> \r\n\
            <category term=\'the type\' \r\n\
                      scheme=\'http://schemas.microsoft.com/ado/2007/08/dataservices/scheme\' /> \r\n\
            <content type=\'application/xml\'> \r\n\
             <m2:properties xmlns=\'http://schemas.microsoft.com/ado/2007/08/dataservices\'>\r\n\
              <Untyped>untyped value</Untyped> \r\n\
              <Typed m2:type='Edm.Int32'>100</Typed> \r\n\
             </m2:properties> \r\n\
            </content> \r\n\
            <link rel=\'self\' href=\'http://selfuri\' /> \r\n\
         </entry>\r\n";

         var expectedEntry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/the id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 self: "http://selfuri",
                 self_link_extensions: [],
                 properties: {
                     Untyped: {
                         type: "Edm.String",
                         extensions: []
                     },
                     Typed: {
                         type: "Edm.Int32",
                         extensions: []
                     }
                 }
             },
             Untyped: "untyped value",
             Typed: 100
         };

         var entry = OData.atomReadEntry(datajs.xmlParse(entryString).documentElement);

         djstest.assert(entry, "atomReadEntry didn't return an entry object");
         djstest.assertAreEqualDeep(entry, expectedEntry);
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlCRSValueTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'   \r\n\
                            xmlns:gml='http://www.opengis.net/gml'>                           \r\n\
                  <PointQualified>                                                            \r\n\
                    <gml:Point gml:srsName='http://www.opengis.net/def/crs/EPSG/0/1234'>      \r\n\
                       <gml:pos>1 2 3 4</gml:pos>                                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </PointQualified>                                                           \r\n\
                  <PointUnQualified>                                                          \r\n\
                    <gml:Point srsName='http://www.opengis.net/def/crs/EPSG/0/5678'>          \r\n\
                       <gml:pos>5 6 7 8</gml:pos>                                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </PointUnQualified>                                                         \r\n\
                </m:properties>                                                               \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     PointQualified: { type: "Edm.Geometry", extensions: [] },
                     PointUnQualified: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             PointQualified: {
                 __metadata: { type: "Edm.Geometry" },
                 crs: {
                     type: "name",
                     properties: {
                         name: "EPSG:1234"
                     }
                 },
                 type: "Point",
                 coordinates: [1, 2, 3, 4]
             },
             PointUnQualified: {
                 __metadata: { type: "Edm.Geometry" },
                 crs: {
                     type: "name",
                     properties: {
                         name: "EPSG:5678"
                     }
                 },
                 type: "Point",
                 coordinates: [5, 6, 7, 8]
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlUnknownCRSValueThrowsTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'   \r\n\
                            xmlns:gml='http://www.opengis.net/gml'>                           \r\n\
                  <Point>                                                                     \r\n\
                    <gml:Point srsName='http://www.opengis.net/def/crs/EPSG/1/1234'>          \r\n\
                       <gml:pos>1 2 3 4</gml:pos>                                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </Point>                                                                     \r\n\
                </m:properties>                                                               \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         try {
             OData.atomHandler.read(response);
             djstest.fail("An exception was expected");
         } catch (e) {
             djstest.assert(e.message.indexOf("Unsupported srs name:") === 0, "Error is the expected one");
         }
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlPointValueTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'   \r\n\
                            xmlns:gml='http://www.opengis.net/gml'>                           \r\n\
                  <Point>                                                                     \r\n\
                    <gml:Point>                                                               \r\n\
                       <gml:pos>1 2 -3 4</gml:pos>                                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </Point>                                                                    \r\n\
                  <PointWithExtraTags>                                                        \r\n\
                    <gml:Point>                                                               \r\n\
                       <gml:name>the point</gml:name>                                         \r\n\
                       <gml:pos>5 6 7 8</gml:pos>                                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </PointWithExtraTags>                                                       \r\n\
                  <EmptyPoint >                                                               \r\n\
                    <gml:Point>                                                               \r\n\
                       <gml:pos/>                                                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </EmptyPoint>                                                               \r\n\
                  <PointWithSpacesInValue>                                                    \r\n\
                    <gml:Point>                                                               \r\n\
                       <gml:pos>  8  9 10   11      12 </gml:pos>                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </PointWithSpacesInValue>                                                   \r\n\
                  <PointWithSingleValue>                                                      \r\n\
                    <gml:Point>                                                               \r\n\
                       <gml:pos>13</gml:pos>                                                  \r\n\
                    </gml:Point>                                                              \r\n\
                  </PointWithSingleValue>                                                     \r\n\
                  <PointWithSingleValueAndSpaces>                                             \r\n\
                    <gml:Point>                                                               \r\n\
                       <gml:pos> 14 </gml:pos>                                                \r\n\
                    </gml:Point>                                                              \r\n\
                  </PointWithSingleValueAndSpaces>                                            \r\n\
               </m:properties>                                                                \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     Point: { type: "Edm.Geometry", extensions: [] },
                     PointWithExtraTags: { type: "Edm.Geometry", extensions: [] },
                     EmptyPoint: { type: "Edm.Geometry", extensions: [] },
                     PointWithSpacesInValue: { type: "Edm.Geometry", extensions: [] },
                     PointWithSingleValue: { type: "Edm.Geometry", extensions: [] },
                     PointWithSingleValueAndSpaces: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             Point: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Point",
                 coordinates: [1, 2, -3, 4]
             },
             PointWithExtraTags: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Point",
                 coordinates: [5, 6, 7, 8]
             },
             EmptyPoint: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Point",
                 coordinates: []
             },
             PointWithSpacesInValue: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Point",
                 coordinates: [8, 9, 10, 11, 12]
             },
             PointWithSingleValue: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Point",
                 coordinates: [13]
             },
             PointWithSingleValueAndSpaces: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Point",
                 coordinates: [14]
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlLineStringValueTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                 <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'  \r\n\
                              xmlns:gml='http://www.opengis.net/gml'>                         \r\n\
                  <LineStringExtraTags>                                                       \r\n\
                    <gml:LineString>                                                          \r\n\
                      <gml:name>the line</gml:name>                                           \r\n\
                      <gml:posList>1.0 2.0 3.0 4.0</gml:posList>                              \r\n\
                    </gml:LineString>                                                         \r\n\
                  </LineStringExtraTags>                                                      \r\n\
                  <LineStringPosList>                                                         \r\n\
                    <gml:LineString>                                                          \r\n\
                      <gml:posList>5.0 6.0 7.0 8.0</gml:posList>                              \r\n\
                    </gml:LineString>                                                         \r\n\
                  </LineStringPosList>                                                        \r\n\
                  <LineStringEmptyPosList>                                                    \r\n\
                    <gml:LineString>                                                          \r\n\
                      <gml:posList/>                                                          \r\n\
                    </gml:LineString>                                                         \r\n\
                  </LineStringEmptyPosList>                                                   \r\n\
                  <LineStringPosAndPoint>                                                     \r\n\
                    <gml:LineString>                                                          \r\n\
                      <gml:pos>7 8</gml:pos>                                                  \r\n\
                      <gml:pointProperty>                                                     \r\n\
                         <gml:Point>                                                          \r\n\
                           <gml:pos>9 10 11 12</gml:pos>                                      \r\n\
                         </gml:Point>                                                         \r\n\
                      </gml:pointProperty>                                                    \r\n\
                    </gml:LineString>                                                         \r\n\
                  </LineStringPosAndPoint>                                                    \r\n\
                  <LineStringEmptyPosAndPoint>                                                \r\n\
                    <gml:LineString>                                                          \r\n\
                      <gml:pos/>                                                              \r\n\
                      <gml:pointProperty>                                                     \r\n\
                         <gml:Point>                                                          \r\n\
                           <gml:pos/>                                                         \r\n\
                         </gml:Point>                                                         \r\n\
                      </gml:pointProperty>                                                    \r\n\
                    </gml:LineString>                                                         \r\n\
                  </LineStringEmptyPosAndPoint>                                               \r\n\
                </m:properties>                                                               \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     LineStringExtraTags: { type: "Edm.Geometry", extensions: [] },
                     LineStringPosList: { type: "Edm.Geometry", extensions: [] },
                     LineStringEmptyPosList: { type: "Edm.Geometry", extensions: [] },
                     LineStringPosAndPoint: { type: "Edm.Geometry", extensions: [] },
                     LineStringEmptyPosAndPoint: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             LineStringExtraTags: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "LineString",
                 coordinates: [[1, 2], [3, 4]]
             },
             LineStringPosList: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "LineString",
                 coordinates: [[5, 6], [7, 8]]
             },
             LineStringEmptyPosList: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "LineString",
                 coordinates: []
             },
             LineStringPosAndPoint: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "LineString",
                 coordinates: [[7, 8], [9, 10, 11, 12]]
             },
             LineStringEmptyPosAndPoint: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "LineString",
                 coordinates: [[], []]
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlLineStringValueWithOddPosListTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                 <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'  \r\n\
                              xmlns:gml='http://www.opengis.net/gml'>                         \r\n\
                  <LineString>                                                                \r\n\
                    <gml:LineString>                                                          \r\n\
                      <gml:posList>1.0 2.0 3.0</gml:posList>                                  \r\n\
                    </gml:LineString>                                                         \r\n\
                  </LineString>                                                               \r\n\
                </m:properties>                                                               \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         try {
             OData.atomHandler.read(response);
             djstest.fail("An exception was expected");
         } catch (e) {
             djstest.assertAreEqual(e.message, "GML posList element has an uneven number of numeric values");
         }
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlPolygonValueTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                 <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'  \r\n\
                              xmlns:gml='http://www.opengis.net/gml'>                         \r\n\
                  <PolygonExteriorOnly>                                                       \r\n\
                    <gml:Polygon>                                                             \r\n\
                      <gml:exterior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>1.0 2.0</gml:pos>                                          \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:exterior>                                                         \r\n\
                    </gml:Polygon>                                                            \r\n\
                  </PolygonExteriorOnly>                                                      \r\n\
                  <PolygonExteriorInterior>                                                   \r\n\
                    <gml:Polygon>                                                             \r\n\
                      <gml:exterior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>3.0 4.0</gml:pos>                                          \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:exterior>                                                         \r\n\
                      <gml:interior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>5.0 6.0</gml:pos>                                          \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:interior>                                                         \r\n\
                    </gml:Polygon>                                                            \r\n\
                  </PolygonExteriorInterior>                                                  \r\n\
                  <PolygonInteriorFirst>                                                      \r\n\
                    <gml:Polygon>                                                             \r\n\
                      <gml:interior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>9.0 10.0</gml:pos>                                         \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:interior>                                                         \r\n\
                      <gml:exterior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>11.0 12.0</gml:pos>                                        \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:exterior>                                                         \r\n\
                    </gml:Polygon>                                                            \r\n\
                  </PolygonInteriorFirst>                                                     \r\n\
                  <PolygonInteriorOnly>                                                       \r\n\
                    <gml:Polygon>                                                             \r\n\
                      <gml:interior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>13.0 14.0</gml:pos>                                        \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:interior>                                                         \r\n\
                      <gml:interior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>15.0 16.0</gml:pos>                                        \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:interior>                                                         \r\n\
                    </gml:Polygon>                                                            \r\n\
                  </PolygonInteriorOnly>                                                      \r\n\
                  <EmptyPolygon>                                                              \r\n\
                    <gml:Polygon/>                                                            \r\n\
                  </EmptyPolygon>                                                             \r\n\
                  <PolygonEmptyExteriorInterior>                                              \r\n\
                    <gml:Polygon>                                                             \r\n\
                      <gml:interior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos/>                                                          \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:interior>                                                         \r\n\
                      <gml:exterior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos/>                                                          \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:exterior>                                                         \r\n\
                    </gml:Polygon>                                                            \r\n\
                  </PolygonEmptyExteriorInterior>                                             \r\n\
                </m:properties>                                                               \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     PolygonExteriorOnly: { type: "Edm.Geometry", extensions: [] },
                     PolygonExteriorInterior: { type: "Edm.Geometry", extensions: [] },
                     PolygonInteriorFirst: { type: "Edm.Geometry", extensions: [] },
                     PolygonInteriorOnly: { type: "Edm.Geometry", extensions: [] },
                     EmptyPolygon: { type: "Edm.Geometry", extensions: [] },
                     PolygonEmptyExteriorInterior: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             PolygonExteriorOnly: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Polygon",
                 coordinates: [[[1, 2]]]
             },
             PolygonExteriorInterior: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Polygon",
                 coordinates: [[[3, 4]], [[5, 6]]]
             },
             PolygonInteriorFirst: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Polygon",
                 coordinates: [[[11, 12]], [[9, 10]]]
             },
             PolygonInteriorOnly: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Polygon",
                 coordinates: [[[]], [[13, 14]], [[15, 16]]]
             },
             EmptyPolygon: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Polygon",
                 coordinates: []
             },
             PolygonEmptyExteriorInterior: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Polygon",
                 coordinates: [[[]], [[]]]
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlMultiPointValueTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'   \r\n\
                            xmlns:gml='http://www.opengis.net/gml'>                           \r\n\
                  <EmptyMultiPoint>                                                           \r\n\
                    <gml:MultiPoint/>                                                         \r\n\
                  </EmptyMultiPoint>                                                          \r\n\
                  <MultiPoint>                                                                \r\n\
                    <gml:MultiPoint>                                                          \r\n\
                      <gml:pointMember>                                                       \r\n\
                        <gml:Point>                                                           \r\n\
                          <gml:pos>1 2</gml:pos>                                              \r\n\
                        </gml:Point>                                                          \r\n\
                      </gml:pointMember>                                                      \r\n\
                      <gml:pointMember>                                                       \r\n\
                        <gml:Point>                                                           \r\n\
                          <gml:pos>3 4</gml:pos>                                              \r\n\
                        </gml:Point>                                                          \r\n\
                      </gml:pointMember>                                                      \r\n\
                      <gml:pointMembers>                                                      \r\n\
                        <gml:Point>                                                           \r\n\
                          <gml:pos>5 6</gml:pos>                                              \r\n\
                        </gml:Point>                                                          \r\n\
                        <gml:Point>                                                           \r\n\
                          <gml:pos>7 8</gml:pos>                                              \r\n\
                        </gml:Point>                                                          \r\n\
                      </gml:pointMembers>                                                     \r\n\
                    </gml:MultiPoint>                                                         \r\n\
                  </MultiPoint>                                                               \r\n\
                  <MultiPointEmptyMembers>                                                    \r\n\
                    <gml:MultiPoint>                                                          \r\n\
                      <gml:pointMember/>                                                      \r\n\
                      <gml:pointMembers/>                                                     \r\n\
                    </gml:MultiPoint>                                                         \r\n\
                  </MultiPointEmptyMembers>                                                   \r\n\
               </m:properties>                                                                \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     EmptyMultiPoint: { type: "Edm.Geometry", extensions: [] },
                     MultiPoint: { type: "Edm.Geometry", extensions: [] },
                     MultiPointEmptyMembers: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             EmptyMultiPoint: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiPoint",
                 coordinates: []
             },
             MultiPoint: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiPoint",
                 coordinates: [[1, 2], [3, 4], [5, 6], [7, 8]]
             },
             MultiPointEmptyMembers: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiPoint",
                 coordinates: []
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlMultiListStringValueTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'   \r\n\
                            xmlns:gml='http://www.opengis.net/gml'>                           \r\n\
                  <EmptyMultiLineString>                                                      \r\n\
                    <gml:MultiCurve/>                                                         \r\n\
                  </EmptyMultiLineString>                                                     \r\n\
                  <MultiLineString>                                                           \r\n\
                    <gml:MultiCurve>                                                          \r\n\
                      <gml:name>The multi line string</gml:name>                              \r\n\
                      <gml:curveMember>                                                       \r\n\
                        <gml:LineString>                                                      \r\n\
                          <gml:posList>1 2 3 4</gml:posList>                                  \r\n\
                        </gml:LineString>                                                     \r\n\
                      </gml:curveMember>                                                      \r\n\
                      <gml:curveMember>                                                       \r\n\
                        <gml:LineString>                                                      \r\n\
                          <gml:posList>5 6 7 8</gml:posList>                                  \r\n\
                        </gml:LineString>                                                     \r\n\
                      </gml:curveMember>                                                      \r\n\
                      <gml:curveMembers>                                                      \r\n\
                        <gml:LineString>                                                      \r\n\
                          <gml:posList>9 10 11 12</gml:posList>                               \r\n\
                        </gml:LineString>                                                     \r\n\
                        <gml:LineString>                                                      \r\n\
                          <gml:posList>13 14 15 16</gml:posList>                              \r\n\
                        </gml:LineString>                                                     \r\n\
                      </gml:curveMembers>                                                     \r\n\
                    </gml:MultiCurve>                                                         \r\n\
                  </MultiLineString>                                                          \r\n\
                  <MultiLineStringEmptyMembers>                                               \r\n\
                    <gml:MultiCurve>                                                          \r\n\
                      <gml:curveMember/>                                                      \r\n\
                      <gml:curveMembers/>                                                     \r\n\
                    </gml:MultiCurve>                                                         \r\n\
                  </MultiLineStringEmptyMembers>                                              \r\n\
               </m:properties>                                                                \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     EmptyMultiLineString: { type: "Edm.Geometry", extensions: [] },
                     MultiLineString: { type: "Edm.Geometry", extensions: [] },
                     MultiLineStringEmptyMembers: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             EmptyMultiLineString: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiLineString",
                 coordinates: []
             },
             MultiLineString: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiLineString",
                 coordinates: [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]], [[13, 14], [15, 16]]]
             },
             MultiLineStringEmptyMembers: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiLineString",
                 coordinates: []
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlMultiPolygonValueTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'   \r\n\
                            xmlns:gml='http://www.opengis.net/gml'>                           \r\n\
                  <EmptyMultiPolygon>                                                         \r\n\
                    <gml:MultiSurface/>                                                       \r\n\
                  </EmptyMultiPolygon>                                                        \r\n\
                  <MultiPolygon>                                                              \r\n\
                    <gml:MultiSurface>                                                        \r\n\
                      <gml:name>The multi surface</gml:name>                                  \r\n\
                      <gml:surfaceMember>                                                     \r\n\
                        <gml:Polygon>                                                         \r\n\
                          <gml:exterior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>1 2</gml:pos>                                          \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:exterior>                                                     \r\n\
                          <gml:interior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>3 4</gml:pos>                                          \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:interior>                                                     \r\n\
                         </gml:Polygon>                                                       \r\n\
                      </gml:surfaceMember>                                                    \r\n\
                      <gml:surfaceMember>                                                     \r\n\
                        <gml:Polygon>                                                         \r\n\
                          <gml:exterior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>5 6</gml:pos>                                          \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:exterior>                                                     \r\n\
                          <gml:interior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>7 8</gml:pos>                                          \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:interior>                                                     \r\n\
                        </gml:Polygon>                                                        \r\n\
                      </gml:surfaceMember>                                                    \r\n\
                      <gml:surfaceMembers>                                                    \r\n\
                        <gml:Polygon>                                                         \r\n\
                          <gml:exterior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>9 10</gml:pos>                                         \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:exterior>                                                     \r\n\
                          <gml:interior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>11 12</gml:pos>                                        \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:interior>                                                     \r\n\
                        </gml:Polygon>                                                        \r\n\
                        <gml:Polygon>                                                         \r\n\
                          <gml:exterior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>13 14</gml:pos>                                        \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:exterior>                                                     \r\n\
                          <gml:interior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>15 16</gml:pos>                                        \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:interior>                                                     \r\n\
                        </gml:Polygon>                                                        \r\n\
                      </gml:surfaceMembers>                                                   \r\n\
                    </gml:MultiSurface>                                                       \r\n\
                  </MultiPolygon>                                                             \r\n\
                  <MultiPolygonEmptyMembers>                                                  \r\n\
                    <gml:MultiSurface>                                                        \r\n\
                      <gml:surfaceMember/>                                                    \r\n\
                      <gml:surfaceMembers/>                                                   \r\n\
                    </gml:MultiSurface>                                                       \r\n\
                  </MultiPolygonEmptyMembers>                                                 \r\n\
               </m:properties>                                                                \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     EmptyMultiPolygon: { type: "Edm.Geometry", extensions: [] },
                     MultiPolygon: { type: "Edm.Geometry", extensions: [] },
                     MultiPolygonEmptyMembers: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             EmptyMultiPolygon: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiPolygon",
                 coordinates: []
             },
             MultiPolygon: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiPolygon",
                 coordinates: [
                   [[[1, 2]], [[3, 4]]], [[[5, 6]], [[7, 8]]], [[[9, 10]], [[11, 12]]], [[[13, 14]], [[15, 16]]]
                 ]
             },
             MultiPolygonEmptyMembers: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "MultiPolygon",
                 coordinates: []
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGmlMultiGeometryValueTest() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'   \r\n\
                            xmlns:gml='http://www.opengis.net/gml'>                           \r\n\
                  <EmptyMultiGeometry>                                                        \r\n\
                    <gml:MultiGeometry/>                                                      \r\n\
                  </EmptyMultiGeometry>                                                       \r\n\
                  <MultiGeometry>                                                             \r\n\
                    <gml:MultiGeometry>                                                       \r\n\
                      <gml:geometryMember>                                                    \r\n\
                        <gml:Point>                                                           \r\n\
                          <gml:pos>1 2</gml:pos>                                              \r\n\
                        </gml:Point>                                                          \r\n\
                      </gml:geometryMember>                                                   \r\n\
                      <gml:geometryMember>                                                    \r\n\
                        <gml:Point>                                                           \r\n\
                          <gml:pos>3 4</gml:pos>                                              \r\n\
                        </gml:Point>                                                          \r\n\
                      </gml:geometryMember>                                                   \r\n\
                      <gml:geometryMembers>                                                   \r\n\
                        <gml:LineString>                                                      \r\n\
                          <gml:posList>5 6 7 8</gml:posList>                                  \r\n\
                        </gml:LineString>                                                     \r\n\
                        <gml:Polygon>                                                         \r\n\
                          <gml:exterior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>9 10</gml:pos>                                         \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:exterior>                                                     \r\n\
                        </gml:Polygon>                                                        \r\n\
                        <gml:MultiPoint>                                                      \r\n\
                          <gml:pointMember>                                                   \r\n\
                            <gml:Point>                                                       \r\n\
                              <gml:pos>11 12</gml:pos>                                        \r\n\
                            </gml:Point>                                                      \r\n\
                          </gml:pointMember>                                                  \r\n\
                        </gml:MultiPoint>                                                     \r\n\
                        <gml:MultiCurve>                                                      \r\n\
                          <gml:curveMember>                                                   \r\n\
                            <gml:LineString>                                                  \r\n\
                              <gml:posList>13 14 15 16</gml:posList>                          \r\n\
                            </gml:LineString>                                                 \r\n\
                          </gml:curveMember>                                                  \r\n\
                        </gml:MultiCurve>                                                     \r\n\
                        <gml:MultiSurface>                                                    \r\n\
                          <gml:surfaceMember>                                                 \r\n\
                            <gml:Polygon>                                                     \r\n\
                              <gml:exterior>                                                  \r\n\
                                <gml:LinearRing>                                              \r\n\
                                  <gml:pos>17 18</gml:pos>                                    \r\n\
                                </gml:LinearRing>                                             \r\n\
                              </gml:exterior>                                                 \r\n\
                              <gml:interior>                                                  \r\n\
                                <gml:LinearRing>                                              \r\n\
                                  <gml:pos>19 20</gml:pos>                                    \r\n\
                                </gml:LinearRing>                                             \r\n\
                              </gml:interior>                                                 \r\n\
                            </gml:Polygon>                                                    \r\n\
                          </gml:surfaceMember>                                                \r\n\
                        </gml:MultiSurface>                                                   \r\n\
                      </gml:geometryMembers>                                                  \r\n\
                    </gml:MultiGeometry>                                                      \r\n\
                  </MultiGeometry>                                                            \r\n\
                  <MultiGeometryEmptyMembers>                                                 \r\n\
                    <gml:MultiGeometry>                                                       \r\n\
                      <gml:geometryMember/>                                                   \r\n\
                      <gml:geometryMembers/>                                                  \r\n\
                    </gml:MultiGeometry>                                                      \r\n\
                  </MultiGeometryEmptyMembers>                                                \r\n\
                  <NestedMultiGeometry>                                                       \r\n\
                    <gml:MultiGeometry>                                                       \r\n\
                      <gml:geometryMember>                                                    \r\n\
                         <gml:MultiGeometry>                                                  \r\n\
                            <gml:geometryMember>                                              \r\n\
                              <gml:Point>                                                     \r\n\
                                <gml:pos>21 22</gml:pos>                                      \r\n\
                              </gml:Point>                                                    \r\n\
                            </gml:geometryMember>                                             \r\n\
                         </gml:MultiGeometry>                                                 \r\n\
                      </gml:geometryMember>                                                   \r\n\
                      <gml:geometryMembers>                                                   \r\n\
                         <gml:MultiGeometry>                                                  \r\n\
                            <gml:geometryMember>                                              \r\n\
                              <gml:MultiGeometry>                                             \r\n\
                                <gml:geometryMember>                                          \r\n\
                                  <gml:Point>                                                 \r\n\
                                    <gml:pos>23 24</gml:pos>                                  \r\n\
                                  </gml:Point>                                                \r\n\
                                </gml:geometryMember>                                         \r\n\
                              </gml:MultiGeometry>                                            \r\n\
                            </gml:geometryMember>                                             \r\n\
                         </gml:MultiGeometry>                                                 \r\n\
                      </gml:geometryMembers>                                                  \r\n\
                    </gml:MultiGeometry>                                                      \r\n\
                  </NestedMultiGeometry>                                                      \r\n\
               </m:properties>                                                                \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     EmptyMultiGeometry: { type: "Edm.Geometry", extensions: [] },
                     MultiGeometry: { type: "Edm.Geometry", extensions: [] },
                     MultiGeometryEmptyMembers: { type: "Edm.Geometry", extensions: [] },
                     NestedMultiGeometry: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             EmptyMultiGeometry: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "GeometryCollection",
                 geometries: []
             },
             MultiGeometry: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "GeometryCollection",
                 geometries: [
                     {
                         type: "Point",
                         coordinates: [1, 2]
                     },
                     {
                         type: "Point",
                         coordinates: [3, 4]
                     },
                     {
                         type: "LineString",
                         coordinates: [[5, 6], [7, 8]]
                     },
                     {
                         type: "Polygon",
                         coordinates: [[[9, 10]]]
                     },
                     {
                         type: "MultiPoint",
                         coordinates: [[11, 12]]
                     },
                     {
                         type: "MultiLineString",
                         coordinates: [[[13, 14], [15, 16]]]
                     },
                     {
                         type: "MultiPolygon",
                         coordinates: [[[[17, 18]], [[19, 20]]]]
                     }
                 ]
             },
             MultiGeometryEmptyMembers: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "GeometryCollection",
                 geometries: []
             },
             NestedMultiGeometry: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "GeometryCollection",
                 geometries: [
                     {
                         type: "GeometryCollection",
                         geometries: [
                             {
                                 type: "Point",
                                 coordinates: [21, 22]
                             }
                         ]
                     },
                     {
                         type: "GeometryCollection",
                         geometries: [
                             {
                                 type: "GeometryCollection",
                                 geometries: [
                                     {
                                         type: "Point",
                                         coordinates: [23, 24]
                                     }
                                 ]
                             }
                         ]
                     }
                 ]
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGeometryProperties() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                 <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'  \r\n\
                              xmlns:gml='http://www.opengis.net/gml'>                         \r\n\
                  <Point m:type='Edm.GeometryPoint'>                                          \r\n\
                    <gml:Point>                                                               \r\n\
                       <gml:pos/>                                                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </Point>                                                                    \r\n\
                  <LineString m:type='Edm.GeometryLineString'>                                \r\n\
                    <gml:LineString>                                                          \r\n\
                      <gml:posList/>                                                          \r\n\
                    </gml:LineString>                                                         \r\n\
                  </LineString>                                                               \r\n\
                  <Polygon m:type='Edm.GeometryPolygon'>                                      \r\n\
                    <gml:Polygon/>                                                            \r\n\
                  </Polygon>                                                                  \r\n\
                  <MultiPoint m:type='Edm.GeometryMultiPoint'>                                \r\n\
                    <gml:MultiPoint/>                                                         \r\n\
                  </MultiPoint>                                                               \r\n\
                  <MultiLineString m:type='Edm.GeometryMultiLineString'>                      \r\n\
                    <gml:MultiCurve/>                                                         \r\n\
                  </MultiLineString>                                                          \r\n\
                  <MultiPolygon m:type='Edm.GeometryMultiPolygon'>                            \r\n\
                    <gml:MultiSurface/>                                                       \r\n\
                  </MultiPolygon>                                                             \r\n\
                  <Collection m:type='Edm.GeometryCollection'>                                \r\n\
                    <gml:MultiGeometry/>                                                      \r\n\
                  </Collection>                                                               \r\n\
                  <Geometry m:type='Edm.Geometry'>                                            \r\n\
                    <gml:Point/>                                                              \r\n\
                  </Geometry>                                                                 \r\n\
                </m:properties>                                                               \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     Point: { type: "Edm.GeometryPoint", extensions: [] },
                     LineString: { type: "Edm.GeometryLineString", extensions: [] },
                     Polygon: { type: "Edm.GeometryPolygon", extensions: [] },
                     MultiPoint: { type: "Edm.GeometryMultiPoint", extensions: [] },
                     MultiLineString: { type: "Edm.GeometryMultiLineString", extensions: [] },
                     MultiPolygon: { type: "Edm.GeometryMultiPolygon", extensions: [] },
                     Collection: { type: "Edm.GeometryCollection", extensions: [] },
                     Geometry: { type: "Edm.Geometry", extensions: [] }
                 }
             },
             Point: {
                 __metadata: { type: "Edm.GeometryPoint" },
                 type: "Point",
                 coordinates: []
             },
             LineString: {
                 __metadata: { type: "Edm.GeometryLineString" },
                 type: "LineString",
                 coordinates: []
             },
             Polygon: {
                 __metadata: { type: "Edm.GeometryPolygon" },
                 type: "Polygon",
                 coordinates: []
             },
             MultiPoint: {
                 __metadata: { type: "Edm.GeometryMultiPoint" },
                 type: "MultiPoint",
                 coordinates: []
             },
             MultiLineString: {
                 __metadata: { type: "Edm.GeometryMultiLineString" },
                 type: "MultiLineString",
                 coordinates: []
             },
             MultiPolygon: {
                 __metadata: { type: "Edm.GeometryMultiPolygon" },
                 type: "MultiPolygon",
                 coordinates: []
             },
             Collection: {
                 __metadata: { type: "Edm.GeometryCollection" },
                 type: "GeometryCollection",
                 geometries: []
             },
             Geometry: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Point",
                 coordinates: []
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryGeographyProperties() {
         var entryXml =
             "<entry                                                                          \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata'      \r\n\
                xmlns='http://www.w3.org/2005/Atom'>                                          \r\n\
                <content type='application/xml'>                                              \r\n\
                 <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'  \r\n\
                              xmlns:gml='http://www.opengis.net/gml'>                         \r\n\
                  <Point m:type='Edm.GeographyPoint'>                                         \r\n\
                    <gml:Point>                                                               \r\n\
                       <gml:pos>1 2 3 4</gml:pos>                                             \r\n\
                    </gml:Point>                                                              \r\n\
                  </Point>                                                                    \r\n\
                  <LineString m:type='Edm.GeographyLineString'>                               \r\n\
                    <gml:LineString>                                                          \r\n\
                      <gml:pos>5 6 7</gml:pos>                                                \r\n\
                      <gml:pos>8 9 10</gml:pos>                                               \r\n\
                    </gml:LineString>                                                         \r\n\
                  </LineString>                                                               \r\n\
                  <Polygon m:type='Edm.GeographyPolygon'>                                     \r\n\
                    <gml:Polygon>                                                             \r\n\
                      <gml:exterior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>9 10</gml:pos>                                             \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:exterior>                                                         \r\n\
                      <gml:interior>                                                          \r\n\
                        <gml:LinearRing>                                                      \r\n\
                          <gml:pos>11 12</gml:pos>                                            \r\n\
                        </gml:LinearRing>                                                     \r\n\
                      </gml:interior>                                                         \r\n\
                    </gml:Polygon>                                                            \r\n\
                  </Polygon>                                                                  \r\n\
                  <MultiPoint m:type='Edm.GeographyMultiPoint'>                               \r\n\
                    <gml:MultiPoint>                                                          \r\n\
                      <gml:pointMember>                                                       \r\n\
                        <gml:Point>                                                           \r\n\
                           <gml:pos>13 14</gml:pos>                                           \r\n\
                        </gml:Point>                                                          \r\n\
                      </gml:pointMember>                                                      \r\n\
                    </gml:MultiPoint>                                                         \r\n\
                  </MultiPoint>                                                               \r\n\
                  <MultiLineString m:type='Edm.GeographyMultiLineString'>                     \r\n\
                    <gml:MultiCurve>                                                          \r\n\
                      <gml:curveMember>                                                       \r\n\
                        <gml:LineString>                                                      \r\n\
                          <gml:posList>15 16 17 18</gml:posList>                              \r\n\
                        </gml:LineString>                                                     \r\n\
                      </gml:curveMember>                                                      \r\n\
                    </gml:MultiCurve>                                                         \r\n\
                  </MultiLineString>                                                          \r\n\
                  <MultiPolygon m:type='Edm.GeographyMultiPolygon'>                           \r\n\
                    <gml:MultiSurface>                                                        \r\n\
                      <gml:surfaceMember>                                                     \r\n\
                        <gml:Polygon>                                                         \r\n\
                          <gml:exterior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>17 18</gml:pos>                                        \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:exterior>                                                     \r\n\
                          <gml:interior>                                                      \r\n\
                            <gml:LinearRing>                                                  \r\n\
                              <gml:pos>19 20</gml:pos>                                        \r\n\
                            </gml:LinearRing>                                                 \r\n\
                          </gml:interior>                                                     \r\n\
                        </gml:Polygon>                                                        \r\n\
                      </gml:surfaceMember>                                                    \r\n\
                    </gml:MultiSurface>                                                       \r\n\
                  </MultiPolygon>                                                             \r\n\
                  <Collection m:type='Edm.GeographyCollection'>                               \r\n\
                    <gml:MultiGeometry>                                                       \r\n\
                      <gml:geometryMember>                                                    \r\n\
                         <gml:MultiGeometry>                                                  \r\n\
                            <gml:geometryMember>                                              \r\n\
                              <gml:Point>                                                     \r\n\
                                <gml:pos>21 22</gml:pos>                                      \r\n\
                              </gml:Point>                                                    \r\n\
                            </gml:geometryMember>                                             \r\n\
                         </gml:MultiGeometry>                                                 \r\n\
                      </gml:geometryMember>                                                   \r\n\
                      <gml:geometryMembers>                                                   \r\n\
                         <gml:MultiGeometry>                                                  \r\n\
                            <gml:geometryMember>                                              \r\n\
                              <gml:MultiGeometry>                                             \r\n\
                                <gml:geometryMember>                                          \r\n\
                                  <gml:Point>                                                 \r\n\
                                    <gml:pos>23 24</gml:pos>                                  \r\n\
                                  </gml:Point>                                                \r\n\
                                </gml:geometryMember>                                         \r\n\
                              </gml:MultiGeometry>                                            \r\n\
                            </gml:geometryMember>                                             \r\n\
                         </gml:MultiGeometry>                                                 \r\n\
                      </gml:geometryMembers>                                                  \r\n\
                    </gml:MultiGeometry>                                                      \r\n\
                  </Collection>                                                               \r\n\
                  <Geography m:type='Edm.Geography'>                                          \r\n\
                    <gml:Point>                                                               \r\n\
                      <gml:pos>25 26</gml:pos>                                                \r\n\
                    </gml:Point>                                                              \r\n\
                  </Geography>                                                                \r\n\
                </m:properties>                                                               \r\n\
               </content>                                                                     \r\n\
             </entry>";

         var entry = {
             __metadata: {
                 properties: {
                     Point: { type: "Edm.GeographyPoint", extensions: [] },
                     LineString: { type: "Edm.GeographyLineString", extensions: [] },
                     Polygon: { type: "Edm.GeographyPolygon", extensions: [] },
                     MultiPoint: { type: "Edm.GeographyMultiPoint", extensions: [] },
                     MultiLineString: { type: "Edm.GeographyMultiLineString", extensions: [] },
                     MultiPolygon: { type: "Edm.GeographyMultiPolygon", extensions: [] },
                     Collection: { type: "Edm.GeographyCollection", extensions: [] },
                     Geography: { type: "Edm.Geography", extensions: [] }
                 }
             },
             Point: {
                 __metadata: { type: "Edm.GeographyPoint" },
                 type: "Point",
                 coordinates: [2, 1, 3, 4]
             },
             LineString: {
                 __metadata: { type: "Edm.GeographyLineString" },
                 type: "LineString",
                 coordinates: [[6, 5, 7], [9, 8, 10]]
             },
             Polygon: {
                 __metadata: { type: "Edm.GeographyPolygon" },
                 type: "Polygon",
                 coordinates: [[[10, 9]], [[12, 11]]]
             },
             MultiPoint: {
                 __metadata: { type: "Edm.GeographyMultiPoint" },
                 type: "MultiPoint",
                 coordinates: [[14, 13]]
             },
             MultiLineString: {
                 __metadata: { type: "Edm.GeographyMultiLineString" },
                 type: "MultiLineString",
                 coordinates: [[[16, 15], [18, 17]]]
             },
             MultiPolygon: {
                 __metadata: { type: "Edm.GeographyMultiPolygon" },
                 type: "MultiPolygon",
                 coordinates: [[[[18, 17]], [[20, 19]]]]
             },
             Collection: {
                 __metadata: { type: "Edm.GeographyCollection" },
                 type: "GeometryCollection",
                 geometries: [
                     {
                         type: "GeometryCollection",
                         geometries: [
                             {
                                 type: "Point",
                                 coordinates: [22, 21]
                             }
                         ]
                     },
                     {
                         type: "GeometryCollection",
                         geometries: [
                             {
                                 type: "GeometryCollection",
                                 geometries: [
                                     {
                                         type: "Point",
                                         coordinates: [24, 23]
                                     }
                                 ]
                             }
                         ]
                     }
                 ]
             },
             Geography: {
                 __metadata: { type: "Edm.Geography" },
                 type: "Point",
                 coordinates: [26, 25]
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, entry, "Entry was read successfully");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryMediaLinkEntryTest() {
         var entryString = "\
         <entry xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
                xmlns:m=\'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\' \r\n\
                xmlns:atom=\'http://www.w3.org/2005/Atom\' \r\n\
                xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
                xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
            <id>the id</id> \r\n\
            <link m:etag=\'etag\' rel=\'edit-media\' href=\'http://editmediauri\' /> \r\n\
            <content type=\'application/png\' src=\'mediaSource/source.png' /> \r\n\
            <m:properties xmlns=\'http://schemas.microsoft.com/ado/2007/08/dataservices\'>\r\n\
              <Untyped>untyped value</Untyped> \r\n\
              <Typed m:type='Edm.Int32'>100</Typed> \r\n\
            </m:properties> \r\n\
         </entry>\r\n";

         var expectedEntry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/the id",
                 uri_extensions: [],
                 media_src: "http://services.odata.org/OData/OData.svc/mediaSource/source.png",
                 content_type: "application/png",
                 edit_media: "http://editmediauri",
                 edit_media_extensions: [],
                 media_etag: "etag",
                 properties: {
                     Untyped: {
                         type: "Edm.String",
                         extensions: []
                     },
                     Typed: {
                         type: "Edm.Int32",
                         extensions: []
                     }
                 }
             },
             Untyped: "untyped value",
             Typed: 100
         };

         var entry = OData.atomReadEntry(datajs.xmlParse(entryString).documentElement);

         djstest.assert(entry, "atomReadFeed didn't return an entry object for the media link entry payload");
         djstest.assertAreEqualDeep(entry, expectedEntry);
         djstest.done();
     });

     djstest.addTest(function atomReadEntryTypeTest() {
         var categoryString = "\
         <category term=\'the type\' \r\n\
                   scheme=\'http://schemas.microsoft.com/ado/2007/08/dataservices/scheme\' \r\n\
                   attr1=\'a1\' me:attr2=\'a2\' \r\n\
                   xmlns:me=\'http//:myExtensions\' \r\n\
                   xmlns=\'http://www.w3.org/2005/Atom\'/> \r\n";
         var entryMetadata = {};
         OData.atomReadEntryType(datajs.xmlParse(categoryString).documentElement, entryMetadata);

         djstest.assertAreEqual(entryMetadata.type, "the type", "atomReadEntryType, entry type has an unexpected value");
         djstest.assertAreEqual(entryMetadata.type_extensions.length, 2, "readATomEntryType, entry type_extensions doens't have the expected number of extensions");

         djstest.done();
     });

     djstest.addTest(function atomReadEntryTypeIgnoresCategoryTest() {
         var categoryString = "\
         <category term=\'the type\' \r\n\
                   attr1=\'a1\' me:attr2=\'a2\' \r\n\
                   xmlns:me=\'http//:myExtensions\' \r\n\
                   xmlns=\'http://www.w3.org/2005/Atom\'/> \r\n";

         var entry = { __metadata: {} };
         OData.atomReadEntryType(datajs.xmlParse(categoryString).documentElement, entry, entry.__metadata);

         djstest.assert(!entry.__metadata.type, "atomReadEntryType, processed a category of without a scheme attribute!!");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryTypeThrowsWithMultipleCategoryTest() {
         var categoryString = "\
          <entry> \r\n\
             <category term=\'the type\' \r\n\
                       scheme=\'http://schemas.microsoft.com/ado/2007/08/dataservices/scheme\' \r\n\
                       xmlns=\'http://www.w3.org/2005/Atom\'/> \r\n\
             <category term=\'the type\' \r\n\
                       scheme=\'http://schemas.microsoft.com/ado/2007/08/dataservices/scheme\' \r\n\
                       xmlns=\'http://www.w3.org/2005/Atom\'/> \r\n\
          </entry> \r\n";

         var entry = { __metadata: {} };

         djstest.expectException(function () {
             var categories = datajs.xmlParse(categoryString).documentElement;
             datajs.xmlChildElements(categories, function (child) {
                 OData.atomReadEntryType(child, entry, entry.__metadata);
             });
         }, "atomReadEntryType didn't throw the expected exception");

         djstest.done();
     });

     djstest.addTest(function atomReadEntryContentThrowsWithNoTypeAttributeTest() {
         var contentString = "\
             <content src=\'http://mediasource\' xmlns=\'http://www.w3.org/2005/Atom\'/> \r\n"

         var entry = { __metadata: {} };
         var content = datajs.xmlParse(contentString).documentElement;
         djstest.expectException(function () {
             OData.atomReadEntryContent(content, entry);
         }, "atomReadEntryContent didn't throw the expected exception");

         djstest.done();
     });

     djstest.addTest(function atomReadEntryContentThrowsWithSrcAndChildrenTest() {
         var contentString = "\
             <content type=\'applicaton/xml\' src=\'http://mediasource\' \r\n\
                      xmlns=\'http://www.w3.org/2005/Atom\' \r\n\
                      xmlns:m2=\'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\'> \r\n\
               <m2:properties xmlns=\'http://schemas.microsoft.com/ado/2007/08/dataservices\'>\r\n\
                 <Untyped>untyped value</Untyped> \r\n\
                 <Typed m2:type='Edm.Int32'>100</Typed> \r\n\
               </m2:properties> \r\n\
            </content> \r\n";

         var entry = { __metadata: {} };
         var content = datajs.xmlParse(contentString).documentElement;
         djstest.expectException(function () {
             OData.atomReadEntryContent(content, entry);
         }, "atomReadEntryContent didn't throw the expected exception");

         djstest.done();
     });

     djstest.addTest(function atomReadEntryEditMediaLinkTest() {
         var linkString = "\
         <link m:etag=\'etag\' rel=\'edit-media\' href=\'http://editmediauri\' \r\n\
               attr1=\'a1\' me:attr2=\'a2\' \r\n\
               xmlns:me=\'http://myExtensions\' \r\n\
               xmlns:m=\'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\' \r\n\
               xmlns=\'http://www.w3.org/2005/Atom\'/> \r\n";

         var entry = { __metadata: {} };

         OData.atomReadEntryLink(datajs.xmlParse(linkString).documentElement, entry, entry.__metadata);

         djstest.assertAreEqual(entry.__metadata.edit_media, "http://editmediauri", "edit_media field has a un expected value");
         djstest.assertAreEqual(entry.__metadata.media_etag, "etag", "media_etag field has a un expected value");
         djstest.assertAreEqual(entry.__metadata.edit_media_extensions.length, 2, "edit_media_extensions doesn't have the expected number of extensions");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryLink() {
         var linksString = "\
         <entry xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
          <link rel=\'edit-media\' href=\'http://editmediauri\' />\r\n\
          <link rel=\'edit\' href=\'http://edituri\' />\r\n\
          <link rel=\'self\' href=\'http://selfuri\' />\r\n\
          <link rel=\'http://schemas.microsoft.com/ado/2007/08/dataservices/related/otherEntry\' \r\n\
                type=\'application/atom+xml;type=entry\' \r\n\
                href=\'http://otherEntryuri\' /> \r\n\
         </entry> \r\n";

         var expectedEntry = {
             __metadata: {
                 edit: "http://edituri",
                 edit_link_extensions: [],
                 edit_media: "http://editmediauri",
                 edit_media_extensions: [],
                 self: "http://selfuri",
                 self_link_extensions: [],
                 properties: {
                     otherEntry: {
                         extensions: []
                     }
                 }
             },
             otherEntry: {
                 __deferred: { uri: "http://otherEntryuri" }
             }
         };

         var entry = { __metadata: {} };
         var links = datajs.xmlParse(linksString).documentElement;
         datajs.xmlChildElements(links, function (child) {
             OData.atomReadEntryLink(child, entry, entry.__metadata);
         });

         djstest.assertAreEqualDeep(entry, expectedEntry);
         djstest.done();
     });

     djstest.addTest(function atomReadEntryNavigationPropertyTest() {
         var entryString = "\
         <entry xml:base='http://baseuri.org/' \r\n\
                xmlns='http://www.w3.org/2005/Atom' \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata' \r\n\
                xmlns:me='http://myextensions'> \r\n\
           <link rel='http://schemas.microsoft.com/ado/2007/08/dataservices/related/deferred' \r\n\
                 type='application/atom+xml;type=entry' \r\n\
                 href='entry/deferred' /> \r\n\
           <link rel='http://schemas.microsoft.com/ado/2007/08/dataservices/relatedlinks/deferred' \r\n\
                 type='application/xml' \r\n\
                 href='entry/deferred/$links' \r\n\
                 me:ext1='value1' /> \r\n\
           <link rel='http://schemas.microsoft.com/ado/2007/08/dataservices/related/inline' \r\n\
                 type='application/atom+xml;type=feed' \r\n\
                 href='http://inline' > \r\n\
             <m:inline> \r\n\
                 <feed xml:base='http://services.odata.org/OData/OData.svc/' \r\n\
                       xmlns:app='http://www.w3.org/2007/app' \r\n\
                       xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata' \r\n\
                       xmlns='http://www.w3.org/2005/Atom'> \r\n\
                   <id>feed id</id> \r\n\
                   <title>test feed</title> \r\n\
                 </feed> \r\n\
            </m:inline> \r\n\
          </link> \r\n\
           <content type='application/xml'> \r\n\
            <m:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'>\r\n\
                <Typed m:type='Edm.Int32'>100</Typed> \r\n\
            </m:properties> \r\n\
          </content> \r\n\
        </entry> \r\n";

         var expectedEntry = {
             __metadata: {
                 properties: {
                     deferred: {
                         associationuri: "http://baseuri.org/entry/deferred/$links",
                         associationuri_extensions: [{ name: "ext1", namespaceURI: "http://myextensions", value: "value1"}],
                         extensions: []
                     },
                     inline: {
                         extensions: []
                     },
                     Typed: {
                         type: "Edm.Int32",
                         extensions: []
                     }
                 }
             },
             deferred: {
                 __deferred: { uri: "http://baseuri.org/entry/deferred" }
             },
             inline: {
                 __metadata: {
                     uri: "http://services.odata.org/OData/OData.svc/feed id",
                     uri_extensions: [],
                     title: "test feed",
                     title_extensions: [],
                     feed_extensions: []
                 },
                 results: []
             },
             Typed: 100
         };

         var entry = OData.atomReadEntry(datajs.xmlParse(entryString).documentElement);

         djstest.assertAreEqualDeep(entry, expectedEntry);
         djstest.done();
     });

     djstest.addTest(function atomReadEntryStructuralObjectTest() {
         var content = "\
            <d:Data m:type = \"Data\" \r\n \
                       xmlns:d=\"http://schemas.microsoft.com/ado/2007/08/dataservices\" \r\n \
                       xmlns:m=\"http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\">\r\n \
                <d:Complex m:type=\"Complex\">\r\n \
                    <d:Property1>value 1</d:Property1>\r\n \
                    <d:Property2>value 2</d:Property2> \r\n \
                    <d:Nested m:type=\"Complex.Nested\">\r\n \
                        <d:NestedProperty1>value 3</d:NestedProperty1> \r\n \
                        <d:NestedProperty2>value 4</d:NestedProperty2> \r\n \
                        <d:NestedProperty3>value 5</d:NestedProperty3> \r\n \
                    </d:Nested>\r\n \
                </d:Complex>\r\n \
            </d:Data>\r\n";

         var dataElement = datajs.xmlParse(content).documentElement;
         var data = {};
         var metadata = {};

         OData.atomReadEntryStructuralObject(dataElement, data, metadata);

         var expectedData = {
             Complex: {
                 __metadata: { type: "Complex" },
                 Property1: "value 1",
                 Property2: "value 2",
                 Nested: {
                     __metadata: { type: "Complex.Nested" },
                     NestedProperty1: "value 3",
                     NestedProperty2: "value 4",
                     NestedProperty3: "value 5"
                 }
             }
         };

         var expectedMetadata = {
             properties: {
                 Complex: {
                     type: "Complex",
                     extensions: [],
                     properties: {
                         Property1: { type: "Edm.String", extensions: [] },
                         Property2: { type: "Edm.String", extensions: [] },
                         Nested: {
                             type: "Complex.Nested",
                             extensions: [],
                             properties: {
                                 NestedProperty1: { type: "Edm.String", extensions: [] },
                                 NestedProperty2: { type: "Edm.String", extensions: [] },
                                 NestedProperty3: { type: "Edm.String", extensions: [] }
                             }
                         }
                     }
                 }
             }
         };

         djstest.assertAreEqualDeep(data, expectedData, "atomReadEntryComplexProperty didn't returned the expected data for a complex property");
         djstest.assertAreEqualDeep(metadata, expectedMetadata, "atomReadEntryComplexProperty didn't returned the expected metadata for a complex property");
         djstest.done();
     });

     djstest.addTest(function atomReadEntryWithComplexTypePropertiesTest() {
         var entryString = "\
         <entry xml:base=\'http://services.odata.org/OData/OData.svc/\' \r\n\
                xmlns:m2=\'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\' \r\n\
                xmlns:atom=\'http://www.w3.org/2005/Atom\' \r\n\
                xmlns:app=\'http://www.w3.org/2007/app\' \r\n\
                xmlns=\'http://www.w3.org/2005/Atom\'> \r\n\
            <id>the id</id> \r\n\
            <category term=\'the type\' \r\n\
                      scheme=\'http://schemas.microsoft.com/ado/2007/08/dataservices/scheme\' /> \r\n\
            <content type=\'application/xml\'> \r\n\
             <m2:properties xmlns=\'http://schemas.microsoft.com/ado/2007/08/dataservices\'>\r\n\
               <Untyped>untyped value</Untyped> \r\n\
               <Typed m2:type='Edm.Int32'>100</Typed> \r\n\
               <Complex m2:type=\"Complex\">\r\n \
                    <Property1>value 1</Property1>\r\n \
                    <Property2>value 2</Property2> \r\n \
                    <Nested m2:type=\"Complex.Nested\">\r\n \
                        <NestedProperty1>value 3</NestedProperty1> \r\n \
                        <NestedProperty2>value 4</NestedProperty2> \r\n \
                        <NestedProperty3>value 5</NestedProperty3> \r\n \
                    </Nested>\r\n \
                </Complex>\r\n \
                <UntypedComplex>\r\n\
                    <P1>value 3</P1>\r\n\
                </UntypedComplex>\r\n\
            </m2:properties> \r\n\
           </content> \r\n\
          <link rel=\'self\' href=\'http://selfuri\' /> \r\n\
         </entry>\r\n";

         var expectedEntry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/the id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 self: "http://selfuri",
                 self_link_extensions: [],
                 properties: {
                     Untyped: {
                         type: "Edm.String",
                         extensions: []
                     },
                     Typed: {
                         type: "Edm.Int32",
                         extensions: []
                     },
                     Complex: {
                         type: "Complex",
                         extensions: [],
                         properties: {
                             Property1: { type: "Edm.String", extensions: [] },
                             Property2: { type: "Edm.String", extensions: [] },
                             Nested: {
                                 type: "Complex.Nested",
                                 extensions: [],
                                 properties: {
                                     NestedProperty1: { type: "Edm.String", extensions: [] },
                                     NestedProperty2: { type: "Edm.String", extensions: [] },
                                     NestedProperty3: { type: "Edm.String", extensions: [] }
                                 }
                             }
                         }
                     },
                     UntypedComplex: {
                         type: null,
                         extensions: [],
                         properties: {
                             P1: { type: "Edm.String", extensions: [] }
                         }
                     }
                 }
             },
             Untyped: "untyped value",
             Typed: 100,
             Complex: {
                 __metadata: { type: "Complex" },
                 Property1: "value 1",
                 Property2: "value 2",
                 Nested: {
                     __metadata: { type: "Complex.Nested" },
                     NestedProperty1: "value 3",
                     NestedProperty2: "value 4",
                     NestedProperty3: "value 5"
                 }
             },
             UntypedComplex: {
                 __metadata: { type: null },
                 P1: "value 3"
             }
         };

         var entry = OData.atomReadEntry(datajs.xmlParse(entryString).documentElement);

         djstest.assert(entry, "atomReadEntry didn't return an entry object");
         djstest.assertAreEqualDeep(entry, expectedEntry, "atomReadEntry didn't return the expected entry object");
         djstest.done();
     });


     djstest.addTest(function atomReadEntryWithActionsAndFunctionsTest() {
         var entryString = "\
         <entry xml:base='http://services.odata.org/OData/OData.svc/' \r\n\
                xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata' \r\n\
                xmlns:me='http://myExtensions' \r\n\
                xmlns:atom='http://www.w3.org/2005/Atom' \r\n\
                xmlns:app='http://www.w3.org/2007/app' \r\n\
                xmlns='http://www.w3.org/2005/Atom'> \r\n\
            <id>the id</id> \r\n\
            <category term='the type' scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme' /> \r\n\
            <content type='application/xml' /> \r\n\
            <m:action metadata='#EntityContainer.Action1' title='Action1' target='http://service/entities(0)/action' /> \r\n\
            <m:action metadata='#EntityContainer.Action2' title='Action2' target='entities(0)/action2' /> \r\n\
            <m:action metadata='http://someService/$metadata#Container.Action1' title='Action1' target='http://someService/action' /> \r\n\
            <m:function metadata='#EntityContainer.Function1' title='Function1' target='http://service/entities(0)/function' /> \r\n\
            <m:function metadata='#EntityContainer.Function2' title='Function2' target='entities(0)/function2' /> \r\n\
            <m:function metadata='http://someService/$metadata#Container.Function1' title='Function1' target='http://someService/function' /> \r\n\
         </entry>\r\n";

         var expected = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/the id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 actions: [
                     {
                         metadata: "#EntityContainer.Action1",
                         title: "Action1",
                         target: "http://service/entities(0)/action",
                         extensions: []
                     },
                     {
                         metadata: "#EntityContainer.Action2",
                         title: "Action2",
                         target: "http://services.odata.org/OData/OData.svc/entities(0)/action2",
                         extensions: []
                     },
                     {
                         metadata: "http://someService/$metadata#Container.Action1",
                         title: "Action1",
                         target: "http://someService/action",
                         extensions: []
                     }
                 ],
                 functions: [
                     {
                         metadata: "#EntityContainer.Function1",
                         title: "Function1",
                         target: "http://service/entities(0)/function",
                         extensions: []
                     },
                     {
                         metadata: "#EntityContainer.Function2",
                         title: "Function2",
                         target: "http://services.odata.org/OData/OData.svc/entities(0)/function2",
                         extensions: []
                     },
                     {
                         metadata: "http://someService/$metadata#Container.Function1",
                         title: "Function1",
                         target: "http://someService/function",
                         extensions: []
                     }
                 ]
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" }, body: entryString };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, expected, "atomReadEntry didn't return the expected entry object");
         djstest.done();

     });

     djstest.addTest(function atomReadEntryWithNamedStreamsTest() {
         var entryString = "\
         <entry xml:base='http://services.odata.org/OData/OData.svc/' \r\n\
                xmlns:m2='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata' \r\n\
                xmlns:me='http://myExtensions' \r\n\
                xmlns:atom='http://www.w3.org/2005/Atom' \r\n\
                xmlns:app='http://www.w3.org/2007/app' \r\n\
                xmlns='http://www.w3.org/2005/Atom'> \r\n\
            <id>the id</id> \r\n\
            <category term='the type' scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme' /> \r\n\
            <content type='application/xml' /> \r\n\
            <link rel='http://schemas.microsoft.com/ado/2007/08/dataservices/mediaresource/readonly' href='readonly' type='image/png' me:ext1='value1' /> \r\n\
            <link rel='http://schemas.microsoft.com/ado/2007/08/dataservices/mediaresource/readwrite' href='http://readwrite' type='image/gif' me:ext2='value2' /> \r\n\
            <link rel='http://schemas.microsoft.com/ado/2007/08/dataservices/edit-media/readwrite' href='http://readwrite/update' type='image/gif' m2:etag='etag0' me:ext3='value3' /> \r\n\
            <link rel='http://schemas.microsoft.com/ado/2007/08/dataservices/edit-media/writeonly' href='writeonly' type='image/jpeg' m2:etag='etag1' me:ext4='value4' /> \r\n\
         </entry>\r\n";

         var expected = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/the id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 properties: {
                     readonly: {
                         media_src_extensions: [
                             { name: "ext1", namespaceURI: "http://myExtensions", value: "value1" }
                         ]
                     },
                     readwrite: {
                         media_src_extensions: [
                             { name: "ext2", namespaceURI: "http://myExtensions", value: "value2" }
                         ],
                         edit_media_extensions: [
                             { name: "ext3", namespaceURI: "http://myExtensions", value: "value3" }
                         ]
                     },
                     writeonly: {
                         media_src_extensions: [],
                         edit_media_extensions: [
                             { name: "ext4", namespaceURI: "http://myExtensions", value: "value4" }
                         ]
                     }
                 }
             },
             readonly: {
                 __mediaresource: {
                     media_src: "http://services.odata.org/OData/OData.svc/readonly",
                     content_type: "image/png"
                 }
             },
             readwrite: {
                 __mediaresource: {
                     media_src: "http://readwrite",
                     edit_media: "http://readwrite/update",
                     content_type: "image/gif",
                     media_etag: "etag0"
                 }
             },
             writeonly: {
                 __mediaresource: {
                     media_src: "http://services.odata.org/OData/OData.svc/writeonly",
                     edit_media: "http://services.odata.org/OData/OData.svc/writeonly",
                     content_type: "image/jpeg",
                     media_etag: "etag1"
                 }
             }
         };

         var response = { headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" }, body: entryString };

         OData.atomHandler.read(response);
         djstest.assertAreEqualDeep(response.data, expected, "atomReadEntry didn't return the expected entry object");
         djstest.done();
     });


     djstest.addTest(function atomReadEntryWithCollectionPropertiesTest() {
         var entryString = "\
         <entry xml:base='http://services.odata.org/OData/OData.svc/' \r\n\
                xmlns:m2='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata\' \r\n\
                xmlns:me=\'http://myExtensions' \r\n\
                xmlns:atom='http://www.w3.org/2005/Atom' \r\n\
                xmlns:app='http://www.w3.org/2007/app' \r\n\
                xmlns='http://www.w3.org/2005/Atom'> \r\n\
            <id>the id</id> \r\n\
            <category term='the type' \r\n\
                      scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme' /> \r\n\
            <content type='application/xml'> \r\n\
             <m2:properties xmlns='http://schemas.microsoft.com/ado/2007/08/dataservices'>\r\n\
               <Empty m2:type='Collection(Edm.Int32)' me:attr1='value1' /> \r\n\
               <Primitive m2:type='Collection(Edm.Int32)'> \r\n\
                   <element>50</element> \r\n\
                   <element me:attr2='value2'>100</element> \r\n\
               </Primitive>  \r\n\
               <Complex m2:type='Collection(ns.MyType)' me:attr3='value3'> \r\n\
                   <element me:attr4='value4'> \r\n\
                       <Property1>value 1</Property1> \r\n\
                       <Property2>value 2</Property2> \r\n\
                   </element> \r\n\
                   <element> \r\n\
                       <Property1>value 3</Property1> \r\n\
                       <Property2>value 4</Property2> \r\n\
                  </element> \r\n\
               </Complex> \r\n\
               <SingleTyped m2:type='Collection(Edm.Int32)'> \r\n\
                  <element>500</element> \r\n\
               </SingleTyped> \r\n\
               <SingleUntyped> \r\n\
                  <element>600</element> \r\n\
               </SingleUntyped> \r\n\
            </m2:properties> \r\n\
           </content> \r\n\
          <link rel=\'self\' href=\'http://selfuri\' /> \r\n\
         </entry>\r\n";

         var expectedEntry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/the id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 self: "http://selfuri",
                 self_link_extensions: [],
                 properties: {
                     Empty: {
                         type: "Collection(Edm.Int32)",
                         extensions: [
                             { name: "attr1", namespaceURI: "http://myExtensions", value: "value1" }
                         ],
                         elements: []
                     },
                     Primitive: {
                         type: "Collection(Edm.Int32)",
                         extensions: [],
                         elements: [
                             { type: "Edm.Int32", extensions: [] },
                             {
                                 type: "Edm.Int32",
                                 extensions: [
                                  { name: "attr2", namespaceURI: "http://myExtensions", value: "value2" }
                               ]
                             }
                         ]
                     },
                     Complex: {
                         type: "Collection(ns.MyType)",
                         extensions: [
                             { name: "attr3", namespaceURI: "http://myExtensions", value: "value3" }
                         ],
                         elements: [
                             {
                                 type: "ns.MyType",
                                 extensions: [
                                   { name: "attr4", namespaceURI: "http://myExtensions", value: "value4" }
                                 ],
                                 properties: {
                                     Property1: { type: "Edm.String", extensions: [] },
                                     Property2: { type: "Edm.String", extensions: [] }
                                 }
                             },
                             {
                                 type: "ns.MyType",
                                 extensions: [],
                                 properties: {
                                     Property1: { type: "Edm.String", extensions: [] },
                                     Property2: { type: "Edm.String", extensions: [] }
                                 }
                             }
                         ]
                     },
                     SingleTyped: {
                         type: "Collection(Edm.Int32)",
                         extensions: [],
                         elements: [
                             {
                                 type: "Edm.Int32",
                                 extensions: []
                             }
                         ]
                     },
                     SingleUntyped: {
                         type: null,
                         extensions: [],
                         properties: {
                             element: {
                                 type: "Edm.String",
                                 extensions: []
                             }
                         }
                     }
                 }
             },
             Empty: {
                 __metadata: { type: "Collection(Edm.Int32)" },
                 results: []
             },
             Primitive: {
                 __metadata: { type: "Collection(Edm.Int32)" },
                 results: [50, 100]
             },
             Complex: {
                 __metadata: { type: "Collection(ns.MyType)" },
                 results: [
                     {
                         __metadata: { type: "ns.MyType" },
                         Property1: "value 1",
                         Property2: "value 2"
                     },
                     {
                         __metadata: { type: "ns.MyType" },
                         Property1: "value 3",
                         Property2: "value 4"
                     }
                 ]
             },
             SingleTyped: {
                 __metadata: { type: "Collection(Edm.Int32)" },
                 results: [500]
             },
             SingleUntyped: {
                 __metadata: { type: null },
                 element: "600"
             }
         };

         // Todo refactor all this tests to use the mock http client instead.
         var entry = OData.atomReadEntry(datajs.xmlParse(entryString).documentElement);

         djstest.assert(entry, "atomReadEntry didn't return an entry object");
         djstest.assertAreEqualDeep(entry, expectedEntry, "atomReadEntry didn't return the expected entry object");
         djstest.done();
     });

     djstest.addTest(function atomSerializeFeedTest() {
         var feed = {
             __metadata: {
                 feed_extensions: []
             },
             results: [
                 { __metadata: {
                     uri: "http://services.odata.org/OData/OData.svc/entry id",
                     uri_extensions: [],
                     type: "the type",
                     type_extensions: [],
                     properties: {
                         Untyped: {
                             type: "Edm.String",
                             extensions: []
                         },
                         Typed: {
                             type: "Edm.Int32",
                             extensions: []
                         }
                     }
                 },
                     Untyped: "untyped value",
                     Typed: 100
                 }
            ]
         };

         var feedXml = OData.atomSerializer(OData.atomHandler, feed, {});

         window.ODataReadOracle.readFeedLoopback(feedXml,
                 function (expectedData) {
                     djstest.assertAreEqualDeep(feed, expectedData, "Response data not same as expected");
                     djstest.done();
                 });
     });

     djstest.addTest(function atomSerializeEntryTest() {
         var entry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/entry id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 properties: {
                     Untyped: {
                         type: "Edm.String",
                         extensions: []
                     },
                     Typed: {
                         type: "Edm.Int32",
                         extensions: []
                     }
                 }
             },
             Untyped: "untyped value",
             Typed: 100
         };

         var entryXml = OData.atomSerializer(OData.atomHandler, entry, {});

         window.ODataReadOracle.readEntryLoopback(entryXml,
         function (expectedData) {
             djstest.assertAreEqualDeep(entry, expectedData, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeEntryWithNamedStreamsTest() {
         var entry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/entry id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 properties: {
                     readonly: {
                         media_src_extensions: [
                             { name: "ext1", namespaceURI: "http://myExtensions", value: "value1" }
                         ]
                     },
                     readwrite: {
                         media_src_extensions: [
                             { name: "ext2", namespaceURI: "http://myExtensions", value: "value2" }
                         ],
                         edit_media_extensions: [
                             { name: "ext3", namespaceURI: "http://myExtensions", value: "value3" }
                         ]
                     },
                     writeonly: {
                         media_src_extensions: [],
                         edit_media_extensions: [
                             { name: "ext4", namespaceURI: "http://myExtensions", value: "value4" }
                         ]
                     }
                 }
             },
             readonly: {
                 __mediaresource: {
                     media_src: "http://services.odata.org/OData/OData.svc/readonly",
                     content_type: "image/png"
                 }
             },
             readwrite: {
                 __mediaresource: {
                     media_src: "http://readwrite",
                     edit_media: "http://readwrite/update",
                     content_type: "image/gif",
                     media_etag: "etag0"
                 }
             },
             writeonly: {
                 __mediaresource: {
                     media_src: "http://services.odata.org/OData/OData.svc/writeonly",
                     edit_media: "http://services.odata.org/OData/OData.svc/writeonly",
                     content_type: "image/jpeg",
                     media_etag: "etag1"
                 }
             },
             complexAsNamedStream1: {
                 __metadata: {},
                 __mediaresource: {
                     media_src: "http://services.odata.org/OData/OData.svc/readonly",
                     content_type: "image/png"
                 }
             },
             complexAsNamedStream2: {
                 __mediaresource: {
                     p1: 500
                 }
             }
         };

         var expectedEntry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/entry id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 properties: {
                     complexAsNamedStream1: {
                         type: null,
                         extensions: [],
                         properties: {
                             __mediaresource: {
                                 type: null,
                                 extensions: [],
                                 properties: {
                                     content_type: {
                                         extensions: [],
                                         type: "Edm.String"
                                     },
                                     media_src: {
                                         extensions: [],
                                         type: "Edm.String"
                                     }
                                 }
                             }
                         }
                     },
                     complexAsNamedStream2: {
                         type: null,
                         extensions: [],
                         properties: {
                             __mediaresource: {
                                 type: null,
                                 extensions: [],
                                 properties: {
                                     p1: {
                                         type: "Edm.String",
                                         extensions: []
                                     }
                                 }
                             }
                         }
                     }
                 }
             },
             complexAsNamedStream1: {
                 __metadata: { type: null },
                 __mediaresource: {
                     __metadata: { type: null },
                     media_src: "http://services.odata.org/OData/OData.svc/readonly",
                     content_type: "image/png"
                 }
             },
             complexAsNamedStream2: {
                 __metadata: { type: null },
                 __mediaresource: {
                     __metadata: { type: null },
                     p1: "500"
                 }
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request);

         window.ODataReadOracle.readEntryLoopback(request.body,
         function (expectedData) {
             djstest.assertAreEqualDeep(expectedData, expectedEntry, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeComplexEntryTest() {
         var entry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/entry id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],
                 properties: {
                     Untyped: {
                         type: "Edm.String",
                         extensions: []
                     },
                     Typed: {
                         type: "Edm.Int32",
                         extensions: []
                     },
                     Complex: {
                         type: "Complex",
                         extensions: [],
                         properties: {
                             Property1: { type: "Edm.String", extensions: [] },
                             Property2: { type: "Edm.String", extensions: [] },
                             Nested: {
                                 type: "Complex.Nested",
                                 extensions: [],
                                 properties: {
                                     NestedProperty1: { type: "Edm.String", extensions: [] },
                                     NestedProperty2: { type: "Edm.String", extensions: [] },
                                     NestedProperty3: { type: "Edm.String", extensions: [] }
                                 }
                             }
                         }
                     }
                 }
             },
             Untyped: "untyped value",
             Typed: 100,
             Complex: {
                 __metadata: { type: "Complex" },
                 Property1: "value 1",
                 Property2: "value 2",
                 Nested: {
                     __metadata: { type: "Complex.Nested" },
                     NestedProperty1: "value 3",
                     NestedProperty2: "value 4",
                     NestedProperty3: "value 5"
                 }
             }
         };

         var entryXml = OData.atomSerializer(OData.atomHandler, entry, {});

         window.ODataReadOracle.readEntryLoopback(entryXml,
         function (expectedData) {
             djstest.assertAreEqualDeep(entry, expectedData, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeInlinedDeferredEntryTest() {
         var entry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/entry id",
                 uri_extensions: [],
                 type: "the type",
                 type_extensions: [],

                 properties: {
                     deferred: {
                         //the test oracle service always adds the title extension to the link
                         extensions: [
                            {
                                name: "title",
                                namespaceURI: null,
                                value: null
                            }
                         ]
                     },
                     inline: {
                         extensions: [
                         {
                             name: "title",
                             namespaceURI: null,
                             value: null
                         }]
                     }
                 }
             },
             deferred: {
                 __deferred: { uri: "http://deferred/" }
             },
             inline: {
                 __metadata: {
                     uri: "http://services.odata.org/OData/OData.svc/entry id",
                     uri_extensions: [],
                     type: "the type",
                     type_extensions: [],
                     properties: {
                         Untyped: {
                             type: "Edm.String",
                             extensions: []
                         },
                         Typed: {
                             type: "Edm.Int32",
                             extensions: []
                         }
                     }
                 },
                 Untyped: "untyped value",
                 Typed: 100
             }
         };

         var entryXml = OData.atomSerializer(OData.atomHandler, entry, {});

         window.ODataReadOracle.readEntryLoopback(entryXml,
         function (expectedData) {
             djstest.assertAreEqualDeep(entry, expectedData, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeJsObjectTest() {
         var entryData = {
             Color: 0x0000ff,
             Height: 500,
             Width: 100
         };

         var entry = {
             __metadata: {
                 properties: {
                     Color: {
                         type: "Edm.String",
                         extensions: []
                     },
                     Width: {
                         type: "Edm.String",
                         extensions: []
                     },
                     Height: {
                         type: "Edm.String",
                         extensions: []
                     }
                 }
             },
             Color: "255",
             Height: "500",
             Width: "100"
         };

         var entryXml = OData.atomSerializer(OData.atomHandler, entryData, {});

         window.ODataReadOracle.readEntryLoopback(entryXml,
         function (data) {
             djstest.assertAreEqualDeep(entry, data, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializePrimitiveTypesTest() {
         // Currently DateTime, Time and DateTimeOffset primitive types are not being covered.
         // DateTimeOffset and Time are not covered because they aren't supported by current WCF DataServices implementations.
         // DateTime follow non standard ways of being represented in JSON streams.

         var testEntry = {
             __metadata: {
                 properties: {
                     Binary: {
                         type: "Edm.Binary",
                         extensions: []
                     },
                     Boolean: {
                         type: "Edm.Boolean",
                         extensions: []
                     },
                     Byte: {
                         type: "Edm.Byte",
                         extensions: []
                     },
                     Decimal: {
                         type: "Edm.Decimal",
                         extensions: []
                     },
                     Guid: {
                         type: "Edm.Guid",
                         extensions: []
                     },
                     Double: {
                         type: "Edm.Double",
                         extensions: []
                     },
                     Single: {
                         type: "Edm.Single",
                         extensions: []
                     },
                     Int16: {
                         type: "Edm.Int16",
                         extensions: []
                     },
                     Int32: {
                         type: "Edm.Int32",
                         extensions: []
                     },
                     Int64: {
                         type: "Edm.Int64",
                         extensions: []
                     },
                     SByte: {
                         type: "Edm.SByte",
                         extensions: []
                     }
                 }
             },
             Binary: "01007A8A680D9E14A64EAC1242DD33C9DB05",
             Boolean: false,
             UntypedBoolean: "true",
             Byte: 0xf0,
             Decimal: "100.0",
             Guid: "12345678-aaaa-bbbb-cccc-ddddeeeeffff",
             Double: 1E+10,
             Single: 100.01,
             Int16: 16,
             Int32: 32,
             Int64: "64",
             SByte: -8
         };

         var expectedEntry = {
             __metadata: {
                 properties: {
                     Binary: {
                         type: "Edm.Binary",
                         extensions: []
                     },
                     Boolean: {
                         type: "Edm.Boolean",
                         extensions: []
                     },
                     UntypedBoolean: {
                         type: "Edm.String",
                         extensions: []
                     },
                     Byte: {
                         type: "Edm.Byte",
                         extensions: []
                     },
                     Decimal: {
                         type: "Edm.Decimal",
                         extensions: []
                     },
                     Guid: {
                         type: "Edm.Guid",
                         extensions: []
                     },
                     Double: {
                         type: "Edm.Double",
                         extensions: []
                     },
                     Single: {
                         type: "Edm.Single",
                         extensions: []
                     },
                     Int16: {
                         type: "Edm.Int16",
                         extensions: []
                     },
                     Int32: {
                         type: "Edm.Int32",
                         extensions: []
                     },
                     Int64: {
                         type: "Edm.Int64",
                         extensions: []
                     },
                     SByte: {
                         type: "Edm.SByte",
                         extensions: []
                     }
                 }
             },
             Binary: "01007A8A680D9E14A64EAC1242DD33C9DB05",
             Boolean: false,
             UntypedBoolean: "true",
             Byte: 0xf0,
             Decimal: "100.0",
             Guid: "12345678-aaaa-bbbb-cccc-ddddeeeeffff",
             Double: 1E+10,
             Single: 100.01,
             Int16: 16,
             Int32: 32,
             Int64: "64",
             SByte: -8
         };

         var entryXml = OData.atomSerializer(OData.atomHandler, testEntry, {});

         window.ODataReadOracle.readEntryLoopback(entryXml,
         function (data) {
             djstest.assertAreEqualDeep(data, expectedEntry, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeSpatialPropertyTest() {
         var entry = {
             __metadata: {
                 properties: {
                     SpatialEdmTypeOnObjectWins: { type: "My.Type", extensions: [] },
                     SpatialEdmTypeOnMetadata: { type: "Edm.GeometryPoint", extensions: [] }
                 }
             },
             SpatialEdmTypeOnly: {
                 __metadata: { type: "Edm.GeometryPoint" },
                 coordinates: [100, 200]
             },
             SpatialEdmTypeWins: {
                 __metadata: { type: "Edm.GeometryPoint" },
                 type: "MultiPoint",
                 coordinates: [300, 400]
             },
             SpatialAbstractType: {
                 __metadata: { type: "Edm.Geometry" },
                 type: "Point",
                 coordinates: [500, 600]
             },
             SpatialEdmTypeOnObjectWins: {
                 __metadata: { type: "Edm.GeometryPoint" },
                 type: "Point",
                 coordinates: [5, 6]
             },
             SpatialEdmTypeOnMetadata: {
                 type: "Point",
                 coordinates: [7, 8]
             },
             SpatialUntyped: {
                 type: "Point",
                 coordinates: [9, 10]
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         djstest.assertAreEqual("3.0", request.headers["DataServiceVersion"], "Request data service version is the expected one");

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeSpatialPointTest() {
         var entry = {
             __metadata: {
                 properties: {
                     pointEdmTypeOnObjectWins: { type: "Edm.GeographyPoint", extensions: [] },
                     pointEdmTypeOnMetadata: { type: "Edm.GeometryPoint", extensions: [] }
                 }
             },
             geometryPoint: {
                 __metadata: { type: "Edm.GeometryPoint" },
                 type: "Point",
                 coordinates: [1, 2]
             },
             geographyPoint: {
                 __metadata: { type: "Edm.GeographyPoint" },
                 type: "Point",
                 coordinates: [3, 4]
             },
             emptyPoint: {
                 __metadata: { type: "Edm.GeometryPoint" },
                 type: "Point",
                 coordinates: []
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         djstest.assertAreEqual("3.0", request.headers["DataServiceVersion"], "Request data service version is the expected one");

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeSpatialLineStringTest() {
         var entry = {
             __metadata: {
                 properties: {
                     lineStringTypeOnObjectWins: { type: "Edm.GeographyLineString", extensions: [] },
                     lineStringTypeOnMetadata: { type: "Edm.GeometryLineString", extensions: [] }
                 }
             },
             geometryLineString: {
                 __metadata: { type: "Edm.GeometryLineString" },
                 type: "LineString",
                 coordinates: [[1, 2], [3, 4]]
             },
             geographyLineString: {
                 __metadata: { type: "Edm.GeographyLineString" },
                 type: "Point",
                 coordinates: [[5, 6], [7, 8]]
             },
             emptyLineString: {
                 __metadata: { type: "Edm.GeometryLineString" },
                 type: "LineString",
                 coordinates: []
             },
             lineStringTypeOnObjectWins: {
                 __metadata: { type: "Edm.GeometryLineString" },
                 type: "LineString",
                 coordinates: [[9, 10], [11, 12]]
             },
             lineStringTypeOnMetadata: {
                 type: "LineString",
                 coordinates: [[13, 14], [15, 16]]
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         djstest.assertAreEqual("3.0", request.headers["DataServiceVersion"], "Request data service version is the expected one");

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeSpatialPolygonTest() {
         var entry = {
             __metadata: {
                 properties: {
                     polygonTypeOnObjectWins: { type: "Edm.GeographyPolygon", extensions: [] },
                     polygonTypeOnMetadata: { type: "Edm.GeometryPolygon", extensions: [] }
                 }
             },
             geometryPolygon: {
                 __metadata: { type: "Edm.GeometryPolygon" },
                 type: "Polygon",
                 coordinates: [[[1, 2], [3, 4], [5, 6], [1, 2]]]
             },
             geographyPolygon: {
                 __metadata: { type: "Edm.GeographyPolygon" },
                 type: "Point",
                 coordinates: [[[7, 8], [9, 10], [11, 12], [7, 8]]]
             },
             emptyPolygon: {
                 __metadata: { type: "Edm.GeometryPolygon" },
                 type: "Point",
                 coordinates: []
             },
             polygonWithInternalRing: {
                 __metadata: { type: "Edm.GeometryPolygon" },
                 type: "Polygon",
                 coordinates: [[[13, 14], [15, 16], [17, 18], [13, 14]], [[19, 20], [21, 22], [23, 24], [19, 20]]]
             },
             polygonTypeOnObjectWins: {
                 __metadata: { type: "Edm.GeometryPolygon" },
                 type: "Polygon",
                 coordinates: [[[33, 34], [35, 36], [37, 38], [33, 34]]]
             },
             polygonTypeOnMetadata: {
                 type: "Polygon",
                 coordinates: [[[39, 40], [41, 42], [43, 44], [39, 40]]]
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         djstest.assertAreEqual("3.0", request.headers["DataServiceVersion"], "Request data service version is the expected one");

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeSpatialMultiPointTest() {
         var entry = {
             geometryMultiPoint: {
                 __metadata: { type: "Edm.GeometryMultiPoint" },
                 type: "MultiPoint",
                 coordinates: [[1, 2], [3, 4]]
             },
             geographyMultiPoint: {
                 __metadata: { type: "Edm.GeographyMultiPoint" },
                 type: "MultiPoint",
                 coordinates: [[5, 6], [7, 8]]
             },
             emptyMultiPoint: {
                 __metadata: { type: "Edm.GeometryMultiPoint" },
                 type: "MultiPoint",
                 coordinates: []
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         djstest.assertAreEqual("3.0", request.headers["DataServiceVersion"], "Request data service version is the expected one");

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeSpatialMultiLineStringTest() {
         var entry = {
             geometryMultiLineString: {
                 __metadata: { type: "Edm.GeometryMultiLineString" },
                 type: "MultiLineString",
                 coordinates: [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
             },
             geographyMultiLineString: {
                 __metadata: { type: "Edm.GeographyMultiLineString" },
                 type: "Point",
                 coordinates: [[[9, 10], [11, 12]]]
             },
             emptyMultiLineString: {
                 __metadata: { type: "Edm.GeometryMultiLineString" },
                 type: "MultiLineString",
                 coordinates: []
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         djstest.assertAreEqual("3.0", request.headers["DataServiceVersion"], "Request data service version is the expected one");

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeSpatialMultiLinePolygonTest() {
         var entry = {
             geometryMultiLineString: {
                 __metadata: { type: "Edm.GeometryMultiPolygon" },
                 type: "MultiPolygon",
                 coordinates: [[[[1, 2], [3, 4], [5, 6], [1, 2]]], [[[7, 8], [9, 10], [11, 12], [7, 8]]]]
             },
             geographyMultiLineString: {
                 __metadata: { type: "Edm.GeographyMultiPolygon" },
                 type: "MultiPolygon",
                 coordinates: [[[[9, 10], [11, 12], [13, 14], [9, 10]]]]
             },
             emptyMultiLineString: {
                 __metadata: { type: "Edm.GeometryMultiPolygon" },
                 type: "MultiPolygon",
                 coordinates: []
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         djstest.assertAreEqual("3.0", request.headers["DataServiceVersion"], "Request data service version is the expected one");

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeSpatialGeometryCollectionTest() {
         var entry = {
             geometryCollection: {
                 __metadata: { type: "Edm.GeometryCollection" },
                 type: "GeometryCollection",
                 geometries: [
                     {
                         type: "Point",
                         coordinates: [1, 2]
                     }
                 ]
             },
             geographyCollection: {
                 __metadata: { type: "Edm.GeometryCollection" },
                 type: "GeometryCollection",
                 geometries: [
                     {
                         type: "Point",
                         coordinates: [3, 4]
                     }
                 ]
             },
             emptyGeometryCollection: {
                 __metadata: { type: "Edm.GeometryCollection" },
                 type: "GeometryCollection",
                 geometries: []
             },
             nestedGeometryCollection: {
                 __metadata: { type: "Edm.GeometryCollection" },
                 type: "GeometryCollection",
                 geometries: [
                     {
                         type: "GeometryCollection",
                         geometries: [
                             {
                                 type: "GeometryCollection",
                                 geometries: [
                                     {
                                         type: "Point",
                                         coordinates: [5, 6]
                                     }
                                 ]
                             }
                         ]
                     }
                ]
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         djstest.assertAreEqual("3.0", request.headers["DataServiceVersion"], "Request data service version is the expected one");

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     djstest.addTest(function atomSerializeCollectionPropertiesTest() {
         var entry = {
             __metadata: {
                 uri: "http://services.odata.org/OData/OData.svc/the id",
                 properties: {
                     primitiveColArray: { type: "Collection(Edm.Int16)" },
                     primitiveColObject: { type: "Collection(Edm.Int32)" },
                     primitiveTypelessCollection: { type: "Collection()" },
                     complexColArray: { type: "Collection(My.Type)" },
                     complexColObject: { type: "Collection(My.Type2)" },
                     colObjectTypeInObjectWins: { type: "Collection(Edm.Double)" },
                     complexColArrayPropertiesInfo: {
                         type: "Collection(My.Type3)",
                         properties: {
                             p3: { type: "Edm.Int32" },
                             p4: { type: "Edm.Int16" }
                         }
                     }
                 }
             },
             primitiveColArray: [1, 2, 3, 4],
             primitiveColObject: {
                 results: [5, 6, 7, 8]
             },
             primitiveColObjectWithType: {
                 __metadata: { type: "Collection(Edm.Double)" },
                 results: [1.1, 2.2, 3.3]
             },
             primitiveUntypedColArray: [5, 6, 7],
             primitiveUntypedColObject: {
                 results: [10, 11, 12]
             },
             primitiveTypelessCollection: [13, 14, 15],
             complexColArray: [{ p1: 10 }, { p1: 20}],
             complexColObject: {
                 results: [{ p2: 300 }, { p2: 400}]
             },
             colObjectTypeInObjectWins: {
                 __metadata: { type: "Collection(Edm.Single)" },
                 results: [1.5, 2.5, 3.5]
             },
             complexColArrayPropertiesInfo: [
                { p3: 900, p4: 1000 },
                { p3: 900, p4: 1000 }
             ],
             complexTypelessCollection: {
                 __metadata: { type: "Collection()" },
                 results: [{ p5: 1500 }, { p5: 1600}]
             }
         };

         var request = { headers: {}, data: entry };
         OData.atomHandler.write(request, {});
         var entryXml = request.body;

         var response = {
             headers: { "Content-Type": "application/atom+xml", "DataServiceVersion": "3.0" },
             body: entryXml
         };

         OData.atomHandler.read(response, {});
         var actual = response.data;

         window.ODataReadOracle.readEntryLoopback(entryXml, function (expected) {
             djstest.assertAreEqualDeep(actual, expected, "Response data not same as expected");
             djstest.done();
         });
     });

     //    djstest.addTest(function atomSerializeInvalidPayloadTest() {
     //        djstest.expectException(function () {
     //            OData.atomSerializer(OData.atomHandler, { EntitySets: [] });
     //        }, "expected exception for serializing a service document");

     //        djstest.expectException(function () {
     //            OData.atomSerializer(OData.atomHandler, null, {});
     //        }, "expected exception for serializing null data");

     //        djstest.expectException(function () {
     //            OData.atomSerializer(OData.atomHandler, undefined, {});
     //        }, "expected exception for serializing undefined data");

     //        djstest.done();
     //    });

     djstest.addTest(function atomSetEntryValueByPathTest() {
         var target = {};

         // simple property added.
         OData.atomSetEntryValueByPath("p", target, 1);
         djstest.assertAreEqual(target.p, 1, "target.p set to 1");

         // simple property replaced.
         OData.atomSetEntryValueByPath("p", target, 2);
         djstest.assertAreEqual(target.p, 2, "target.p overwritten to 1");

         // Construct object and set property.
         OData.atomSetEntryValueByPath("a/b", target, 3);
         djstest.assertAreEqual(target.a.b, 3, "target.a.b set to 3");

         // Construct object and replace property.
         OData.atomSetEntryValueByPath("a/b", target, 4);
         djstest.assertAreEqual(target.a.b, 4, "target.a.b set to 4");

         // Construct object deeply and set property.
         OData.atomSetEntryValueByPath("a/deep/value", target, 5);
         djstest.assertAreEqual(target.a.b, 4, "target.a.b still 4");
         djstest.assertAreEqual(target.a.deep.value, 5, "target.a.deep.value set to 5");

         djstest.done();
     });

     djstest.addTest(function getXmlPathValueTest() {
         // Tests with expected value and result based on doc.
         var doc = datajs.xmlParse(
         "<atom:entry xmlns:atom='http://www.w3.org/2005/Atom' xmlns:c='custom'>" +
         " <atom:title>title</atom:title>" +
         " <atom:summary>summary</atom:summary>" +
         " <atom:author><atom:name>author name</atom:name><atom:uri>author uri</atom:uri><atom:email>author email</atom:email></atom:author>" +
         " <atom:contributor><atom:name>contributor name</atom:name></atom:contributor>" +
         " <c:element>custom element</c:element>" +
         " <c:other c:with-attribute='attribute' with-attribute='decoy'>text</c:other>" +
         " <c:third><c:item><c:a>a</c:a><c:b>b</c:b><c:empty /></c:item></c:third>" +
         "</atom:entry>");

         var root = datajs.xmlFirstChildElement(doc);

         var atomXmlNs = "http://www.w3.org/2005/Atom";
         var tests = [
         { ns: atomXmlNs, path: "title", e: "title" },
         { ns: atomXmlNs, path: "updated", e: null },
         { ns: atomXmlNs, path: "summary", e: "summary" },
         { ns: atomXmlNs, path: "rights", e: null },
         { ns: atomXmlNs, path: "published", e: null },
         { ns: atomXmlNs, path: "contributor/email", e: null },
         { ns: atomXmlNs, path: "contributor/uri", e: null },
         { ns: atomXmlNs, path: "contributor/name", e: "contributor name" },
         { ns: atomXmlNs, path: "author/uri", e: "author uri" },
         { ns: atomXmlNs, path: "author/name", e: "author name" },
         { ns: atomXmlNs, path: "author/email", e: "author email" },
         { ns: "custom", path: "element", e: "custom element" },
         { ns: "other", path: "element", e: null },
         { ns: "custom", path: "other", e: "text" },
         { ns: "custom", path: "other/@with-attribute", e: "attribute" },
         { ns: "custom", path: "third/item/a", e: "a" },
         { ns: "custom", path: "third/item/b", e: "b" },
         { ns: "custom", path: "third/item/c", e: null },
         { ns: "custom", path: "third/item/empty", e: null }
     ];

         var i, len;
         for (i = 0, len = tests.length; i < len; i++) {
             var test = tests[i];
             var node = datajs.xmlFindNodeByPath(root, test.ns, test.path);
             var actual = node && datajs.xmlNodeValue(node);
             djstest.assertAreEqual(actual, test.e, "match for test #" + i + "(" + test.path + ")");
         }

         djstest.done();
     });

     djstest.addTest(function atomApplyCustomizationToEntryObjectTest() {
         var entryXml =
             "<atom:entry xmlns:atom='http://www.w3.org/2005/Atom' xmlns:c='custom'>" +
             " <atom:title>title</atom:title>" +
             " <atom:summary>summary</atom:summary>" +
             " <atom:author><atom:name>author name</atom:name><atom:uri>author uri</atom:uri><atom:email>author email</atom:email></atom:author>" +
             " <atom:contributor><atom:name>contributor name</atom:name></atom:contributor>" +
             " <atom:category term='Ns.Customer' scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme' />" +
             " <c:element>custom element</c:element>" +
             " <c:other c:with-attribute='attribute' with-attribute='decoy'>text</c:other>" +
             " <c:third><c:item><c:a>a</c:a><c:b>b</c:b><c:empty /></c:item></c:third>" +
             "</atom:entry>"

         var tests = [
             { ns: null, path: "SyndicationTitle", e: "title" },
             { ns: null, path: "SyndicationUpdated", e: undefined },
             { ns: null, path: "SyndicationSummary", e: "summary" },
             { ns: "custom", path: "element", e: "custom element" },
             { ns: "custom", path: "other/@with-attribute", e: "attribute" }
         ];

         var i, len;
         for (i = 0, len = tests.length; i < len; i++) {
             var test = tests[i];
             var model = {
                 "namespace": "Ns",
                 entityType: [
                     {
                         name: "Customer",
                         FC_SourcePath: "targetProperty/value",
                         FC_NsUri: test.ns, FC_TargetPath: test.path
                     }
                 ]
             };
             var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };

             OData.atomHandler.read(response, { metadata: model });
             var data = response.data;
             var actual = (data.targetProperty) ? data.targetProperty.value : undefined;
             djstest.assertAreEqual(actual, test.e, "match for test #" + i + "(" + test.path + ")");
         }

         djstest.done();
     });

     djstest.addTest(function atomReadCustomizedEntryWithNoTypeInformation() {
         var entryXml =
         "<atom:entry xmlns:atom='http://www.w3.org/2005/Atom' xmlns:c='custom'>" +
         " <atom:title>title</atom:title>" +
         " <atom:summary>summary</atom:summary>" +
         " <atom:author><atom:name>author name</atom:name><atom:uri>author uri</atom:uri><atom:email>author email</atom:email></atom:author>" +
         " <atom:contributor><atom:name>contributor name</atom:name></atom:contributor>" +
         " <c:element>custom element</c:element>" +
         " <c:other c:with-attribute='attribute' with-attribute='decoy'>text</c:other>" +
         " <c:third><c:item><c:a>a</c:a><c:b>b</c:b><c:empty /></c:item></c:third>" +
         "</atom:entry>";

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };
         var metadata = { "namespace": "Ns", entityType: [{ name: "Customer"}] };

         OData.atomHandler.read(response, { metadata: metadata });
         djstest.assertAreEqualDeep(response.data, { __metadata: {} }, "No change for entity with no type name");

         djstest.done();
     });

     djstest.addTest(function atomReadCustomizedEntryWithMismatchedType() {
         var entryXml =
         "<atom:entry xmlns:atom='http://www.w3.org/2005/Atom' xmlns:c='custom'>" +
         " <atom:title>title</atom:title>" +
         " <atom:summary>summary</atom:summary>" +
         " <atom:author><atom:name>author name</atom:name><atom:uri>author uri</atom:uri><atom:email>author email</atom:email></atom:author>" +
         " <atom:contributor><atom:name>contributor name</atom:name></atom:contributor>" +
         " <atom:category term='Ns.Customer' scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme' />" +
         " <c:element>custom element</c:element>" +
         " <c:other c:with-attribute='attribute' with-attribute='decoy'>text</c:other>" +
         " <c:third><c:item><c:a>a</c:a><c:b>b</c:b><c:empty /></c:item></c:third>" +
         "</atom:entry>";

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };
         var metadata = { "namespace": "Ns", entityType: [{ name: "Person"}] };

         OData.atomHandler.read(response, { metadata: metadata });
         djstest.assertAreEqualDeep(response.data,
             { __metadata: { type: "Ns.Customer", type_extensions: []} },
             "No change for entity with no matching type name");

         djstest.done();
     });

     djstest.addTest(function atomReadCustomizedEntryTest() {
         var entryXml =
         "<atom:entry xmlns:atom='http://www.w3.org/2005/Atom' xmlns:c='custom'>" +
         " <atom:title>title</atom:title>" +
         " <atom:summary>summary</atom:summary>" +
         " <atom:author><atom:name>author name</atom:name><atom:uri>author uri</atom:uri><atom:email>author email</atom:email></atom:author>" +
         " <atom:contributor><atom:name>contributor name</atom:name></atom:contributor>" +
         " <atom:category term='Ns.Customer' scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme' />" +
         " <c:element>custom element</c:element>" +
         " <c:other c:with-attribute='attribute' with-attribute='decoy'>text</c:other>" +
         " <c:third><c:item><c:a>a</c:a><c:b>b</c:b><c:empty /></c:item></c:third>" +
         "</atom:entry>";

         var response = { headers: { "Content-Type": "application/atom+xml" }, body: entryXml };
         var metadata;

         // Entity-level feed customization.
         metadata = { "namespace": "Ns", entityType: [{ name: "Customer", FC_SourcePath: "name", FC_TargetPath: "SyndicationTitle"}] };
         OData.atomHandler.read(response, { metadata: metadata });
         djstest.assertAreEqualDeep(response.data, {
             __metadata: { type: "Ns.Customer", type_extensions: [] },
             name: "title"
         }, "title mapped from entity");

         // Property-level feed customization.
         metadata = {
             "namespace": "Ns",
             entityType: [
                 {
                     name: "Customer",
                     FC_SourcePath: "name",
                     FC_TargetPath:
                     "SyndicationTitle",
                     property: [
                         { name: "biography", FC_TargetPath: "SyndicationSummary" },
                         { name: "stuff", FC_TargetPath: "third/item/a", FC_NsUri: "custom" },
                         { name: "contactInfo", FC_SourcePath: "email", FC_TargetPath: "SyndicationAuthorEmail" }
                     ]
                 }
             ]
         };

         OData.atomHandler.read(response, { metadata: metadata });
         djstest.assertAreEqualDeep(response.data, {
             __metadata: { type: "Ns.Customer", type_extensions: [] },
             name: "title",
             biography: "summary",
             "stuff": "a",
             contactInfo: { email: "author email" }
         }, "biography and stuff mapped from property feed customizations");

         // Base type customization.
         metadata = {
             "namespace": "Ns",
             entityType: [
                 {
                     name: "Customer", baseType: "Ns.Person",
                     FC_SourcePath: "name", FC_TargetPath: "SyndicationTitle",
                     property: [
                         { name: "biography", FC_TargetPath: "SyndicationSummary" },
                         { name: "stuff", FC_TargetPath: "third/item/a", FC_NsUri: "custom" }
                     ]
                 },
                 {
                     name: "Person",
                     FC_SourcePath: "name", FC_TargetPath: "SyndicationTitle",
                     property: [
                         { name: "personAttribute", FC_TargetPath: "other/@with-attribute", FC_NsUri: "custom" }
                     ]
                 }
             ]
         };

         OData.atomHandler.read(response, { metadata: metadata });
         djstest.assertAreEqualDeep(response.data, {
             __metadata: { type: "Ns.Customer", type_extensions: [] },
             name: "title",
             biography: "summary",
             "stuff": "a",
             personAttribute: "attribute"
         }, "attribute mapped from base type");

         djstest.done();
     });

     djstest.addTest(function lookupPropertyTypeTest() {
         // Tests are in metadata / entity / path / expected name form.

         var schema = {
             namespace: "Ns",
             entityType: [
             { name: "Person", property: [
                 { name: "id", type: "Edm.Int32" }, { name: "name" }
             ]
             },
             { name: "Customer", baseType: "Ns.Person", property: [
                 { name: "account", type: "Edm.Int32" }, { name: "delivery", type: "Ns.Address" }
             ]
             }
         ],
             complexType: [
             { name: "Address", property: [{ name: "street", type: "Edm.String" }, { name: "city"}] }
         ]
         };

         var tests = [
         { m: schema, e: schema.entityType[0], path: "id", n: "Edm.Int32" },
         { m: schema, e: schema.entityType[0], path: "foo", n: null },
         { m: schema, e: schema.entityType[0], path: "name", n: null },
         { m: schema, e: schema.entityType[1], path: "id", n: "Edm.Int32" },
         { m: schema, e: schema.entityType[1], path: "name", n: null },
         { m: schema, e: schema.entityType[1], path: "account", n: "Edm.Int32" },
         { m: schema, e: schema.entityType[1], path: "delivery/street", n: "Edm.String" }
     ];

         var i, len;
         for (i = 0, len = tests.length; i < len; i++) {
             var test = tests[i];
             var actual = OData.lookupPropertyType(test.m, test.e, test.path);
             djstest.assertAreEqualDeep(actual, test.n, "matching type name for path " + test.path);
         }

         djstest.done();
     });

     var dateMs = function (text, extraMs, ns, offset) {
         /// <summary>Constructs a Date object by parsing the specified text and adding milliseconds, nanosenconds and offest data.</summary>
         /// <param name="text" type="String">Date in string form.</param>
         /// <param name="extraMS" type="Number">Milliseconds to add.</param>
         /// <param name="ns" type="Number">Nanoseconds.</param>
         /// <param name="offset" type="String">Offset data.</param>

         var result = new Date(new Date(text).valueOf() + extraMs);
         if (ns !== undefined) {
             result.__ns = ns;
         }

         if (offset) {
             result.__edmType = "Edm.DateTimeOffset";
             result.__offset = offset;
         }

         return result;
     };

     djstest.addTest(function parseDateTimeTest() {

         // This function is used to create dates with out-of-range years; it works only on Safari
         var createDateWithLargeYear = function (dateString, actualYear) {
             var date = new Date(dateString);
             date.setFullYear(actualYear);

             if (!isNaN(date.valueOf())) {
                 return date;
             }
             else {
                 return undefined;
             }
         };

         // Input and expected values (undefined for exceptions).
         var tests = [
         // Valid values.
             {i: "2000-01-02T03:04:05", e: new Date("01/02/2000 03:04:05 GMT") }, // simple date
             {i: "2000-01-31T03:04:05", e: new Date("01/31/2000 03:04:05 GMT") }, // 31st date of month
             {i: "2000-01-31T23:58:59", e: new Date("01/31/2000 23:58:59 GMT") }, // post-noon hours
             {i: "0500-08-09T09:09:09", e: new Date("08/09/0500 09:09:09 GMT") }, // leading zeroes
             {i: "20000-01-31T23:58:59", e: new Date("01/31/20000 23:58:59 GMT") }, // >4 digit years
             {i: "2000-01-02T24:00:00", e: new Date("01/03/2000 00:00:00 GMT") }, // 24:00 for midnight
             {i: "0050-01-31T23:00:00", e: new Date(-60586621200000) }, // year in 0-99 range

             {i: "2000-01-31T03:04:05.5", e: dateMs("01/31/2000 03:04:05 GMT", 500) },  // An extra half-second
             {i: "2000-01-31T03:04:05.001", e: dateMs("01/31/2000 03:04:05 GMT", 1) },  // An extra millisecond
             {i: "2000-01-31T03:04:05.0000001", e: dateMs("01/31/2000 03:04:05 GMT", 0, 1) },  // An extra nanosecond
             {i: "2000-01-31T03:04:05.0010001", e: dateMs("01/31/2000 03:04:05 GMT", 1, 1) },  // An extra millisecond and nanosecond
             {i: "2000-01-31T03:04:05.0011000", e: dateMs("01/31/2000 03:04:05 GMT", 1, 1000) },  // An extra millisecond and 1000 nanoseconds
             {i: "2000-01-31T03:04:05.00101", e: dateMs("01/31/2000 03:04:05 GMT", 1, 100) },  // An extra millisecond and 100 nanoseconds
             {i: "2011-09-24T16:20:15.7724193", e: dateMs("09/24/2011 16:20:15 GMT", 772, 4193) }, // Azure timestamp value
             {i: "-0100-01-31T23:58:59", e: new Date(-65288678461000) },                 // BC years
             {i: "2000-02-29T03:04:05", e: new Date("02/29/2000 03:04:05 GMT") },  // Leap day
             {i: "0000-01-02T03:04:05", e: new Date(-62135499355000) },   // Zero year
             {i: "2000-13-32T25:61:61", e: new Date("02/02/2001 02:02:01 GMT") },  // Time components overflow
             {i: "2000-01-02T24:00:01", e: new Date("01/03/2000 00:00:01 GMT") },  // 24-hour overflow
             {i: "2000-04-31T00:00:00", e: new Date("05/01/2000 00:00:00 GMT") },  // Day overflow
             {i: "2001-02-29T00:00:00", e: new Date("03/01/2001 00:00:00 GMT") },  // Non-existent leap day overflow
             {i: "2000-01-02T03:04", e: new Date("01/02/2000 03:04:00 GMT") },  //Date without seconds
         // Unparseable invalid values.
             {i: "2000-01-02T03:04:05+01:00" }, // Timezone included
             {i: "2000-01-02T03:04:05.00000001" },  // Too much precision, tenths of nanoseconds not supported
             {i: "-100-01-31T23:58:59" },       // Year component too short
             {i: "2000" },                      // Not enough components
             {i: "+2000-01-02T03:04:05" },      // Positive sign prefix
             {i: "2000-1-2T3:4:5" },            // Components too short
             {i: "2000-01-02T03:04:05." },      // Trailing dot with no fractional seconds component

         // Out of range date values (except Safari)
             {i: "-271822-04-19T23:59:59", e: createDateWithLargeYear("04/19/2000 23:59:59 GMT", -271821) },
             { i: "275760-09-13T00:00:01", e: createDateWithLargeYear("09/13/2000 00:00:01 GMT", 275760) }
         ];

         for (var i = 0; i < tests.length; i++) {
             var result;
             try {
                 result = OData.parseDateTime(tests[i].i);
             } catch (err) {
                 result = undefined;
             }

             djstest.assertAreEqualDeep(result, tests[i].e, "parseDateTime for " + tests[i].i + " expecting " + tests[i].e + " found " + result);
         }
         djstest.done();
     });

     djstest.addTest(function parseDateTimeOffsetTest() {
         // Each test has input, expected value in text form, and expected offset text.
         var tests = [
         // Valid values.
             {i: "2000-01-02T03:04:05Z", ev: dateMs("01/02/2000 03:04:05 GMT", 0, 0, "Z") }, // simple date
             {i: "2000-01-02T03:04:05+00:00", ev: dateMs("01/02/2000 03:04:05 GMT", 0, 0, "Z") }, // simple date with zero positive offset
             {i: "2000-01-02T03:04:05-00:00", ev: dateMs("01/02/2000 03:04:05 GMT", 0, 0, "Z") }, // simple date with zero negative offset
             {i: "2000-01-02T03:04:05+14:00", ev: dateMs("01/01/2000 13:04:05 GMT", 0, 0, "+14:00") }, // simple date with maximum positive offset
             {i: "2000-01-02T03:04:05-14:00", ev: dateMs("01/02/2000 17:04:05 GMT", 0, 0, "-14:00") }, // simple date with maximum negative offset
             {i: "2000-01-02T03:04:05+01:00", ev: dateMs("01/02/2000 02:04:05 GMT", 0, 0, "+01:00") }, // simple date with an hour positive offset
             {i: "2000-01-02T03:04:05+00:30", ev: dateMs("01/02/2000 02:34:05 GMT", 0, 0, "+00:30") }, // simple date with a half-hour positive offset
             {i: "2000-01-02T03:04:05-01:00", ev: dateMs("01/02/2000 04:04:05 GMT", 0, 0, "-01:00") }, // simple date with an hour negative offset
             {i: "2000-01-02T03:04:05+10:30", ev: dateMs("01/01/2000 16:34:05 GMT", 0, 0, "+10:30") }, // simple date with a ten hour and a half positive offset
             {i: "2000-01-02T03:04:05-10:30", ev: dateMs("01/02/2000 13:34:05 GMT", 0, 0, "-10:30") }, // simple date with a ten hour and a half negative offset
             {i: "2000-01-01T00:29:00+00:30", ev: dateMs("12/31/1999 23:59:00 GMT", 0, 0, "+00:30") }, // positive offset crossing component boundaries
             {i: "1999-12-31T23:30:00-00:30", ev: dateMs("01/01/2000 00:00:00 GMT", 0, 0, "-00:30") },  // negative offset crossing component boundaries
             {i: "2011-09-24T16:20:15.7724193Z", ev: dateMs("09/24/2011 16:20:15 GMT", 772, 4193, "Z")} // Azure timestamp value
         ];

         for (var i = 0; i < tests.length; i++) {
             var result = OData.parseDateTimeOffset(tests[i].i);
             djstest.assertAreEqualDeep(result, tests[i].ev, "parseDateTimeOffset for " + tests[i].i);
         }
         djstest.done();
     });

     djstest.addTest(function parseTimeTest() {
         var error;
         try {
             OData.parseTime("00:01:02");
             error = null;
         } catch (err) {
             error = err;
         }

         djstest.assert(error !== null, "error !== null");

         djstest.done();
     });

     djstest.addTest(function formatDateTimeOffsetTest() {
         // Input values that should simply round-trip.
         var tests = [
             "2000-01-02T03:04:05Z",
             "2000-01-31T03:04:05Z",
             "-2000-01-31T03:04:05.002Z",
             "2000-01-31T03:04:05.800+00:10-00:00",
             "2000-01-31T03:04:05.020+00:10+00:00",
             "2000-01-31T03:04:05.500+00:10-08:30",
             "2000-01-31T03:04:05.500+12:10+08:30",
             "2000-01-31T03:04:05.500-12:10-08:30",
             "0099-01-31T03:04:05.500-12:10+00:30",
             "-0001-01-31T03:04:05.500-12:10+00:05",
             "-0001-01-31T03:04:05.500-12:10-00:05",
             "2020-01-31T03:04:05.501-12:10+07:00",
             "2011-09-24T16:20:15.7724193Z"
         ];

         for (var i = 0; i < tests.length; i++) {
             var test = tests[i];
             var dateValue = OData.parseDateTimeOffset(test);
             var textValue = OData.formatDateTimeOffset(dateValue);
             djstest.assertAreEqual(textValue, test, "Roundtripping " + test + " through " + dateValue.toUTCString());
         }

         djstest.done();
     });

     djstest.addTest(function malformedXmlTest() {
         // Verifies that malformed XML documents (typically incomplete payloads) do indeed throw an error.
         var xmlText = "<top>text <another /> <item> </item> <!-- top not closed -->";
         var err = null;
         try {
             parseMetadataHelper(xmlText);
         } catch (_) { err = _; }

         var expectedErrorMessage0 = "The following tags were not closed: top."; // IE MSXML
         var expectedErrorMessage1 = "XML Parsing Error: no element found";      // FF
         var expectedErrorMessage2 = "This page contains the following errors";  // Chrome
         var expectedErrorMessage3 = "Error";                                    // Opera
         var expectedErrorMessage4 = "DOM Exception: SYNTAX_ERR (12)"            // IE9 DOMParser
         var expectedErrorMessage5 = "SyntaxError"                               // IE10 DOMParser

         djstest.assert(err !== null, "err !== null");
         djstest.assertAreEqual(err.errorXmlText, xmlText, "xmlText matches original");
         djstest.assert(
             err.message.indexOf(expectedErrorMessage0) === 0 ||
             err.message.indexOf(expectedErrorMessage1) === 0 ||
             err.message.indexOf(expectedErrorMessage2) === 0 ||
             err.message.indexOf(expectedErrorMessage3) === 0 && window.opera ||
             err.message.indexOf(expectedErrorMessage4) === 0 ||
             err.message.indexOf(expectedErrorMessage5) === 0,
             err.message + " contains one of '" +
             [expectedErrorMessage0, expectedErrorMessage1, expectedErrorMessage2,
              expectedErrorMessage3, expectedErrorMessage4, expectedErrorMessage5].join(',') + "'");

         djstest.done();
     });

     // DATAJS INTERNAL END
 })(this);