diff --git a/CHANGELOG.md b/CHANGELOG.md
index 75e387bde..4cdf308f6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,19 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/) 
 
+## [6.5.0] Preview Release
+### Added
+- Support for spatial datatypes [#642](https://github.com/Microsoft/mssql-jdbc/pull/642)
+
+### Fixed Issues
+- Fixed blobs becoming unavailable when the Result Set cursor moves or the Result Set closes [#595](https://github.com/Microsoft/mssql-jdbc/pull/595)
+- Fixed an issue when attempting to insert an empty or null value into an encrypted column [#632](https://github.com/Microsoft/mssql-jdbc/pull/632)
+- Fixed a misleading error message thrown by the driver when a user doesn't have execute permissions [#635](https://github.com/Microsoft/mssql-jdbc/pull/635)
+- Fixed statements throwing SQLServerException instead of java.sql.SQLTimeoutException when the query times out [#641](https://github.com/Microsoft/mssql-jdbc/pull/641)
+
+### Changed
+- Unit tests now use SQLException in most cases instead of SQLServerException.
+
 ## [6.4.0] Stable Release
 ### Added
 - Support added for AAD Integrated Authentication with ADAL4J on Windows/Linux/Mac OS [#603](https://github.com/Microsoft/mssql-jdbc/pull/603) 
diff --git a/README.md b/README.md
index 4983f0c10..788d8bf28 100644
--- a/README.md
+++ b/README.md
@@ -90,7 +90,7 @@ To get the latest preview version of the driver, add the following to your POM f
 <dependency>
 	<groupId>com.microsoft.sqlserver</groupId>
 	<artifactId>mssql-jdbc</artifactId>
-	<version>6.3.6.jre8-preview</version>
+	<version>6.5.0.jre9-preview</version>
 </dependency>
 ```
 
@@ -120,7 +120,7 @@ Projects that require either of the two features need to explicitly declare the
 <dependency>
 	<groupId>com.microsoft.sqlserver</groupId>
 	<artifactId>mssql-jdbc</artifactId>
-	<version>6.4.0.jre9</version>
+	<version>6.5.0.jre9-preview</version>
 	<scope>compile</scope>
 </dependency>
 
@@ -136,7 +136,7 @@ Projects that require either of the two features need to explicitly declare the
 <dependency>
 	<groupId>com.microsoft.sqlserver</groupId>
 	<artifactId>mssql-jdbc</artifactId>
-	<version>6.4.0.jre9</version>
+	<version>6.5.0.jre9-preview</version>
 	<scope>compile</scope>
 </dependency>
 
diff --git a/pom.xml b/pom.xml
index 6c41936d5..f63e32330 100644
--- a/pom.xml
+++ b/pom.xml
@@ -5,7 +5,7 @@
 	
 	<groupId>com.microsoft.sqlserver</groupId>
 	<artifactId>mssql-jdbc</artifactId>
-	<version>6.4.0.${jreVersion}</version>
+	<version>6.5.0.${jreVersion}-preview</version>
 	<packaging>jar</packaging>
 	
 	<name>Microsoft JDBC Driver for SQL Server</name>
@@ -40,8 +40,8 @@
 
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<junit.platform.version>1.0.0-M3</junit.platform.version>
-		<junit.jupiter.version>5.0.0-M3</junit.jupiter.version>
+		<junit.platform.version>1.1.0</junit.platform.version>
+		<junit.jupiter.version>5.1.0</junit.jupiter.version>
 	</properties>
 	
 	<dependencies>
@@ -118,13 +118,13 @@
 		<dependency>
 			<groupId>com.zaxxer</groupId>
 			<artifactId>HikariCP</artifactId>
-			<version>2.7.4</version>
+			<version>2.7.8</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.apache.commons</groupId>
 			<artifactId>commons-dbcp2 </artifactId>
-			<version>2.1.1</version>
+			<version>2.2.0</version>
 			<scope>test</scope>
 		</dependency>
   	<!-- 
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/DDC.java b/src/main/java/com/microsoft/sqlserver/jdbc/DDC.java
index 1e90ef726..2509b5e3c 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/DDC.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/DDC.java
@@ -612,6 +612,10 @@ static final Object convertStreamToObject(BaseInputStream stream,
                             byte[] byteValue = stream.getBytes();
                             if (JDBCType.GUID == jdbcType) {
                                 return Util.readGUID(byteValue);
+                            } else if (JDBCType.GEOMETRY == jdbcType) {
+                                return Geometry.STGeomFromWKB(byteValue);
+                            } else if (JDBCType.GEOGRAPHY == jdbcType) {
+                                return Geography.STGeomFromWKB(byteValue);
                             }
                             else {
                                 String hexString = Util.bytesToHexString(byteValue, byteValue.length);
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/DataTypes.java b/src/main/java/com/microsoft/sqlserver/jdbc/DataTypes.java
index 3f6ebdbea..19c6a64a2 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/DataTypes.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/DataTypes.java
@@ -148,7 +148,9 @@ enum SSType
     SQL_VARIANT    (Category.SQL_VARIANT,     "sql_variant",      JDBCType.SQL_VARIANT),  
     UDT            (Category.UDT,             "udt",              JDBCType.VARBINARY),
     XML            (Category.XML,             "xml",              JDBCType.LONGNVARCHAR),
-    TIMESTAMP      (Category.TIMESTAMP,       "timestamp",        JDBCType.BINARY);
+    TIMESTAMP      (Category.TIMESTAMP,       "timestamp",        JDBCType.BINARY),
+    GEOMETRY       (Category.UDT,             "geometry",         JDBCType.GEOMETRY),
+    GEOGRAPHY      (Category.UDT,             "geography",        JDBCType.GEOGRAPHY);
 
     final Category category;
     private final String name;
@@ -352,7 +354,9 @@ enum GetterConversion
             EnumSet.of(
                 JDBCType.Category.BINARY,
                 JDBCType.Category.LONG_BINARY,
-                JDBCType.Category.CHARACTER)),
+                JDBCType.Category.CHARACTER,
+                JDBCType.Category.GEOMETRY,
+                JDBCType.Category.GEOGRAPHY)),
 
         GUID (
             SSType.Category.GUID,
@@ -856,7 +860,9 @@ enum JDBCType
     DATETIME      (Category.TIMESTAMP,       microsoft.sql.Types.DATETIME,			"java.sql.Timestamp"),
     SMALLDATETIME (Category.TIMESTAMP,       microsoft.sql.Types.SMALLDATETIME,     "java.sql.Timestamp"),
     GUID		  (Category.CHARACTER,		 microsoft.sql.Types.GUID,				"java.lang.String"),
-    SQL_VARIANT   (Category.SQL_VARIANT,     microsoft.sql.Types.SQL_VARIANT,       "java.lang.Object");
+    SQL_VARIANT   (Category.SQL_VARIANT,     microsoft.sql.Types.SQL_VARIANT,       "java.lang.Object"),
+    GEOMETRY      (Category.GEOMETRY,        microsoft.sql.Types.GEOMETRY,          "java.lang.Object"),
+    GEOGRAPHY     (Category.GEOGRAPHY,       microsoft.sql.Types.GEOGRAPHY,         "java.lang.Object");
 
 
     final Category category;
@@ -906,6 +912,8 @@ enum Category {
         TVP,
         GUID,
         SQL_VARIANT,
+        GEOMETRY,
+        GEOGRAPHY
     }
 
     // This SetterConversion enum is based on the Category enum
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Geography.java b/src/main/java/com/microsoft/sqlserver/jdbc/Geography.java
new file mode 100644
index 000000000..7c9fcaf8a
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/Geography.java
@@ -0,0 +1,332 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Locale;
+
+public class Geography extends SQLServerSpatialDatatype {
+    
+    /**
+     * Private constructor used for creating a Geography object from WKT and srid.
+     */
+    private Geography(String WellKnownText, int srid) {
+        this.wkt = WellKnownText;
+        this.srid = srid;
+        
+        try {
+            parseWKTForSerialization(this, currentWktPos, -1, false);
+        }
+        catch (StringIndexOutOfBoundsException e) {
+            throw new IllegalArgumentException("Reached unexpected end of WKT. Please make sure WKT is valid.");
+        }
+        
+        serializeToWkb(false);
+        isNull = false;
+    }
+
+    /**
+     * Private constructor used for creating a Geography object from WKB.
+     */
+    private Geography(byte[] wkb) {
+        this.wkb = wkb;
+        buffer = ByteBuffer.wrap(wkb);
+        buffer.order(ByteOrder.LITTLE_ENDIAN);
+        
+        parseWkb();
+        
+        WKTsb = new StringBuffer();
+        WKTsbNoZM = new StringBuffer();
+        
+        constructWKT(this, internalType, numberOfPoints, numberOfFigures, numberOfSegments, numberOfShapes);
+        
+        wkt = WKTsb.toString();
+        wktNoZM = WKTsbNoZM.toString();
+        isNull = false;
+    }
+    
+    public Geography() {
+        // TODO Auto-generated constructor stub
+    }
+    
+    /**
+     * Returns a Geography instance from an Open Geospatial Consortium (OGC) Well-Known Text (WKT)
+     *  representation augmented with any Z (elevation) and M (measure) values carried by the instance.
+     *  
+     * @param wkt WKT
+     * @param srid SRID
+     * @return Geography instance
+     */
+    public static Geography STGeomFromText(String wkt, int srid) {
+        return new Geography(wkt, srid);
+    }
+    
+    /**
+     * Returns a Geography instance from an Open Geospatial Consortium (OGC) 
+     * Well-Known Binary (WKB) representation.
+     * 
+     * @param wkb WKB
+     * @return Geography instance
+     */
+    public static Geography STGeomFromWKB(byte[] wkb) {
+        return new Geography(wkb);
+    }
+    
+    /**
+     * Returns a constructed Geography from an internal SQL Server format for spatial data.
+     * 
+     * @param wkb WKB
+     * @return Geography instance
+     */
+    public static Geography deserialize(byte[] wkb) {
+        return new Geography(wkb);
+    }
+
+    /**
+     * Returns a Geography instance from an Open Geospatial Consortium (OGC) Well-Known Text (WKT) representation.
+     * SRID is defaulted to 4326.
+     * 
+     * @param wkt WKt
+     * @return Geography instance
+     */
+    public static Geography parse(String wkt) {
+        return new Geography(wkt, 4326);
+    }
+    
+    /**
+     * Constructs a Geography instance that represents a Point instance from its X and Y values and an SRID.
+     * 
+     * @param x x coordinate
+     * @param y y coordinate
+     * @param srid SRID
+     * @return Geography instance
+     */
+    public static Geography point(double x, double y, int srid) {
+        return new Geography("POINT (" + x + " " + y + ")", srid);
+    }
+
+    /**
+     * Returns the Open Geospatial Consortium (OGC) Well-Known Text (WKT) representation of a 
+     * Geography instance. This text will not contain any Z (elevation) or M (measure) values carried by the instance.
+     * 
+     * @return the WKT representation without the Z and M values.
+     */
+    public String STAsText() {
+        if (null == wktNoZM) {
+            buffer = ByteBuffer.wrap(wkb);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+            
+            parseWkb();
+            
+            WKTsb = new StringBuffer();
+            WKTsbNoZM = new StringBuffer();
+            constructWKT(this, internalType, numberOfPoints, numberOfFigures, numberOfSegments, numberOfShapes);
+            wktNoZM = WKTsbNoZM.toString();
+        }
+        return wktNoZM;
+    }
+    
+    /**
+     *  Returns the Open Geospatial Consortium (OGC) Well-Known Binary (WKB) representation of a 
+     *  Geography instance. This value will not contain any Z or M values carried by the instance.
+     * @return WKB
+     */
+    public byte[] STAsBinary() {
+        if (null == wkbNoZM) {
+            serializeToWkb(true);
+        }
+        return wkbNoZM;
+    }
+    
+    /**
+     *  Returns the bytes that represent an internal SQL Server format of Geography type.
+     * 
+     * @return WKB
+     */
+    public byte[] serialize() {
+        return wkb;
+    }
+    
+    public boolean hasM() {
+        return hasMvalues;
+    }
+    
+    public boolean hasZ() {
+        return hasZvalues;
+    }
+    
+    public Double getX() {
+        if (null != internalType && internalType == InternalSpatialDatatype.POINT && points.length == 2) {
+            return points[0];
+        }
+        return null;
+    }
+    
+    public Double getY() {
+        if (null != internalType && internalType == InternalSpatialDatatype.POINT && points.length == 2) {
+            return points[1];
+        }
+        return null;
+    }
+    
+    public Double getM() {
+        if (null != internalType && internalType == InternalSpatialDatatype.POINT && hasM()) {
+            return mValues[0];
+        }
+        return null;
+    }
+    
+    public Double getZ() {
+        if (null != internalType && internalType == InternalSpatialDatatype.POINT && hasZ()) {
+            return zValues[0];
+        }
+        return null;
+    }
+
+    public int getSrid() {
+        return srid;
+    }
+    
+    public boolean isNull() {
+        return isNull;
+    }
+    
+    public int STNumPoints() {
+        return numberOfPoints;
+    }
+
+    /**
+     * Returns the Open Geospatial Consortium (OGC) type name represented by a Geography instance.
+     * 
+     * @return type name
+     */
+    public String STGeographyType() {
+        if (null != internalType) {
+            return internalType.getTypeName();
+        }
+        return null;
+    }
+    
+    public String asTextZM() {
+        return wkt;
+    }
+    
+    public String toString() {
+        return wkt;
+    }
+
+    protected void serializeToWkb(boolean noZM) {
+        ByteBuffer buf = ByteBuffer.allocate(determineWkbCapacity());
+        createSerializationProperties();
+        
+        buf.order(ByteOrder.LITTLE_ENDIAN);
+        buf.putInt(srid);
+        buf.put(version);
+        buf.put(serializationProperties);
+        
+        if (!isSinglePoint && !isSingleLineSegment) {
+            buf.putInt(numberOfPoints);
+        }
+        
+        for (int i = 0; i < numberOfPoints; i++) {
+            buf.putDouble(points[2 * i + 1]);
+            buf.putDouble(points[2 * i]);
+        }
+        
+        if (!noZM) {
+            if (hasZvalues) {
+                for (int i = 0; i < numberOfPoints; i++) {
+                    buf.putDouble(zValues[i]);
+                }
+            }
+            
+            if (hasMvalues) {
+                for (int i = 0; i < numberOfPoints; i++) {
+                    buf.putDouble(mValues[i]);
+                }
+            }
+        }
+        
+        if (isSinglePoint || isSingleLineSegment) {
+            wkb = buf.array();
+            return;
+        }
+        
+        buf.putInt(numberOfFigures);
+        for (int i = 0; i < numberOfFigures; i++) {
+            buf.put(figures[i].getFiguresAttribute());
+            buf.putInt(figures[i].getPointOffset());
+        }
+        
+        buf.putInt(numberOfShapes);
+        for (int i = 0; i < numberOfShapes; i++) {
+            buf.putInt(shapes[i].getParentOffset());
+            buf.putInt(shapes[i].getFigureOffset());
+            buf.put(shapes[i].getOpenGISType());
+        }
+        
+        if (version == 2 && null != segments) {
+            buf.putInt(numberOfSegments);
+            for (int i = 0; i < numberOfSegments; i++) {
+                buf.put(segments[i].getSegmentType());
+            }
+        }
+        
+        if (noZM) { 
+            wkbNoZM = buf.array();
+        } else {
+            wkb = buf.array();
+
+        }
+        return;
+    }
+    
+    protected void parseWkb() {
+        srid = buffer.getInt();
+        version = buffer.get();
+        serializationProperties = buffer.get();
+        
+        interpretSerializationPropBytes();
+        readNumberOfPoints();
+        readPoints();
+        
+        if (hasZvalues) {
+            readZvalues();
+        }
+        
+        if (hasMvalues) {
+            readMvalues();
+        }
+        
+        if (!(isSinglePoint || isSingleLineSegment)) {
+            readNumberOfFigures();
+            readFigures();
+            readNumberOfShapes();
+            readShapes();
+        }
+        
+        determineInternalType();
+
+        if (buffer.hasRemaining()) {
+            if (version == 2 && internalType.getTypeCode() != 8 && internalType.getTypeCode() != 11) {
+                readNumberOfSegments();
+                readSegments();
+            }
+        }
+    }
+    
+    private void readPoints() {
+        points = new double[2 * numberOfPoints];
+        for (int i = 0; i < numberOfPoints; i++) {
+            points[2 * i + 1] = buffer.getDouble();
+            points[2 * i] = buffer.getDouble();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Geometry.java b/src/main/java/com/microsoft/sqlserver/jdbc/Geometry.java
new file mode 100644
index 000000000..5966d5fe9
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/Geometry.java
@@ -0,0 +1,332 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Locale;
+
+public class Geometry extends SQLServerSpatialDatatype {
+    
+    /**
+     * Private constructor used for creating a Geometry object from WKT and srid.
+     */
+    private Geometry(String WellKnownText, int srid) {
+        this.wkt = WellKnownText;
+        this.srid = srid;
+        
+        try {
+            parseWKTForSerialization(this, currentWktPos, -1, false);
+        }
+        catch (StringIndexOutOfBoundsException e) {
+            throw new IllegalArgumentException("Reached unexpected end of WKT. Please make sure WKT is valid.");
+        }
+        
+        serializeToWkb(false);
+        isNull = false;
+    }
+
+    /**
+     * Private constructor used for creating a Geometry object from WKB.
+     */
+    private Geometry(byte[] wkb) {
+        this.wkb = wkb;
+        buffer = ByteBuffer.wrap(wkb);
+        buffer.order(ByteOrder.LITTLE_ENDIAN);
+        
+        parseWkb();
+        
+        WKTsb = new StringBuffer();
+        WKTsbNoZM = new StringBuffer();
+        
+        constructWKT(this, internalType, numberOfPoints, numberOfFigures, numberOfSegments, numberOfShapes);
+        
+        wkt = WKTsb.toString();
+        wktNoZM = WKTsbNoZM.toString();
+        isNull = false;
+    }
+    
+    public Geometry() {
+        // TODO Auto-generated constructor stub
+    }
+    
+    /**
+     * Returns a Geometry instance from an Open Geospatial Consortium (OGC) Well-Known Text (WKT)
+     *  representation augmented with any Z (elevation) and M (measure) values carried by the instance.
+     *  
+     * @param wkt WKT
+     * @param srid SRID
+     * @return Geometry instance
+     */
+    public static Geometry STGeomFromText(String wkt, int srid) {
+        return new Geometry(wkt, srid);
+    }
+    
+    /**
+     * Returns a Geometry instance from an Open Geospatial Consortium (OGC) 
+     * Well-Known Binary (WKB) representation.
+     * 
+     * @param wkb WKB
+     * @return Geometry instance
+     */
+    public static Geometry STGeomFromWKB(byte[] wkb) {
+        return new Geometry(wkb);
+    }
+    
+    /**
+     * Returns a constructed Geometry from an internal SQL Server format for spatial data.
+     * 
+     * @param wkb WKB
+     * @return Geometry instance
+     */
+    public static Geometry deserialize(byte[] wkb) {
+        return new Geometry(wkb);
+    }
+
+    /**
+     * Returns a Geometry instance from an Open Geospatial Consortium (OGC) Well-Known Text (WKT) representation.
+     * SRID is defaulted to 0.
+     * 
+     * @param wkt WKT
+     * @return Geometry instance
+     */
+    public static Geometry parse(String wkt) {
+        return new Geometry(wkt, 0);
+    }
+    
+    /**
+     * Constructs a Geometry instance that represents a Point instance from its X and Y values and an SRID.
+     * 
+     * @param x x coordinate
+     * @param y y coordinate
+     * @param srid SRID
+     * @return Geometry instance
+     */
+    public static Geometry point(double x, double y, int srid) {
+        return new Geometry("POINT (" + x + " " + y + ")", srid);
+    }
+    
+    /**
+     * Returns the Open Geospatial Consortium (OGC) Well-Known Text (WKT) representation of a 
+     * Geometry instance. This text will not contain any Z (elevation) or M (measure) values carried by the instance.
+     * 
+     * @return the WKT representation without the Z and M values.
+     */
+    public String STAsText() {
+        if (null == wktNoZM) {
+            buffer = ByteBuffer.wrap(wkb);
+            buffer.order(ByteOrder.LITTLE_ENDIAN);
+            
+            parseWkb();
+            
+            WKTsb = new StringBuffer();
+            WKTsbNoZM = new StringBuffer();
+            constructWKT(this, internalType, numberOfPoints, numberOfFigures, numberOfSegments, numberOfShapes);
+            wktNoZM = WKTsbNoZM.toString();
+        }
+        return wktNoZM;
+    }
+    
+    /**
+     *  Returns the Open Geospatial Consortium (OGC) Well-Known Binary (WKB) representation of a 
+     *  Geometry instance. This value will not contain any Z or M values carried by the instance.
+     * @return WKB
+     */
+    public byte[] STAsBinary() {
+        if (null == wkbNoZM) {
+            serializeToWkb(true);
+        }
+        return wkbNoZM;
+    }
+    
+    /**
+     *  Returns the bytes that represent an internal SQL Server format of Geometry type.
+     * 
+     * @return WKB
+     */
+    public byte[] serialize() {
+        return wkb;
+    }
+    
+    public boolean hasM() {
+        return hasMvalues;
+    }
+    
+    public boolean hasZ() {
+        return hasZvalues;
+    }
+    
+    public Double getX() {
+        if (null != internalType && internalType == InternalSpatialDatatype.POINT && points.length == 2) {
+            return points[0];
+        }
+        return null;
+    }
+    
+    public Double getY() {
+        if (null != internalType && internalType == InternalSpatialDatatype.POINT && points.length == 2) {
+            return points[1];
+        }
+        return null;
+    }
+    
+    public Double getM() {
+        if (null != internalType && internalType == InternalSpatialDatatype.POINT && hasM()) {
+            return mValues[0];
+        }
+        return null;
+    }
+    
+    public Double getZ() {
+        if (null != internalType && internalType == InternalSpatialDatatype.POINT && hasZ()) {
+            return zValues[0];
+        }
+        return null;
+    }
+
+    public int getSrid() {
+        return srid;
+    }
+    
+    public boolean isNull() {
+        return isNull;
+    }
+    
+    public int STNumPoints() {
+        return numberOfPoints;
+    }
+
+    /**
+     * Returns the Open Geospatial Consortium (OGC) type name represented by a geometry instance.
+     * 
+     * @return type name
+     */
+    public String STGeometryType() {
+        if (null != internalType) {
+            return internalType.getTypeName();
+        }
+        return null;
+    }
+    
+    public String asTextZM() {
+        return wkt;
+    }
+    
+    public String toString() {
+        return wkt;
+    }
+    
+    protected void serializeToWkb(boolean noZM) {
+        ByteBuffer buf = ByteBuffer.allocate(determineWkbCapacity());
+        createSerializationProperties();
+        
+        buf.order(ByteOrder.LITTLE_ENDIAN);
+        buf.putInt(srid);
+        buf.put(version);
+        buf.put(serializationProperties);
+        
+        if (!isSinglePoint && !isSingleLineSegment) {
+            buf.putInt(numberOfPoints);
+        }
+        
+        for (int i = 0; i < numberOfPoints; i++) {
+            buf.putDouble(points[2 * i]);
+            buf.putDouble(points[2 * i + 1]);
+        }
+        
+        if (!noZM ) {
+            if (hasZvalues) {
+                for (int i = 0; i < numberOfPoints; i++) {
+                    buf.putDouble(zValues[i]);
+                }
+            }
+            
+            if (hasMvalues) {
+                for (int i = 0; i < numberOfPoints; i++) {
+                    buf.putDouble(mValues[i]);
+                }
+            }
+        }
+        
+        if (isSinglePoint || isSingleLineSegment) {
+            wkb = buf.array();
+            return;
+        }
+        
+        buf.putInt(numberOfFigures);
+        for (int i = 0; i < numberOfFigures; i++) {
+            buf.put(figures[i].getFiguresAttribute());
+            buf.putInt(figures[i].getPointOffset());
+        }
+        
+        buf.putInt(numberOfShapes);
+        for (int i = 0; i < numberOfShapes; i++) {
+            buf.putInt(shapes[i].getParentOffset());
+            buf.putInt(shapes[i].getFigureOffset());
+            buf.put(shapes[i].getOpenGISType());
+        }
+        
+        if (version == 2 && null != segments) {
+            buf.putInt(numberOfSegments);
+            for (int i = 0; i < numberOfSegments; i++) {
+                buf.put(segments[i].getSegmentType());
+            }
+        }
+        
+        if (noZM) { 
+            wkbNoZM = buf.array();
+        } else {
+            wkb = buf.array();
+
+        }
+        return;
+    }
+    
+    protected void parseWkb() {
+        srid = buffer.getInt();
+        version = buffer.get();
+        serializationProperties = buffer.get();
+        
+        interpretSerializationPropBytes();
+        readNumberOfPoints();
+        readPoints();
+        
+        if (hasZvalues) {
+            readZvalues();
+        }
+        
+        if (hasMvalues) {
+            readMvalues();
+        }
+        
+        if (!(isSinglePoint || isSingleLineSegment)) {
+            readNumberOfFigures();
+            readFigures();
+            readNumberOfShapes();
+            readShapes();
+        }
+        
+        determineInternalType();
+
+        if (buffer.hasRemaining()) {
+            if (version == 2 && internalType.getTypeCode() != 8 && internalType.getTypeCode() != 11) {
+                readNumberOfSegments();
+                readSegments();
+            }
+        }
+    }
+    
+    private void readPoints() {
+        points = new double[2 * numberOfPoints];
+        for (int i = 0; i < numberOfPoints; i++) {
+            points[2 * i] = buffer.getDouble();
+            points[2 * i + 1] = buffer.getDouble();
+        }
+    }
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/InternalSpatialDatatype.java b/src/main/java/com/microsoft/sqlserver/jdbc/InternalSpatialDatatype.java
new file mode 100644
index 000000000..a4fc6edfb
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/InternalSpatialDatatype.java
@@ -0,0 +1,41 @@
+package com.microsoft.sqlserver.jdbc;
+
+public enum InternalSpatialDatatype {
+    POINT((byte)1, "POINT"),
+    LINESTRING((byte)2, "LINESTRING"),
+    POLYGON((byte)3, "POLYGON"),
+    MULTIPOINT((byte)4, "MULTIPOINT"),
+    MULTILINESTRING((byte)5, "MULTILINESTRING"),
+    MULTIPOLYGON((byte)6, "MULTIPOLYGON"),
+    GEOMETRYCOLLECTION((byte)7, "GEOMETRYCOLLECTION"),
+    CIRCULARSTRING((byte)8, "CIRCULARSTRING"),
+    COMPOUNDCURVE((byte)9, "COMPOUNDCURVE"),
+    CURVEPOLYGON((byte)10, "CURVEPOLYGON"),
+    FULLGLOBE((byte)11, "FULLGLOBE"),
+    INVALID_TYPE((byte)0, null);
+    
+    private byte typeCode;
+    private String typeName;
+    
+    private InternalSpatialDatatype(byte typeCode, String typeName) {
+        this.typeCode = typeCode;
+        this.typeName = typeName;
+    }
+    
+    public byte getTypeCode() {
+        return this.typeCode;
+    }
+    
+    public String getTypeName() {
+        return this.typeName;
+    }
+    
+    public static InternalSpatialDatatype valueOf(byte typeCode) {
+        for (InternalSpatialDatatype internalType : values()) {
+            if (internalType.typeCode == typeCode) {
+                return internalType;
+            }
+        }
+        return INVALID_TYPE;
+    }
+}
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java
index 86edb5d8a..b614ad5fe 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/Parameter.java
@@ -580,7 +580,9 @@ private void setTypeDefinition(DTV dtv) {
                          * specific type info, otherwise generic type info can be used as before.
                          */
                         if (0 == valueLength) {
-                            param.typeDefinition = "varbinary";
+                            // Workaround for the issue when inserting empty string and null into encrypted columns
+                            param.typeDefinition = "varbinary(1)";
+                            valueLength++;
                         }
                         else {
                             param.typeDefinition = "varbinary(" + valueLength + ")";
@@ -721,7 +723,9 @@ private void setTypeDefinition(DTV dtv) {
                          * specific type info, otherwise generic type info can be used as before.
                          */
                         if (0 == valueLength) {
-                            param.typeDefinition = "varchar";
+                            // Workaround for the issue when inserting empty string and null into encrypted columns
+                            param.typeDefinition = "varchar(1)";
+                            valueLength++;
                         }
                         else {
                             param.typeDefinition = "varchar(" + valueLength + ")";
@@ -745,7 +749,9 @@ private void setTypeDefinition(DTV dtv) {
                         if ((null != jdbcTypeSetByUser) && ((jdbcTypeSetByUser == JDBCType.VARCHAR) || (jdbcTypeSetByUser == JDBCType.CHAR)
                                 || (jdbcTypeSetByUser == JDBCType.LONGVARCHAR))) {
                             if (0 == valueLength) {
-                                param.typeDefinition = "varchar";
+                                // Workaround for the issue when inserting empty string and null into encrypted columns
+                                param.typeDefinition = "varchar(1)";
+                                valueLength++;
                             }
                             else if (DataTypes.SHORT_VARTYPE_MAX_BYTES < valueLength) {
                                 param.typeDefinition = VARCHAR_MAX;
@@ -761,7 +767,9 @@ else if (DataTypes.SHORT_VARTYPE_MAX_BYTES < valueLength) {
                         else if ((null != jdbcTypeSetByUser)
                                 && (jdbcTypeSetByUser == JDBCType.NVARCHAR || jdbcTypeSetByUser == JDBCType.LONGNVARCHAR)) {
                             if (0 == valueLength) {
-                                param.typeDefinition = "nvarchar";
+                                // Workaround for the issue when inserting empty string and null into encrypted columns
+                                param.typeDefinition = "nvarchar(1)";
+                                valueLength++;
                             }
                             else if (DataTypes.SHORT_VARTYPE_MAX_CHARS < valueLength) {
                                 param.typeDefinition = NVARCHAR_MAX;
@@ -776,7 +784,9 @@ else if (DataTypes.SHORT_VARTYPE_MAX_CHARS < valueLength) {
                         }
                         else { // used if setNull() is called with java.sql.Types.NCHAR
                             if (0 == valueLength) {
-                                param.typeDefinition = "nvarchar";
+                                // Workaround for the issue when inserting empty string and null into encrypted columns
+                                param.typeDefinition = "nvarchar(1)";
+                                valueLength++;
                             }
                             else {
                                 param.typeDefinition = "nvarchar(" + valueLength + ")";
@@ -813,7 +823,9 @@ else if (DataTypes.SHORT_VARTYPE_MAX_CHARS < valueLength) {
                         if ((null != jdbcTypeSetByUser) && ((jdbcTypeSetByUser == JDBCType.VARCHAR) || (jdbcTypeSetByUser == JDBCType.CHAR)
                                 || (JDBCType.LONGVARCHAR == jdbcTypeSetByUser))) {
                             if (0 == valueLength) {
-                                param.typeDefinition = "varchar";
+                                // Workaround for the issue when inserting empty string and null into encrypted columns
+                                param.typeDefinition = "varchar(1)";
+                                valueLength++;
                             }
                             else {
                                 param.typeDefinition = "varchar(" + valueLength + ")";
@@ -830,7 +842,9 @@ else if (DataTypes.SHORT_VARTYPE_MAX_CHARS < valueLength) {
                         else if ((null != jdbcTypeSetByUser) && ((jdbcTypeSetByUser == JDBCType.NVARCHAR) || (jdbcTypeSetByUser == JDBCType.NCHAR)
                                 || (JDBCType.LONGNVARCHAR == jdbcTypeSetByUser))) {
                             if (0 == valueLength) {
-                                param.typeDefinition = "nvarchar";
+                                // Workaround for the issue when inserting empty string and null into encrypted columns
+                                param.typeDefinition = "nvarchar(1)";
+                                valueLength++;
                             }
                             else {
                                 param.typeDefinition = "nvarchar(" + valueLength + ")";
@@ -846,7 +860,9 @@ else if ((null != jdbcTypeSetByUser) && ((jdbcTypeSetByUser == JDBCType.NVARCHAR
                         }
                         else { // used if setNull() is called with java.sql.Types.NCHAR
                             if (0 == valueLength) {
-                                param.typeDefinition = "nvarchar";
+                                // Workaround for the issue when inserting empty string and null into encrypted columns
+                                param.typeDefinition = "nvarchar(1)";
+                                valueLength++;
                             }
                             else {
                                 param.typeDefinition = "nvarchar(" + valueLength + ")";
@@ -885,6 +901,14 @@ else if ((null != jdbcTypeSetByUser) && ((jdbcTypeSetByUser == JDBCType.NVARCHAR
                 case SQL_VARIANT:
                     param.typeDefinition = SSType.SQL_VARIANT.toString();
                     break;
+                
+                case GEOMETRY:
+                    param.typeDefinition = SSType.GEOMETRY.toString();
+                    break;
+                    
+                case GEOGRAPHY:
+                    param.typeDefinition = SSType.GEOGRAPHY.toString();
+                    break;
                 default:
                     assert false : "Unexpected JDBC type " + dtv.getJdbcType();
                     break;
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLJdbcVersion.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLJdbcVersion.java
index 9aaaa8f52..eee5f7aa6 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLJdbcVersion.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLJdbcVersion.java
@@ -10,7 +10,7 @@
 
 final class SQLJdbcVersion {
     static final int major = 6;
-    static final int minor = 4;
+    static final int minor = 5;
     static final int patch = 0;
     static final int build = 0;
 }
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java
index 47927d6a6..9dc401717 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java
@@ -232,10 +232,23 @@ public byte[] getBytes(long pos,
      */
     public long length() throws SQLException {
         checkClosed();
+        if (value == null && activeStreams.get(0) instanceof PLPInputStream) {
+        	return (long)((PLPInputStream)activeStreams.get(0)).payloadLength;
+        }
         getBytesFromStream();
         return value.length;
     }
     
+    /**
+     * Function for the result set to maintain blobs it has created
+     * @throws SQLException
+     */
+    void fillByteArray() throws SQLException {
+    	if(!isClosed) {
+    		getBytesFromStream();
+    	}
+    }
+    
     /**
      * Converts stream to byte[]
      * @throws SQLServerException
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java
index 5ad8689c8..c30eab2fa 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java
@@ -1450,6 +1450,8 @@ public NClob getNClob(String parameterName) throws SQLException {
         int l = 0;
         if (paramNames != null)
             l = paramNames.size();
+        if (l == 0)//Server didn't return anything, user might not have access
+        	return 1;//attempting to look up the first column will return no access exception
 
         // handle `@name` as well as `name`, since `@name` is what's returned 
         // by DatabaseMetaData#getProcedureColumns
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java
index 92ab65877..3ec82dc11 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java
@@ -15,6 +15,7 @@
 import java.sql.ResultSet;
 import java.sql.RowIdLifetime;
 import java.sql.SQLException;
+import java.sql.SQLTimeoutException;
 import java.text.MessageFormat;
 import java.util.EnumMap;
 import java.util.Properties;
@@ -237,9 +238,10 @@ private void checkClosed() throws SQLServerException {
      * @param query
      *            to execute
      * @return Resultset from the execution
+     * @throws SQLTimeoutException 
      */
     private SQLServerResultSet getResultSetFromInternalQueries(String catalog,
-            String query) throws SQLServerException {
+            String query) throws SQLServerException, SQLTimeoutException {
         checkClosed();
         String orgCat = null;
         orgCat = switchCatalogs(catalog);
@@ -287,10 +289,11 @@ private CallableStatement getCallableStatementHandle(CallableHandles request,
      * @param arguments
      *            for the stored procedure
      * @return Resultset from the execution
+     * @throws SQLTimeoutException 
      */
     private SQLServerResultSet getResultSetFromStoredProc(String catalog,
             CallableHandles procedure,
-            String[] arguments) throws SQLServerException {
+            String[] arguments) throws SQLServerException, SQLTimeoutException {
         checkClosed();
         assert null != arguments;
         String orgCat = null;
@@ -316,7 +319,7 @@ private SQLServerResultSet getResultSetFromStoredProc(String catalog,
     private SQLServerResultSet getResultSetWithProvidedColumnNames(String catalog,
             CallableHandles procedure,
             String[] arguments,
-            String[] columnNames) throws SQLServerException {
+            String[] columnNames) throws SQLServerException, SQLTimeoutException {
         // Execute the query
         SQLServerResultSet rs = getResultSetFromStoredProc(catalog, procedure, arguments);
 
@@ -408,7 +411,7 @@ public boolean supportsSharding() throws SQLException {
         return false;
     }
 
-    /* L0 */ public java.sql.ResultSet getCatalogs() throws SQLServerException {
+    /* L0 */ public java.sql.ResultSet getCatalogs() throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -434,7 +437,7 @@ public boolean supportsSharding() throws SQLException {
     /* L0 */ public java.sql.ResultSet getColumnPrivileges(String catalog,
             String schema,
             String table,
-            String col) throws SQLServerException {
+            String col) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -460,7 +463,7 @@ public boolean supportsSharding() throws SQLException {
     /* L0 */ public java.sql.ResultSet getTables(String catalog,
             String schema,
             String table,
-            String types[]) throws SQLServerException {
+            String types[]) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -570,7 +573,7 @@ private static String EscapeIDName(String inID) throws SQLServerException {
     /* L0 */ public java.sql.ResultSet getColumns(String catalog,
             String schema,
             String table,
-            String col) throws SQLServerException {
+            String col) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -709,7 +712,7 @@ public java.sql.ResultSet getClientInfoProperties() throws SQLException {
             String schema,
             String table,
             int scope,
-            boolean nullable) throws SQLServerException {
+            boolean nullable) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -751,7 +754,7 @@ public java.sql.ResultSet getClientInfoProperties() throws SQLException {
             String tab1,
             String cat2,
             String schem2,
-            String tab2) throws SQLServerException {
+            String tab2) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -817,7 +820,7 @@ public java.sql.ResultSet getClientInfoProperties() throws SQLException {
 
     /* L0 */ public java.sql.ResultSet getExportedKeys(String cat,
             String schema,
-            String table) throws SQLServerException {
+            String table) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -852,7 +855,7 @@ public java.sql.ResultSet getClientInfoProperties() throws SQLException {
 
     /* L0 */ public java.sql.ResultSet getImportedKeys(String cat,
             String schema,
-            String table) throws SQLServerException {
+            String table) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -882,8 +885,9 @@ public java.sql.ResultSet getClientInfoProperties() throws SQLException {
      * @param sp_fkeys_Query
      * @return
      * @throws SQLServerException
+     * @throws SQLTimeoutException 
      */
-    private ResultSet getResultSetForForeignKeyInformation(SQLServerResultSet fkeysRS, String cat) throws SQLServerException {
+    private ResultSet getResultSetForForeignKeyInformation(SQLServerResultSet fkeysRS, String cat) throws SQLServerException, SQLTimeoutException {
         UUID uuid = UUID.randomUUID();
         String fkeys_results_tableName = "[#fkeys_results" + uuid + "]";
         String foreign_keys_combined_tableName = "[#foreign_keys_combined_results" + uuid + "]";
@@ -1020,7 +1024,7 @@ private ResultSet getResultSetForForeignKeyInformation(SQLServerResultSet fkeysR
             String schema,
             String table,
             boolean unique,
-            boolean approximate) throws SQLServerException {
+            boolean approximate) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1091,7 +1095,7 @@ private ResultSet getResultSetForForeignKeyInformation(SQLServerResultSet fkeysR
         return 1024;
     }
 
-    /* L0 */ public int getMaxConnections() throws SQLServerException {
+    /* L0 */ public int getMaxConnections() throws SQLServerException, SQLTimeoutException {
         checkClosed();
         try {
             String s = "sp_configure 'user connections'";
@@ -1171,7 +1175,7 @@ private ResultSet getResultSetForForeignKeyInformation(SQLServerResultSet fkeysR
 
     /* L0 */ public java.sql.ResultSet getPrimaryKeys(String cat,
             String schema,
-            String table) throws SQLServerException {
+            String table) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1194,7 +1198,7 @@ private ResultSet getResultSetForForeignKeyInformation(SQLServerResultSet fkeysR
     /* L0 */ public java.sql.ResultSet getProcedureColumns(String catalog,
             String schema,
             String proc,
-            String col) throws SQLServerException {
+            String col) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1236,7 +1240,7 @@ private ResultSet getResultSetForForeignKeyInformation(SQLServerResultSet fkeysR
 
     /* L0 */ public java.sql.ResultSet getProcedures(String catalog,
             String schema,
-            String proc) throws SQLServerException {
+            String proc) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1286,7 +1290,7 @@ public ResultSet getPseudoColumns(String catalog,
         /* 13 */ " cast(NULL as char(1)) as IS_NULLABLE" + " where 0 = 1");
     }
 
-    /* L0 */ public java.sql.ResultSet getSchemas() throws SQLServerException {
+    /* L0 */ public java.sql.ResultSet getSchemas() throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1296,7 +1300,7 @@ public ResultSet getPseudoColumns(String catalog,
     }
 
     private java.sql.ResultSet getSchemasInternal(String catalog,
-            String schemaPattern) throws SQLServerException {
+            String schemaPattern) throws SQLServerException, SQLTimeoutException {
 
         String s;
         // The schemas that return null for catalog name, these are prebuilt schemas shipped by SQLServer, if SQLServer adds anymore of these
@@ -1401,7 +1405,7 @@ public java.sql.ResultSet getSchemas(String catalog,
 
     /* L0 */ public java.sql.ResultSet getTablePrivileges(String catalog,
             String schema,
-            String table) throws SQLServerException {
+            String table) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1420,7 +1424,7 @@ public java.sql.ResultSet getSchemas(String catalog,
         return getResultSetWithProvidedColumnNames(catalog, CallableHandles.SP_TABLE_PRIVILEGES, arguments, getTablePrivilegesColumnNames);
     }
 
-    /* L0 */ public java.sql.ResultSet getTableTypes() throws SQLServerException {
+    /* L0 */ public java.sql.ResultSet getTableTypes() throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1435,7 +1439,7 @@ public java.sql.ResultSet getSchemas(String catalog,
         return "CURDATE,CURTIME,DAYNAME,DAYOFMONTH,DAYOFWEEK,DAYOFYEAR,HOUR,MINUTE,MONTH,MONTHNAME,NOW,QUARTER,SECOND,TIMESTAMPADD,TIMESTAMPDIFF,WEEK,YEAR";
     }
 
-    /* L0 */ public java.sql.ResultSet getTypeInfo() throws SQLServerException {
+    /* L0 */ public java.sql.ResultSet getTypeInfo() throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1517,7 +1521,7 @@ else if (name.equals(SQLServerDriverIntProperty.PORT_NUMBER.toString())) {
         return (url.toString());
     }
 
-    /* L0 */ public String getUserName() throws SQLServerException {
+    /* L0 */ public String getUserName() throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -1551,7 +1555,7 @@ else if (name.equals(SQLServerDriverIntProperty.PORT_NUMBER.toString())) {
 
     /* L0 */ public java.sql.ResultSet getVersionColumns(String catalog,
             String schema,
-            String table) throws SQLServerException {
+            String table) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -2093,7 +2097,7 @@ else if (name.equals(SQLServerDriverIntProperty.PORT_NUMBER.toString())) {
     /* L0 */ public java.sql.ResultSet getUDTs(String catalog,
             String schemaPattern,
             String typeNamePattern,
-            int[] types) throws SQLServerException {
+            int[] types) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -2187,7 +2191,7 @@ public RowIdLifetime getRowIdLifetime() throws SQLException {
     /* L3 */ public ResultSet getAttributes(String catalog,
             String schemaPattern,
             String typeNamePattern,
-            String attributeNamePattern) throws SQLServerException {
+            String attributeNamePattern) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -2218,7 +2222,7 @@ public RowIdLifetime getRowIdLifetime() throws SQLException {
 
     /* L3 */ public ResultSet getSuperTables(String catalog,
             String schemaPattern,
-            String tableNamePattern) throws SQLServerException {
+            String tableNamePattern) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -2232,7 +2236,7 @@ public RowIdLifetime getRowIdLifetime() throws SQLException {
 
     /* L3 */ public ResultSet getSuperTypes(String catalog,
             String schemaPattern,
-            String typeNamePattern) throws SQLServerException {
+            String typeNamePattern) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
@@ -2400,4 +2404,4 @@ final Object apply(Object value,
         }
     }
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
index 20e18255b..80629cc64 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java
@@ -71,6 +71,7 @@ public final class SQLServerException extends java.sql.SQLException {
     static final int DRIVER_ERROR_UNSUPPORTED_CONFIG = 6;
     static final int DRIVER_ERROR_INTERMITTENT_TLS_FAILED = 7;
     static final int ERROR_SOCKET_TIMEOUT = 8;
+    static final int ERROR_QUERY_TIMEOUT = 9;
     private int driverErrorCode = DRIVER_ERROR_NONE;
 
     final int getDriverErrorCode() {
@@ -114,6 +115,10 @@ final void setDriverErrorCode(int value) {
                 exLogger.fine(sb.toString());
             }
         }
+        if (errText.equals(SQLServerException.getErrString("R_queryTimedOut")))
+        {
+        	this.setDriverErrorCode(SQLServerException.ERROR_QUERY_TIMEOUT);
+        }
     }
 
     static String getErrString(String errCode) {
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java
index 262728a94..7106d9f10 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java
@@ -21,6 +21,7 @@
 import java.sql.RowId;
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
+import java.sql.SQLTimeoutException;
 import java.sql.SQLXML;
 import java.sql.Statement;
 import java.text.MessageFormat;
@@ -390,9 +391,11 @@ private String buildParamTypeDefinitions(Parameter[] params,
      *
      * @throws SQLServerException
      *             when an error occurs
+     * @throws SQLTimeoutException 
+     * 			   when the query times out
      * @return ResultSet
      */
-    public java.sql.ResultSet executeQuery() throws SQLServerException {
+    public java.sql.ResultSet executeQuery() throws SQLServerException, SQLTimeoutException {
         loggerExternal.entering(getClassNameLogging(), "executeQuery");
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
@@ -408,14 +411,15 @@ public java.sql.ResultSet executeQuery() throws SQLServerException {
      *
      * @throws SQLServerException
      * @return ResultSet
+     * @throws SQLTimeoutException 
      */
-    final java.sql.ResultSet executeQueryInternal() throws SQLServerException {
+    final java.sql.ResultSet executeQueryInternal() throws SQLServerException, SQLTimeoutException {
         checkClosed();
         executeStatement(new PrepStmtExecCmd(this, EXECUTE_QUERY_INTERNAL));
         return resultSet;
     }
 
-    public int executeUpdate() throws SQLServerException {
+    public int executeUpdate() throws SQLServerException, SQLTimeoutException {
         loggerExternal.entering(getClassNameLogging(), "executeUpdate");
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
@@ -434,7 +438,7 @@ public int executeUpdate() throws SQLServerException {
         return (int) updateCount;
     }
 
-    public long executeLargeUpdate() throws SQLServerException {
+    public long executeLargeUpdate() throws SQLServerException, SQLTimeoutException {
         DriverJDBCVersion.checkSupportsJDBC42();
 
         loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate");
@@ -452,9 +456,11 @@ public long executeLargeUpdate() throws SQLServerException {
      * 
      * @throws SQLServerException
      *             when an error occurs
+     * @throws SQLTimeoutException 
+     * 			   when the query times out
      * @return true if the statement returned a result set
      */
-    public boolean execute() throws SQLServerException {
+    public boolean execute() throws SQLServerException, SQLTimeoutException {
         loggerExternal.entering(getClassNameLogging(), "execute");
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
@@ -1579,6 +1585,24 @@ public final void setFloat(int n,
         setValue(n, JDBCType.REAL, x, JavaType.FLOAT, forceEncrypt);
         loggerExternal.exiting(getClassNameLogging(), "setFloat");
     }
+    
+    public final void setGeometry(int n,
+            Geometry x) throws SQLServerException {
+        if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
+            loggerExternal.entering(getClassNameLogging(), "setGeometry", new Object[] {n, x});
+        checkClosed();
+        setValue(n, JDBCType.GEOMETRY, x, JavaType.STRING, false);
+        loggerExternal.exiting(getClassNameLogging(), "setGeometry");
+    }
+    
+    public final void setGeography(int n,
+            Geography x) throws SQLServerException {
+        if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
+            loggerExternal.entering(getClassNameLogging(), "setGeography", new Object[] {n, x});
+        checkClosed();
+        setValue(n, JDBCType.GEOGRAPHY, x, JavaType.STRING, false);
+        loggerExternal.exiting(getClassNameLogging(), "setGeography");
+    }
 
     public final void setInt(int n,
             int value) throws SQLServerException {
@@ -2421,7 +2445,7 @@ public final void addBatch() throws SQLServerException {
         loggerExternal.exiting(getClassNameLogging(), "clearBatch");
     }
 
-    public int[] executeBatch() throws SQLServerException, BatchUpdateException {
+    public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQLTimeoutException {
         loggerExternal.entering(getClassNameLogging(), "executeBatch");
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
@@ -2476,7 +2500,7 @@ public int[] executeBatch() throws SQLServerException, BatchUpdateException {
         return updateCounts;
     }
 
-    public long[] executeLargeBatch() throws SQLServerException, BatchUpdateException {
+    public long[] executeLargeBatch() throws SQLServerException, BatchUpdateException, SQLTimeoutException {
         DriverJDBCVersion.checkSupportsJDBC42();
 
         loggerExternal.entering(getClassNameLogging(), "executeLargeBatch");
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java
index 37e1ac033..b993a6d3c 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java
@@ -126,6 +126,7 @@ final void setCurrentRowType(RowType rowType) {
      * occurs
      */
     private Closeable activeStream;
+    private Blob activeBlob;
 
     /**
      * A window of fetchSize quickly accessible rows for scrollable result sets
@@ -669,6 +670,7 @@ final Column getColumn(int columnIndex) throws SQLServerException {
         // before moving to another one.
         if (null != activeStream) {
             try {
+            	fillBlobs();
                 activeStream.close();
             }
             catch (IOException e) {
@@ -747,6 +749,7 @@ private Column loadColumn(int index) throws SQLServerException {
     /* ----------------- JDBC API methods ------------------ */
 
     private void moverInit() throws SQLServerException {
+    	fillBlobs();
         cancelInsert();
         cancelUpdates();
     }
@@ -1035,6 +1038,7 @@ public boolean next() throws SQLServerException {
     public boolean wasNull() throws SQLServerException {
         loggerExternal.entering(getClassNameLogging(), "wasNull");
         checkClosed();
+        fillBlobs();
         loggerExternal.exiting(getClassNameLogging(), "wasNull", lastValueWasNull);
         return lastValueWasNull;
     }
@@ -1892,6 +1896,7 @@ Column getterGetColumn(int index) throws SQLServerException {
         if (logger.isLoggable(java.util.logging.Level.FINER))
             logger.finer(toString() + " Getting Column:" + index);
 
+        fillBlobs();
         return loadColumn(index);
     }
 
@@ -2120,6 +2125,38 @@ public float getFloat(String columnName) throws SQLServerException {
         loggerExternal.exiting(getClassNameLogging(), "getFloat", value);
         return null != value ? value : 0;
     }
+    
+    public Geometry getGeometry(int columnIndex) throws SQLServerException {
+        loggerExternal.entering(getClassNameLogging(), "getFloat", columnIndex);
+        checkClosed();
+        Geometry value = (Geometry) getValue(columnIndex, JDBCType.GEOMETRY);
+        loggerExternal.exiting(getClassNameLogging(), "getFloat", value);
+        return value;
+    }
+
+    public Geometry getGeometry(String columnName) throws SQLServerException {
+        loggerExternal.entering(getClassNameLogging(), "getFloat", columnName);
+        checkClosed();
+        Geometry value = (Geometry) getValue(findColumn(columnName), JDBCType.GEOMETRY);
+        loggerExternal.exiting(getClassNameLogging(), "getFloat", value);
+        return value;
+    }
+    
+    public Geography getGeography(int columnIndex) throws SQLServerException {
+        loggerExternal.entering(getClassNameLogging(), "getFloat", columnIndex);
+        checkClosed();
+        Geography value = (Geography) getValue(columnIndex, JDBCType.GEOGRAPHY);
+        loggerExternal.exiting(getClassNameLogging(), "getFloat", value);
+        return value;
+    }
+
+    public Geography getGeography(String columnName) throws SQLServerException {
+        loggerExternal.entering(getClassNameLogging(), "getFloat", columnName);
+        checkClosed();
+        Geography value = (Geography) getValue(findColumn(columnName), JDBCType.GEOGRAPHY);
+        loggerExternal.exiting(getClassNameLogging(), "getFloat", value);
+        return value;
+    }
 
     public int getInt(int columnIndex) throws SQLServerException {
         loggerExternal.entering(getClassNameLogging(), "getInt", columnIndex);
@@ -2657,6 +2694,7 @@ public Blob getBlob(int i) throws SQLServerException {
         checkClosed();
         Blob value = (Blob) getValue(i, JDBCType.BLOB);
         loggerExternal.exiting(getClassNameLogging(), "getBlob", value);
+        activeBlob = value;
         return value;
     }
 
@@ -2665,6 +2703,7 @@ public Blob getBlob(String colName) throws SQLServerException {
         checkClosed();
         Blob value = (Blob) getValue(findColumn(colName), JDBCType.BLOB);
         loggerExternal.exiting(getClassNameLogging(), "getBlob", value);
+        activeBlob = value;
         return value;
     }
 
@@ -6507,6 +6546,24 @@ final void doServerFetch(int fetchType,
             scrollWindow.reset();
         }
     }
+    
+    /*
+     * Iterates through the list of objects which rely on the stream that's about to be closed, filling them with their data
+     * Will skip over closed blobs, implemented in SQLServerBlob
+     */
+    private void fillBlobs() {
+    	if (null != activeBlob && activeBlob instanceof SQLServerBlob) {
+    		try {
+    			((SQLServerBlob)activeBlob).fillByteArray();
+    		} catch (SQLException e) {
+    			if (logger.isLoggable(java.util.logging.Level.FINER)) {
+    				logger.finer(toString() + "Filling blobs before closing: " + e.getMessage());
+    			}
+    		} finally {
+    			activeBlob = null;
+    		}
+    	}
+	}
 
     /**
      * Discards the contents of the current fetch buffer.
@@ -6519,6 +6576,9 @@ final void doServerFetch(int fetchType,
      * fetch buffer is considered to be discarded.
      */
     private void discardFetchBuffer() {
+    	//fills blobs before discarding anything
+    	fillBlobs();
+
         // Clear the TDSReader mark at the start of the fetch buffer
         fetchBuffer.clearStartMark();
 
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSpatialDatatype.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSpatialDatatype.java
new file mode 100644
index 000000000..f290959f3
--- /dev/null
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSpatialDatatype.java
@@ -0,0 +1,1661 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+
+package com.microsoft.sqlserver.jdbc;
+
+import java.math.BigDecimal;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+import com.sun.mail.imap.protocol.INTERNALDATE;
+
+abstract class SQLServerSpatialDatatype {
+    
+    /**WKT = Well-Known-Text, WKB = Well-Knwon-Binary */
+    /**As a general rule, the ~IndexEnd variables are non-inclusive (i.e. pointIndexEnd = 8 means the shape using it will
+     * only go up to the 7th index of the array) */
+    protected ByteBuffer buffer;
+    protected InternalSpatialDatatype internalType;
+    protected String wkt;
+    protected String wktNoZM;
+    protected byte[] wkb;
+    protected byte[] wkbNoZM;
+    protected int srid;
+    protected byte version = 1;
+    protected int numberOfPoints;
+    protected int numberOfFigures;
+    protected int numberOfShapes;
+    protected int numberOfSegments;
+    protected StringBuffer WKTsb;
+    protected StringBuffer WKTsbNoZM;
+    protected int currentPointIndex = 0;
+    protected int currentFigureIndex = 0;
+    protected int currentSegmentIndex = 0;
+    protected int currentShapeIndex = 0;
+    protected double points[];
+    protected double zValues[];
+    protected double mValues[];
+    protected Figure figures[];
+    protected Shape shapes[];
+    protected Segment segments[];
+
+    //serialization properties
+    protected boolean hasZvalues = false;
+    protected boolean hasMvalues = false;
+    protected boolean isValid = false;
+    protected boolean isSinglePoint = false;
+    protected boolean isSingleLineSegment = false;
+    protected boolean isLargerThanHemisphere = false;
+    protected boolean isNull = true;
+    
+    protected final byte FA_INTERIOR_RING = 0;
+    protected final byte FA_STROKE = 1;
+    protected final byte FA_EXTERIOR_RING = 2;
+    
+    protected final byte FA_POINT = 0;
+    protected final byte FA_LINE = 1;
+    protected final byte FA_ARC = 2;
+    protected final byte FA_COMPOSITE_CURVE = 3;
+    
+    // WKT to WKB properties
+    protected int currentWktPos = 0;
+    protected List<Point> pointList = new ArrayList<Point>();
+    protected List<Figure> figureList = new ArrayList<Figure>();
+    protected List<Shape> shapeList = new ArrayList<Shape>();
+    protected List<Segment> segmentList = new ArrayList<Segment>();
+    protected byte serializationProperties = 0;
+    
+    private final byte SEGMENT_LINE = 0;
+    private final byte SEGMENT_ARC = 1;
+    private final byte SEGMENT_FIRST_LINE = 2;
+    private final byte SEGMENT_FIRST_ARC = 3;
+    
+    private final byte hasZvaluesMask =              0b00000001;
+    private final byte hasMvaluesMask =              0b00000010;
+    private final byte isValidMask =                 0b00000100;
+    private final byte isSinglePointMask =           0b00001000;
+    private final byte isSingleLineSegmentMask =     0b00010000;
+    private final byte isLargerThanHemisphereMask =  0b00100000;
+    
+    private List<Integer> version_one_shape_indexes = new ArrayList<Integer>();
+    
+    /**
+     * Serializes the Geogemetry/Geography instance to WKB.
+     * 
+     * @param noZM flag to indicate if Z and M coordinates should be included
+     */
+    protected abstract void serializeToWkb(boolean noZM);
+    
+    /**
+     * Deserialize the buffer (that contains WKB representation of Geometry/Geography data), and stores it
+     * into multiple corresponding data structures.
+     * 
+     */
+    protected abstract void parseWkb();
+    
+    /**
+     * Create the WKT representation of Geometry/Geography from the deserialized data.
+     * 
+     * @param sd the Geometry/Geography instance.
+     * @param isd internal spatial datatype object
+     * @param pointIndexEnd upper bound for reading points
+     * @param figureIndexEnd upper bound for reading figures
+     * @param segmentIndexEnd upper bound for reading segments
+     * @param shapeIndexEnd upper bound for reading shapes
+     */
+    protected void constructWKT(SQLServerSpatialDatatype sd, InternalSpatialDatatype isd, int pointIndexEnd, int figureIndexEnd, 
+            int segmentIndexEnd, int shapeIndexEnd) {
+        if (null == points || numberOfPoints == 0) {
+            if (isd.getTypeCode() == 11) { // FULLGLOBE
+                if (sd instanceof Geometry) {
+                    throw new IllegalArgumentException("Fullglobe is not supported for Geometry.");
+                } else {
+                    appendToWKTBuffers("FULLGLOBE");
+                    return;
+                }
+            }
+            // handle the case of GeometryCollection having empty objects
+            if (isd.getTypeCode() == 7 && currentShapeIndex != shapeIndexEnd - 1) {
+                currentShapeIndex++;
+                appendToWKTBuffers(isd.getTypeName() + "(");
+                constructWKT(this, InternalSpatialDatatype.valueOf(shapes[currentShapeIndex].getOpenGISType()),
+                        numberOfPoints, numberOfFigures, numberOfSegments, numberOfShapes);
+                appendToWKTBuffers(")");
+                return;                
+            }
+            appendToWKTBuffers(isd.getTypeName() + " EMPTY");
+            return;
+        }
+        
+        appendToWKTBuffers(isd.getTypeName());
+        appendToWKTBuffers("(");
+
+        switch (isd) {
+            case POINT:
+                constructPointWKT(currentPointIndex);
+                break;
+            case LINESTRING:
+            case CIRCULARSTRING:
+                constructLineWKT(currentPointIndex, pointIndexEnd);
+                break;
+            case POLYGON:
+                constructShapeWKT(currentFigureIndex, figureIndexEnd);
+                break;
+            case MULTIPOINT:
+            case MULTILINESTRING:
+                constructMultiShapeWKT(currentShapeIndex, shapeIndexEnd);
+                break;
+            case COMPOUNDCURVE:
+                constructCompoundcurveWKT(currentSegmentIndex, segmentIndexEnd, pointIndexEnd);
+                break;
+            case MULTIPOLYGON:
+                constructMultipolygonWKT(currentShapeIndex, shapeIndexEnd);
+                break;
+            case GEOMETRYCOLLECTION:
+                constructGeometryCollectionWKT(shapeIndexEnd);
+                break;
+            case CURVEPOLYGON:
+                constructCurvepolygonWKT(currentFigureIndex, figureIndexEnd, currentSegmentIndex, segmentIndexEnd);
+                break;
+            default:
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+        }
+        
+        appendToWKTBuffers(")");
+    }
+    
+    /**
+     * Parses WKT and populates the data structures of the Geometry/Geography instance.
+     * 
+     * @param sd the Geometry/Geography instance.
+     * @param startPos The index to start from from the WKT.
+     * @param parentShapeIndex The index of the parent's Shape in the shapes array. Used to determine this shape's parent.
+     * @param isGeoCollection flag to indicate if this is part of a GeometryCollection.
+     */
+    protected void parseWKTForSerialization(SQLServerSpatialDatatype sd, int startPos, int parentShapeIndex, boolean isGeoCollection) {
+        //after every iteration of this while loop, the currentWktPosition will be set to the
+        //end of the geometry/geography shape, except for the very first iteration of it.
+        //This means that there has to be comma (that separates the previous shape with the next shape),
+        //or we expect a ')' that will close the entire shape and exit the method.
+        
+        while (hasMoreToken()) {
+            if (startPos != 0) {
+                if (wkt.charAt(currentWktPos) == ')') {
+                    return;
+                } else if (wkt.charAt(currentWktPos) == ',') {
+                    currentWktPos++;
+                }
+            }
+
+            String nextToken = getNextStringToken().toUpperCase(Locale.US);
+            int thisShapeIndex;
+            InternalSpatialDatatype isd = InternalSpatialDatatype.INVALID_TYPE;
+            try {
+                isd = InternalSpatialDatatype.valueOf(nextToken);
+            }
+            catch (Exception e) {
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+            }
+            byte fa = 0;
+            
+            if (version == 1 && (nextToken.equals("CIRCULARSTRING") || nextToken.equals("COMPOUNDCURVE") ||
+                    nextToken.equals("CURVEPOLYGON"))) {
+                version = 2;
+            }
+            
+            // check for FULLGLOBE before reading the first open bracket, since FULLGLOBE doesn't have one.
+            if (nextToken.equals("FULLGLOBE")) {
+                if (sd instanceof Geometry) {
+                    throw new IllegalArgumentException("Fullglobe is not supported for Geometry.");
+                }
+                
+                if (startPos != 0) {
+                    throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+                }
+                
+                shapeList.add(new Shape(parentShapeIndex, -1, isd.getTypeCode()));
+                isLargerThanHemisphere = true;
+                version = 2;
+                break;
+            }
+
+            // if next keyword is empty, continue the loop. 
+            if (checkEmptyKeyword(parentShapeIndex, isd, false)) {
+                continue;
+            }
+            
+            readOpenBracket();
+            
+            switch (nextToken) {
+                case "POINT":
+                    if (startPos == 0 && nextToken.toUpperCase().equals("POINT")) {
+                        isSinglePoint = true;
+                    }
+                    
+                    if (isGeoCollection) {
+                        shapeList.add(new Shape(parentShapeIndex, figureList.size(), isd.getTypeCode()));
+                        figureList.add(new Figure(FA_LINE, pointList.size()));
+                    }
+                    
+                    readPointWkt();
+                    break;
+                case "LINESTRING":
+                case "CIRCULARSTRING":
+                    shapeList.add(new Shape(parentShapeIndex, figureList.size(), isd.getTypeCode()));
+                    fa = isd.getTypeCode() == InternalSpatialDatatype.LINESTRING.getTypeCode() ? FA_STROKE : FA_EXTERIOR_RING;
+                    figureList.add(new Figure(fa, pointList.size()));
+                    
+                    readLineWkt();
+                    
+                    if (startPos == 0 && nextToken.toUpperCase().equals("LINESTRING") && pointList.size() == 2) {
+                        isSingleLineSegment = true;
+                    }
+                    break;
+                case "POLYGON":
+                case "MULTIPOINT":
+                case "MULTILINESTRING":
+                    thisShapeIndex = shapeList.size();
+                    shapeList.add(new Shape(parentShapeIndex, figureList.size(), isd.getTypeCode()));
+                    
+                    readShapeWkt(thisShapeIndex, nextToken);
+
+                    break;
+                case "MULTIPOLYGON":
+                    thisShapeIndex = shapeList.size();
+                    shapeList.add(new Shape(parentShapeIndex, figureList.size(), isd.getTypeCode()));
+                    
+                    readMultiPolygonWkt(thisShapeIndex, nextToken);
+   
+                    break;
+                case "COMPOUNDCURVE":
+                    shapeList.add(new Shape(parentShapeIndex, figureList.size(), isd.getTypeCode()));
+                    figureList.add(new Figure(FA_COMPOSITE_CURVE, pointList.size()));
+                    
+                    readCompoundCurveWkt(true);
+                    
+                    break;
+                case "CURVEPOLYGON":
+                    shapeList.add(new Shape(parentShapeIndex, figureList.size(), isd.getTypeCode()));
+
+                    readCurvePolygon();
+                    
+                    break;
+                case "GEOMETRYCOLLECTION":
+                    thisShapeIndex = shapeList.size();
+                    shapeList.add(new Shape(parentShapeIndex, figureList.size(), isd.getTypeCode()));
+                    
+                    parseWKTForSerialization(this, currentWktPos, thisShapeIndex, true);
+                    
+                    break;
+                default:
+                    throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+            }
+            readCloseBracket();
+        }
+        
+        populateStructures();
+    }
+    
+    /**
+     * Constructs and appends a Point type in WKT form to the stringbuffer.
+     * There are two stringbuffers - WKTsb and WKTsbNoZM. WKTsb contains the X, Y, Z and M coordinates,
+     * whereas WKTsbNoZM contains only X and Y coordinates.
+     * 
+     * @param pointIndex indicates which point to append to the stringbuffer.
+     * 
+     */
+    protected void constructPointWKT(int pointIndex) {
+        int firstPointIndex = pointIndex * 2;
+        int secondPointIndex = firstPointIndex + 1;
+        int zValueIndex = pointIndex;
+        int mValueIndex = pointIndex;
+        
+        if (points[firstPointIndex] % 1 == 0) {
+            appendToWKTBuffers((int) points[firstPointIndex]);
+        } else {
+            appendToWKTBuffers(points[firstPointIndex]);
+        }
+        appendToWKTBuffers(" ");
+
+        if (points[secondPointIndex] % 1 == 0) {
+            appendToWKTBuffers((int) points[secondPointIndex]);
+        } else {
+            appendToWKTBuffers(points[secondPointIndex]);
+        }
+        appendToWKTBuffers(" ");
+        
+        if (hasZvalues && !Double.isNaN(zValues[zValueIndex]) && !(zValues[zValueIndex] == 0)) {
+            if (zValues[zValueIndex] % 1 == 0) {
+                WKTsb.append((int) zValues[zValueIndex]);
+            } else {
+                WKTsb.append(zValues[zValueIndex]);
+            }
+            WKTsb.append(" ");
+            
+            if (hasMvalues && !Double.isNaN(mValues[mValueIndex]) && !(mValues[mValueIndex] <= 0)) {
+                if (mValues[mValueIndex] % 1 == 0) {
+                    WKTsb.append((int) mValues[mValueIndex]);
+                } else {
+                    WKTsb.append(mValues[mValueIndex]);
+                }
+                WKTsb.append(" ");
+            }
+        }
+        
+        currentPointIndex++;
+        // truncate last space
+        WKTsb.setLength(WKTsb.length() - 1);
+        WKTsbNoZM.setLength(WKTsbNoZM.length() - 1);
+    }
+
+    /** 
+     * Constructs a line in WKT form.
+     * 
+     * @param pointStartIndex .
+     * @param pointEndIndex .
+     */
+    protected void constructLineWKT(int pointStartIndex, int pointEndIndex) {
+        for (int i = pointStartIndex; i < pointEndIndex; i++) {
+            constructPointWKT(i);
+            
+            // add ', ' to separate points, except for the last point
+            if (i != pointEndIndex - 1) {
+                appendToWKTBuffers(", ");
+            }
+        }
+    }
+    
+    /**
+     * Constructs a shape (simple Geometry/Geography entities that are contained within a single bracket) in WKT form.
+     * 
+     * @param figureStartIndex .
+     * @param figureEndIndex .
+     */
+    protected void constructShapeWKT(int figureStartIndex, int figureEndIndex) {
+        for (int i = figureStartIndex; i < figureEndIndex; i++) {
+            appendToWKTBuffers("(");
+            if (i != numberOfFigures - 1) { //not the last figure
+                constructLineWKT(figures[i].getPointOffset(), figures[i + 1].getPointOffset());
+            } else {
+                constructLineWKT(figures[i].getPointOffset(), numberOfPoints);
+            }
+            
+            if (i != figureEndIndex - 1) {
+                appendToWKTBuffers("), ");
+            } else {
+                appendToWKTBuffers(")");
+            }
+        }
+    }
+
+    /**
+     * Constructs a mutli-shape (MultiPoint / MultiLineString) in WKT form.
+     * 
+     * @param shapeStartIndex .
+     * @param shapeEndIndex .
+     */
+    protected void constructMultiShapeWKT(int shapeStartIndex, int shapeEndIndex) {
+        for (int i = shapeStartIndex + 1; i < shapeEndIndex; i++) {
+            if (shapes[i].getFigureOffset() == -1) { // EMPTY
+                appendToWKTBuffers("EMPTY");
+            } else {
+                constructShapeWKT(shapes[i].getFigureOffset(), shapes[i].getFigureOffset() + 1);
+            }
+            if (i != shapeEndIndex - 1) {
+                appendToWKTBuffers(", ");
+            }
+        }
+    }
+    
+    /**
+     * Constructs a CompoundCurve in WKT form.
+     * 
+     * @param segmentStartIndex .
+     * @param segmentEndIndex .
+     * @param pointEndIndex .
+     */
+    protected void constructCompoundcurveWKT(int segmentStartIndex, int segmentEndIndex, int pointEndIndex) {
+        for (int i = segmentStartIndex; i < segmentEndIndex; i++) {
+            byte segment = segments[i].getSegmentType();
+            constructSegmentWKT(i, segment, pointEndIndex);
+            
+            if (i == segmentEndIndex - 1) {
+                appendToWKTBuffers(")");
+                break;
+            }
+            
+            switch (segment) {
+                case 0:
+                case 2:
+                    if (segments[i + 1].getSegmentType() != 0) {
+                        appendToWKTBuffers("), ");
+                    }
+                    break;
+                case 1:
+                case 3:
+                    if (segments[i + 1].getSegmentType() != 1) {
+                        appendToWKTBuffers("), ");
+                    }
+                    break;
+                default:
+                    return;
+            }
+        }
+    }
+    
+    /**
+     * Constructs a MultiPolygon in WKT form.
+     * 
+     * @param shapeStartIndex .
+     * @param shapeEndIndex .
+     */
+    protected void constructMultipolygonWKT(int shapeStartIndex, int shapeEndIndex) {
+        int figureStartIndex;
+        int figureEndIndex;
+        
+        for (int i = shapeStartIndex + 1; i < shapeEndIndex; i++) {
+            figureEndIndex = figures.length;
+            if (shapes[i].getFigureOffset() == -1) { // EMPTY
+                appendToWKTBuffers("EMPTY");
+                if (!(i == shapeEndIndex - 1)) { // not the last exterior polygon of this multipolygon, add a comma
+                    appendToWKTBuffers(", ");
+                }
+                continue;
+            }
+            figureStartIndex = shapes[i].getFigureOffset();
+            if (i == shapes.length - 1) { // last shape
+                figureEndIndex = figures.length;
+            } else {
+                // look ahead and find the next shape that doesn't have -1 as its figure offset (which signifies EMPTY)
+                int tempCurrentShapeIndex = i + 1;
+                // We need to iterate this through until the very end of the shapes list, since if the last shape
+                // in this MultiPolygon is an EMPTY, it won't know what the correct figureEndIndex would be.
+                while (tempCurrentShapeIndex < shapes.length) {
+                    if (shapes[tempCurrentShapeIndex].getFigureOffset() == -1) {
+                        tempCurrentShapeIndex++;
+                        continue;
+                    } else {
+                        figureEndIndex = shapes[tempCurrentShapeIndex].getFigureOffset();
+                        break;
+                    }
+                }
+            }
+
+            appendToWKTBuffers("(");
+            
+            for (int j = figureStartIndex; j < figureEndIndex; j++) {
+                appendToWKTBuffers("(");// interior ring
+                
+                if (j == figures.length - 1) { // last figure
+                    constructLineWKT(figures[j].getPointOffset(), numberOfPoints);
+                } else {
+                    constructLineWKT(figures[j].getPointOffset(), figures[j + 1].getPointOffset());
+                }
+                
+                if (j == figureEndIndex - 1) { // last polygon of this multipolygon, close off the Multipolygon
+                    appendToWKTBuffers(")");
+                } else {  // not the last polygon, followed by an interior ring
+                    appendToWKTBuffers("), ");
+                }
+            }
+            
+            appendToWKTBuffers(")");
+            
+            if (!(i == shapeEndIndex - 1)) { // not the last exterior polygon of this multipolygon, add a comma
+                appendToWKTBuffers(", ");
+            }
+        }
+    }
+    
+    /**
+     * Constructs a CurvePolygon in WKT form.
+     * 
+     * @param figureStartIndex .
+     * @param figureEndIndex .
+     * @param segmentStartIndex .
+     * @param segmentEndIndex .
+     */
+    protected void constructCurvepolygonWKT(int figureStartIndex, int figureEndIndex, int segmentStartIndex, int segmentEndIndex) {        
+        for (int i = figureStartIndex; i < figureEndIndex; i++) {
+            switch (figures[i].getFiguresAttribute()) {
+                case 1: // line
+                    appendToWKTBuffers("(");
+                    
+                    if (i == figures.length - 1) {
+                        constructLineWKT(currentPointIndex, numberOfPoints);
+                    } else {
+                        constructLineWKT(currentPointIndex, figures[i + 1].getPointOffset());
+                    }
+                        
+                    appendToWKTBuffers(")");
+                    break;
+                case 2: // arc
+                    appendToWKTBuffers("CIRCULARSTRING(");
+                    
+                    if (i == figures.length - 1) {
+                        constructLineWKT(currentPointIndex, numberOfPoints);
+                    } else {
+                        constructLineWKT(currentPointIndex, figures[i + 1].getPointOffset());
+                    }
+                        
+                    appendToWKTBuffers(")");
+                    
+                    break;
+                case 3: // composite curve
+                    appendToWKTBuffers("COMPOUNDCURVE(");
+                    
+                    int pointEndIndex = 0;
+                    
+                    if (i == figures.length - 1) {
+                        pointEndIndex = numberOfPoints;
+                    } else {
+                        pointEndIndex = figures[i + 1].getPointOffset();
+                    }
+                    
+                    while (currentPointIndex < pointEndIndex) {
+                        byte segment = segments[segmentStartIndex].getSegmentType();
+                        constructSegmentWKT(segmentStartIndex, segment, pointEndIndex);
+                        
+                        if (!(currentPointIndex < pointEndIndex)) {
+                            appendToWKTBuffers("))");
+                        } else {
+                            switch (segment) {
+                                case 0:
+                                case 2:
+                                    if (segments[segmentStartIndex + 1].getSegmentType() != 0) {
+                                        appendToWKTBuffers("), ");
+                                    }
+                                    break;
+                                case 1:
+                                case 3:
+                                    if (segments[segmentStartIndex + 1].getSegmentType() != 1) {
+                                        appendToWKTBuffers("), ");
+                                    }
+                                    break;
+                                default:
+                                    return;
+                            }
+                        }
+
+                        segmentStartIndex++;
+                    }
+                    
+                    break;
+                default:
+                    return;
+            }
+            
+            //Append a comma if this is not the last figure of the shape.
+            if (i != figureEndIndex - 1) {
+                appendToWKTBuffers(", ");
+            }
+        }
+    }
+    
+    /**
+     * Constructs a Segment in WKT form.
+     * SQL Server re-uses the last point of a segment if the following segment is of type 3 (first arc) or
+     * type 2 (first line). This makes sense because the last point of a segment and the first point of the next
+     * segment have to match for a valid curve. This means that the code has to look ahead and decide to decrement
+     * the currentPointIndex depending on what segment comes next, since it may have been reused (and it's reflected
+     * in the array of points)
+     * 
+     * @param currentSegment .
+     * @param segment .
+     * @param pointEndIndex .
+     */
+    protected void constructSegmentWKT(int currentSegment, byte segment, int pointEndIndex) {
+        switch (segment) {
+            case 0:
+                appendToWKTBuffers(", ");
+                constructLineWKT(currentPointIndex, currentPointIndex + 1);
+                
+                if (currentSegment == segments.length - 1) { // last segment
+                    break;
+                } else if (segments[currentSegment + 1].getSegmentType() != 0) { // not being followed by another line, but not the last segment
+                    currentPointIndex = currentPointIndex - 1;
+                    incrementPointNumStartIfPointNotReused(pointEndIndex);
+                }
+                break;
+                
+            case 1:
+                appendToWKTBuffers(", ");
+                constructLineWKT(currentPointIndex, currentPointIndex + 2);
+                
+                if (currentSegment == segments.length - 1) { // last segment
+                    break;
+                } else if (segments[currentSegment + 1].getSegmentType() != 1) { // not being followed by another arc, but not the last segment
+                    currentPointIndex = currentPointIndex - 1; // only increment pointNumStart by one less than what we should be, since the last point will be reused
+                    incrementPointNumStartIfPointNotReused(pointEndIndex);
+                }
+
+                break;
+            case 2:
+                appendToWKTBuffers("(");
+                constructLineWKT(currentPointIndex, currentPointIndex + 2);
+                
+                if (currentSegment == segments.length - 1) { // last segment
+                    break;
+                } else if (segments[currentSegment + 1].getSegmentType() != 0) { // not being followed by another line, but not the last segment
+                    currentPointIndex = currentPointIndex - 1; // only increment pointNumStart by one less than what we should be, since the last point will be reused
+                    incrementPointNumStartIfPointNotReused(pointEndIndex);
+                }
+                
+                break;
+            case 3:
+                appendToWKTBuffers("CIRCULARSTRING(");
+                constructLineWKT(currentPointIndex, currentPointIndex + 3);
+                
+                if (currentSegment == segments.length - 1) { // last segment
+                    break;
+                } else if (segments[currentSegment + 1].getSegmentType() != 1) { // not being followed by another arc
+                    currentPointIndex = currentPointIndex - 1; // only increment pointNumStart by one less than what we should be, since the last point will be reused
+                    incrementPointNumStartIfPointNotReused(pointEndIndex);
+                }
+
+                break;
+            default:
+                return;
+        }
+    }
+    
+    /**
+     * The starting point for constructing a GeometryCollection type in WKT form.
+     * 
+     * @param shapeEndIndex .
+     */
+    protected void constructGeometryCollectionWKT(int shapeEndIndex) {
+        currentShapeIndex++;
+        constructGeometryCollectionWKThelper(shapeEndIndex);
+    }
+    
+    /**
+     * Reads Point WKT and adds it to the list of points.
+     * This method will read up until and including the comma that may come at the end of the Point WKT.
+     */
+    protected void readPointWkt() {
+        int numOfCoordinates = 0;
+        double sign;
+        double coords[] = new double[4];
+        
+        while (numOfCoordinates < 4) {
+            sign = 1;
+            if (wkt.charAt(currentWktPos) == '-') {
+                sign = -1;
+                currentWktPos++;
+            }
+            
+            int startPos = currentWktPos;
+            
+            if (wkt.charAt(currentWktPos) == ')') {
+                break;
+            }
+            
+            while (currentWktPos < wkt.length() && 
+                    (Character.isDigit(wkt.charAt(currentWktPos))
+                            || wkt.charAt(currentWktPos) == '.'       
+                            || wkt.charAt(currentWktPos) == 'E'
+                            || wkt.charAt(currentWktPos) == 'e')) {
+                currentWktPos++;
+            }
+            
+            try {
+                coords[numOfCoordinates] = sign *
+                        new BigDecimal(wkt.substring(startPos, currentWktPos)).doubleValue();
+            } catch (Exception e) { //modify to conversion exception
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos); 
+            }
+            
+            numOfCoordinates++;
+            
+            skipWhiteSpaces();
+            
+            // After skipping white space after the 4th coordinate has been read, the next
+            // character has to be either a , or ), or the WKT is invalid.
+            if (numOfCoordinates == 4) {
+                if (wkt.charAt(currentWktPos) != ',' && wkt.charAt(currentWktPos) != ')') {
+                    throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos); 
+                }
+            }
+            
+            if (wkt.charAt(currentWktPos) == ',') {
+                // need at least 2 coordinates
+                if (numOfCoordinates == 1) {
+                    throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos); 
+                }
+                currentWktPos++;
+                skipWhiteSpaces();
+                break;
+            }
+            skipWhiteSpaces();
+        }
+        
+        if (numOfCoordinates == 4) {
+            hasZvalues = true;
+            hasMvalues = true;
+        } else if (numOfCoordinates == 3) {
+            hasZvalues = true;
+        }
+        
+        pointList.add(new Point(coords[0], coords[1], coords[2], coords[3]));
+    }
+    
+    /**
+     * Reads a series of Point types.
+     */
+    protected void readLineWkt() {
+        while (currentWktPos < wkt.length() && wkt.charAt(currentWktPos) != ')') {
+            readPointWkt();
+        }
+    }
+    
+    /**
+     * Reads a shape (simple Geometry/Geography entities that are contained within a single bracket) WKT.
+     * 
+     * @param parentShapeIndex shape index of the parent shape that called this method
+     * @param nextToken next string token
+     */
+    protected void readShapeWkt(int parentShapeIndex, String nextToken) {
+        byte fa = FA_POINT;
+        while (currentWktPos < wkt.length() && wkt.charAt(currentWktPos) != ')') {
+            
+            // if next keyword is empty, continue the loop.
+            // Do not check this for polygon.
+            if (!nextToken.equals("POLYGON") &&
+                    checkEmptyKeyword(parentShapeIndex, InternalSpatialDatatype.valueOf(nextToken), true)) {
+                continue;
+            }
+            
+            if (nextToken.equals("MULTIPOINT")) {
+                shapeList.add(new Shape(parentShapeIndex, figureList.size(), InternalSpatialDatatype.POINT.getTypeCode()));
+            } else if (nextToken.equals("MULTILINESTRING")) {
+                shapeList.add(new Shape(parentShapeIndex, figureList.size(), InternalSpatialDatatype.LINESTRING.getTypeCode()));
+            }
+            
+            if (version == 1) {
+                if (nextToken.equals("MULTIPOINT")) {
+                    fa = FA_STROKE;
+                } else if (nextToken.equals("MULTILINESTRING") || nextToken.equals("POLYGON")) {
+                    fa = FA_EXTERIOR_RING;
+                }
+                version_one_shape_indexes.add(figureList.size());
+            } else if (version == 2) {
+                if (nextToken.equals("MULTIPOINT") || nextToken.equals("MULTILINESTRING") || 
+                        nextToken.equals("POLYGON") || nextToken.equals("MULTIPOLYGON")) {
+                    fa = FA_LINE;
+                }
+            }
+            
+            figureList.add(new Figure(fa, pointList.size()));
+            readOpenBracket();
+            readLineWkt();
+            readCloseBracket();
+
+            skipWhiteSpaces();
+            
+            if (wkt.charAt(currentWktPos) == ',') { // more rings to follow
+                readComma();
+            } else if (wkt.charAt(currentWktPos) == ')') { // about to exit while loop
+                continue;
+            } else { // unexpected input
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+            }
+        }
+    }
+    
+    /**
+     * Reads a CurvePolygon WKT
+     */
+    protected void readCurvePolygon() {
+        while (currentWktPos < wkt.length() && wkt.charAt(currentWktPos) != ')') {
+            String nextPotentialToken = getNextStringToken().toUpperCase(Locale.US);
+            if (nextPotentialToken.equals("CIRCULARSTRING")) {
+                figureList.add(new Figure(FA_ARC, pointList.size()));
+                readOpenBracket();
+                readLineWkt();
+                readCloseBracket();
+            } else if (nextPotentialToken.equals("COMPOUNDCURVE")) {
+                figureList.add(new Figure(FA_COMPOSITE_CURVE, pointList.size()));
+                readOpenBracket();
+                readCompoundCurveWkt(true);
+                readCloseBracket();
+            } else if (wkt.charAt(currentWktPos) == '(') { //LineString
+                figureList.add(new Figure(FA_LINE, pointList.size()));
+                readOpenBracket();
+                readLineWkt();
+                readCloseBracket();
+            } else {
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+            }
+            
+            if (wkt.charAt(currentWktPos) == ',') { // more polygons to follow
+                readComma();
+            } else if (wkt.charAt(currentWktPos) == ')') { // about to exit while loop
+                continue;
+            } else { // unexpected input
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+            }
+        }
+    }
+
+    /**
+     * Reads a MultiPolygon WKT
+     * 
+     * @param thisShapeIndex shape index of current shape
+     * @param nextToken next string token
+     */
+    protected void readMultiPolygonWkt(int thisShapeIndex, String nextToken) {
+        while (currentWktPos < wkt.length() && wkt.charAt(currentWktPos) != ')') {
+            if (checkEmptyKeyword(thisShapeIndex, InternalSpatialDatatype.valueOf(nextToken), true)) {
+                continue;
+            }
+            shapeList.add(new Shape(thisShapeIndex, figureList.size(), InternalSpatialDatatype.POLYGON.getTypeCode())); //exterior polygon
+            readOpenBracket();
+            readShapeWkt(thisShapeIndex, nextToken);
+            readCloseBracket();
+            
+            if (wkt.charAt(currentWktPos) == ',') { // more polygons to follow
+                readComma();
+            } else if (wkt.charAt(currentWktPos) == ')') { // about to exit while loop
+                continue;
+            } else { // unexpected input
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+            }
+        }
+    }
+    
+    /**
+     * Reads a Segment WKT
+     * 
+     * @param segmentType segment type
+     * @param isFirstIteration flag that indicates if this is the first iteration from the loop outside
+     */
+    protected void readSegmentWkt(int segmentType, boolean isFirstIteration) {
+        segmentList.add(new Segment((byte) segmentType));
+        
+        int segmentLength = segmentType;
+        
+        // under 2 means 0 or 1 (possible values). 0 (line) has 1 point, and 1 (arc) has 2 points, so increment by one
+        if (segmentLength < 2) { 
+            segmentLength++;
+        }
+        
+        for (int i = 0; i < segmentLength; i++) {
+            //If a segment type of 2 (first line) or 3 (first arc) is not from the very first iteration of the while loop,
+            //then the first point has to be a duplicate point from the previous segment, so skip the first point.
+            if (i == 0 && !isFirstIteration && segmentType >= 2) {
+                skipFirstPointWkt();
+            } else {
+                readPointWkt();
+            }
+        }
+        
+        if (currentWktPos < wkt.length() && wkt.charAt(currentWktPos) != ')') {
+            if (segmentType == SEGMENT_FIRST_ARC || segmentType == SEGMENT_ARC) {
+                readSegmentWkt(SEGMENT_ARC, false);
+            } else if (segmentType == SEGMENT_FIRST_LINE | segmentType == SEGMENT_LINE) {
+                readSegmentWkt(SEGMENT_LINE, false);
+            }
+        }
+    }
+
+    /**
+     * Reads a CompoundCurve WKT
+     * 
+     * @param isFirstIteration flag that indicates if this is the first iteration from the loop outside
+     */
+    protected void readCompoundCurveWkt(boolean isFirstIteration) {
+        while (currentWktPos < wkt.length() && wkt.charAt(currentWktPos) != ')') {
+            String nextPotentialToken = getNextStringToken().toUpperCase(Locale.US);
+            if (nextPotentialToken.equals("CIRCULARSTRING")) {
+                readOpenBracket();
+                readSegmentWkt(SEGMENT_FIRST_ARC, isFirstIteration);
+                readCloseBracket();
+            } else if (wkt.charAt(currentWktPos) == '(') {//LineString
+                readOpenBracket();
+                readSegmentWkt(SEGMENT_FIRST_LINE, isFirstIteration);
+                readCloseBracket();
+            } else {
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+            }
+            
+            isFirstIteration = false;
+            
+            if (wkt.charAt(currentWktPos) == ',') { // more polygons to follow
+                readComma();
+            } else if (wkt.charAt(currentWktPos) == ')') { // about to exit while loop
+                continue;
+            } else { // unexpected input
+                throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+            }
+        }        
+    }
+
+    /**
+     * Reads the next string token (usually POINT, LINESTRING, etc.).
+     * Then increments currentWktPos to the end of the string token.
+     * 
+     * @return the next string token
+     */
+    protected String getNextStringToken() {
+        skipWhiteSpaces();
+        int endIndex = currentWktPos;
+        while (endIndex < wkt.length() && Character.isLetter(wkt.charAt(endIndex))) {
+            endIndex++;
+        }
+        int temp = currentWktPos;
+        currentWktPos = endIndex;
+        skipWhiteSpaces();
+        
+        return wkt.substring(temp, endIndex);
+    }
+
+    /**
+     * Populates the various data structures contained within the Geometry/Geography instace.
+     */
+    protected void populateStructures() {
+        if (pointList.size() > 0) {
+            points = new double[pointList.size()  * 2];
+            
+            for (int i = 0; i < pointList.size(); i++) {
+                points[i * 2] = pointList.get(i).getX();
+                points[i * 2 + 1] = pointList.get(i).getY();
+            }
+            
+            if (hasZvalues) {
+                zValues = new double[pointList.size()];
+                for (int i = 0; i < pointList.size(); i++) {
+                    zValues[i] = pointList.get(i).getZ();
+                }
+            }
+            
+            if (hasMvalues) {
+                mValues = new double[pointList.size()];
+                for (int i = 0; i < pointList.size(); i++) {
+                    mValues[i] = pointList.get(i).getM();
+                }
+            }
+        }
+        
+        // if version is 2, then we need to check for potential shapes (polygon & multi-shapes) that were
+        // given their figure attributes as if it was version 1, since we don't know what would be the
+        // version of the geometry/geography before we parse the entire WKT.
+        if (version == 2) {
+            for (int i = 0; i < version_one_shape_indexes.size(); i++) {
+                figureList.get(version_one_shape_indexes.get(i)).setFiguresAttribute((byte) 1);
+            }
+        }
+        
+        if (figureList.size() > 0) {
+            figures = new Figure[figureList.size()];
+            
+            for (int i = 0; i < figureList.size(); i++) {
+                figures[i] = figureList.get(i);
+            }
+        }
+        
+        // There is an edge case of empty GeometryCollections being inside other GeometryCollections. In this case,
+        // the figure offset of the very first shape (GeometryCollections) has to be -1, but this is not possible to know until
+        // We've parsed through the entire WKT and confirmed that there are 0 points.
+        // Therefore, if so, we make the figure offset of the first shape to be -1.
+        if (pointList.size() == 0 && shapeList.size() > 0 && shapeList.get(0).getOpenGISType() == 7) {
+            shapeList.get(0).setFigureOffset(-1);
+        }
+        
+        if (shapeList.size() > 0) {
+            shapes = new Shape[shapeList.size()];
+            
+            for (int i = 0; i < shapeList.size(); i++) {
+                shapes[i] = shapeList.get(i);
+            }
+        }
+        
+        if (segmentList.size() > 0) {
+            segments = new Segment[segmentList.size()];
+            
+            for (int i = 0; i < segmentList.size(); i++) {
+                segments[i] = segmentList.get(i);
+            }
+        }
+        
+        numberOfPoints = pointList.size();
+        numberOfFigures = figureList.size();
+        numberOfShapes = shapeList.size();
+        numberOfSegments = segmentList.size();
+    }
+    
+    protected void readOpenBracket() {
+        skipWhiteSpaces();
+        if (wkt.charAt(currentWktPos) == '(') {
+            currentWktPos++;
+            skipWhiteSpaces();
+        } else {
+            throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+        }
+    }
+    
+    protected void readCloseBracket() {
+        skipWhiteSpaces();
+        if (wkt.charAt(currentWktPos) == ')') {
+            currentWktPos++;
+            skipWhiteSpaces();
+        } else {
+            throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+        }
+    }
+
+    protected boolean hasMoreToken() {
+        skipWhiteSpaces();
+        return currentWktPos < wkt.length();
+    }
+    
+    protected void createSerializationProperties() {
+        serializationProperties = 0;
+        if (hasZvalues) {
+            serializationProperties += hasZvaluesMask;
+        }
+        
+        if (hasMvalues) {
+            serializationProperties += hasMvaluesMask;
+        }
+        
+        if (isValid) {
+            serializationProperties += isValidMask;
+        }
+        
+        if (isSinglePoint) {
+            serializationProperties += isSinglePointMask;
+        }
+        
+        if (isSingleLineSegment) {
+            serializationProperties += isSingleLineSegmentMask;
+        }
+        
+        if (version == 2) {
+            if (isLargerThanHemisphere) {
+                serializationProperties += isLargerThanHemisphereMask;
+            }
+        }
+    }
+    
+    protected int determineWkbCapacity() {
+        int totalSize = 0;
+        
+        totalSize+=6; // SRID + version + SerializationPropertiesByte
+        
+        if (isSinglePoint || isSingleLineSegment) {
+            totalSize += 16 * numberOfPoints;
+            
+            if (hasZvalues) {
+                totalSize += 8 * numberOfPoints;
+            }
+            
+            if (hasMvalues) {
+                totalSize += 8 * numberOfPoints;
+            }
+            
+            return totalSize;
+        }
+        
+        int pointSize = 16;
+        if (hasZvalues) {
+            pointSize += 8;
+        }
+        
+        if (hasMvalues) {
+            pointSize += 8;
+        }
+        
+        totalSize += 12; // 4 bytes for 3 ints, each representing the number of points, shapes and figures
+        totalSize += numberOfPoints * pointSize;
+        totalSize += numberOfFigures * 5;
+        totalSize += numberOfShapes * 9;
+        
+        if (version == 2) {
+            totalSize += 4; // 4 bytes for 1 int, representing the number of segments
+            totalSize += numberOfSegments;
+        }
+        
+        return totalSize;
+    }
+    
+    /**
+     * Append the data to both stringbuffers.
+     * @param o data to append to the stringbuffers.
+     */
+    protected void appendToWKTBuffers(Object o) {
+        WKTsb.append(o);
+        WKTsbNoZM.append(o);
+    }
+
+    protected void interpretSerializationPropBytes() {
+        hasZvalues = (serializationProperties & hasZvaluesMask) != 0;
+        hasMvalues = (serializationProperties & hasMvaluesMask) != 0;
+        isValid = (serializationProperties & isValidMask) != 0;
+        isSinglePoint = (serializationProperties & isSinglePointMask) != 0;
+        isSingleLineSegment = (serializationProperties & isSingleLineSegmentMask) != 0;
+        isLargerThanHemisphere = (serializationProperties & isLargerThanHemisphereMask) != 0;
+    }
+    
+    protected void readNumberOfPoints() {
+        if (isSinglePoint) {
+            numberOfPoints = 1;
+        } else if (isSingleLineSegment) {
+            numberOfPoints = 2;
+        } else {
+            numberOfPoints = buffer.getInt();
+        }
+    }
+    
+    protected void readZvalues() {
+        zValues = new double[numberOfPoints];
+        for (int i = 0; i < numberOfPoints; i++) {
+            zValues[i] = buffer.getDouble();
+        }
+    }
+    
+    protected void readMvalues() {
+        mValues = new double[numberOfPoints];
+        for (int i = 0; i < numberOfPoints; i++) {
+            mValues[i] = buffer.getDouble();
+        }
+    }
+    
+    protected void readNumberOfFigures() {
+        numberOfFigures = buffer.getInt();
+    }
+    
+    protected void readFigures() {
+        byte fa;
+        int po;
+        figures = new Figure[numberOfFigures];
+        for (int i = 0; i < numberOfFigures; i++) {
+            fa = buffer.get();
+            po = buffer.getInt();
+            figures[i] = new Figure(fa, po);
+        }
+    }
+    
+    protected void readNumberOfShapes() {
+        numberOfShapes = buffer.getInt();
+    }
+    
+    protected void readShapes() {
+        int po;
+        int fo;
+        byte ogt;
+        shapes = new Shape[numberOfShapes];
+        for (int i = 0; i < numberOfShapes; i++) {
+            po = buffer.getInt();
+            fo = buffer.getInt();
+            ogt = buffer.get();
+            shapes[i] = new Shape(po, fo, ogt);
+        }
+    }
+    
+    protected void readNumberOfSegments() {
+        numberOfSegments = buffer.getInt();
+    }
+    
+    protected void readSegments() {
+        byte st;
+        segments = new Segment[numberOfSegments];
+        for (int i = 0; i < numberOfSegments; i++) {
+            st = buffer.get();
+            segments[i] = new Segment(st);
+        }
+    }
+
+    protected void determineInternalType() {
+        if (isSinglePoint) {
+            internalType = InternalSpatialDatatype.POINT;
+        } else if (isSingleLineSegment) {
+            internalType = InternalSpatialDatatype.LINESTRING;
+        } else {
+            internalType = InternalSpatialDatatype.valueOf(shapes[0].getOpenGISType());
+        }
+    }
+    
+    protected boolean checkEmptyKeyword(int parentShapeIndex, InternalSpatialDatatype isd, boolean isInsideAnotherShape) {
+        String potentialEmptyKeyword = getNextStringToken().toUpperCase(Locale.US);
+        if (potentialEmptyKeyword.equals("EMPTY")) {
+            
+            byte typeCode = 0;
+            
+            if (isInsideAnotherShape) {
+                byte parentTypeCode = isd.getTypeCode();
+                if (parentTypeCode == 4) { // MultiPoint
+                    typeCode = InternalSpatialDatatype.POINT.getTypeCode();
+                } else if (parentTypeCode == 5) { // MultiLineString
+                    typeCode = InternalSpatialDatatype.LINESTRING.getTypeCode();
+                } else if (parentTypeCode == 6) { // MultiPolygon
+                    typeCode = InternalSpatialDatatype.POLYGON.getTypeCode();
+                } else if (parentTypeCode == 7) { // GeometryCollection
+                    typeCode = InternalSpatialDatatype.GEOMETRYCOLLECTION.getTypeCode();
+                } else {
+                    throw new IllegalArgumentException("Illegal parentTypeCode."); 
+                }
+            } else {
+                typeCode = isd.getTypeCode();
+            }
+            
+            shapeList.add(new Shape(parentShapeIndex, -1, typeCode));
+            skipWhiteSpaces();
+            if (currentWktPos < wkt.length() && wkt.charAt(currentWktPos) == ',') {
+                currentWktPos++;
+                skipWhiteSpaces();
+            }
+            return true;
+        }
+        
+        if (!potentialEmptyKeyword.equals("")) {
+            throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos); 
+        }
+        return false;
+    }
+    
+    private void incrementPointNumStartIfPointNotReused(int pointEndIndex) {
+        // We need to increment PointNumStart if the last point was actually not re-used in the points array.
+        // 0 for pointNumEnd indicates that this check is not applicable.
+        if (currentPointIndex + 1 >= pointEndIndex) {
+            currentPointIndex++;
+        }
+    }
+    
+    /**
+     * Helper used for resurcive iteration for constructing GeometryCollection in WKT form.
+     * 
+     * @param shapeEndIndex .
+     */
+    private void constructGeometryCollectionWKThelper(int shapeEndIndex) {
+        //phase 1: assume that there is no multi - stuff and no geometrycollection
+        while (currentShapeIndex < shapeEndIndex) {
+            InternalSpatialDatatype isd = InternalSpatialDatatype.valueOf(shapes[currentShapeIndex].getOpenGISType());
+            
+            int figureIndex = shapes[currentShapeIndex].getFigureOffset();
+            int pointIndexEnd = numberOfPoints;
+            int figureIndexEnd = numberOfFigures;
+            int segmentIndexEnd = numberOfSegments;
+            int shapeIndexEnd = numberOfShapes;
+            int figureIndexIncrement = 0;
+            int segmentIndexIncrement = 0;
+            int shapeIndexIncrement = 0;
+            int localCurrentSegmentIndex = 0;
+            int localCurrentShapeIndex = 0;
+            
+            switch (isd) {
+                case POINT:
+                    figureIndexIncrement++;
+                    currentShapeIndex++;
+                    break;
+                case LINESTRING:
+                case CIRCULARSTRING:
+                    figureIndexIncrement++;
+                    currentShapeIndex++;
+                    pointIndexEnd = figures[figureIndex + 1].getPointOffset();
+                    break;
+                case POLYGON:
+                case CURVEPOLYGON:
+                    if (currentShapeIndex < shapes.length - 1) {
+                        figureIndexEnd = shapes[currentShapeIndex + 1].getFigureOffset();
+                    }
+                    
+                    figureIndexIncrement = figureIndexEnd - currentFigureIndex;
+                    currentShapeIndex++;
+                    
+                    // Needed to keep track of which segment we are at, inside the for loop
+                    localCurrentSegmentIndex = currentSegmentIndex;
+                    
+                    if (isd.equals(InternalSpatialDatatype.CURVEPOLYGON)) {
+                        // assume Version 2
+
+                        for (int i = currentFigureIndex; i < figureIndexEnd; i++) {
+                            // Only Compoundcurves (with figure attribute 3) can have segments
+                            if (figures[i].getFiguresAttribute() == 3) {
+                                
+                                int pointOffsetEnd;
+                                if (i == figures.length - 1) {
+                                    pointOffsetEnd = numberOfPoints;
+                                } else {
+                                    pointOffsetEnd = figures[i + 1].getPointOffset();
+                                }
+                                
+                                int increment = calculateSegmentIncrement(localCurrentSegmentIndex, pointOffsetEnd - figures[i].getPointOffset());
+
+                                segmentIndexIncrement = segmentIndexIncrement + increment;
+                                localCurrentSegmentIndex = localCurrentSegmentIndex + increment;
+                            }
+                        }
+                    }
+                    
+                    segmentIndexEnd = localCurrentSegmentIndex;
+                    
+                    break;
+                case MULTIPOINT:
+                case MULTILINESTRING:
+                case MULTIPOLYGON:
+                    //Multipoint and MultiLineString can go on for multiple Shapes, but eventually
+                    //the parentOffset will signal the end of the object, or it's reached the end of the
+                    //shapes array.
+                    //There is also no possibility that a MultiPoint or MultiLineString would branch
+                    //into another parent.
+                    
+                    int thisShapesParentOffset = shapes[currentShapeIndex].getParentOffset();
+                    
+                    int tempShapeIndex = currentShapeIndex;
+                    
+                    // Increment shapeStartIndex to account for the shape index that either Multipoint, MultiLineString
+                    // or MultiPolygon takes up
+                    tempShapeIndex++;
+                    while (tempShapeIndex < shapes.length && 
+                            shapes[tempShapeIndex].getParentOffset() != thisShapesParentOffset) {
+                        if (!(tempShapeIndex == shapes.length - 1) && // last iteration, don't check for shapes[tempShapeIndex + 1]
+                                !(shapes[tempShapeIndex + 1].getFigureOffset() == -1)) { // disregard EMPTY cases
+                            figureIndexEnd = shapes[tempShapeIndex + 1].getFigureOffset();
+                        }
+                        tempShapeIndex++;
+                    }
+                    
+                    figureIndexIncrement = figureIndexEnd - currentFigureIndex;
+                    shapeIndexIncrement = tempShapeIndex - currentShapeIndex;
+                    shapeIndexEnd = tempShapeIndex;
+                    break;
+                case GEOMETRYCOLLECTION:
+                    appendToWKTBuffers(isd.getTypeName());
+                    
+                    // handle Empty GeometryCollection cases
+                    if (shapes[currentShapeIndex].getFigureOffset() == -1) {
+                        appendToWKTBuffers(" EMPTY");
+                        currentShapeIndex++;
+                        if (currentShapeIndex < shapeEndIndex) {
+                            appendToWKTBuffers(", ");
+                        }
+                        continue;
+                    }
+                    
+                    appendToWKTBuffers("(");
+                    
+                    int geometryCollectionParentIndex = shapes[currentShapeIndex].getParentOffset();
+                    
+                    // Needed to keep track of which shape we are at, inside the for loop
+                    localCurrentShapeIndex = currentShapeIndex;
+                    
+                    while (localCurrentShapeIndex < shapes.length - 1 && 
+                            shapes[localCurrentShapeIndex + 1].getParentOffset() > geometryCollectionParentIndex) {
+                        localCurrentShapeIndex++;
+                    }
+                    // increment localCurrentShapeIndex one more time since it will be used as a shapeEndIndex parameter
+                    // for constructGeometryCollectionWKT, and the shapeEndIndex parameter is used non-inclusively
+                    localCurrentShapeIndex++;
+                    
+                    currentShapeIndex++;
+                    constructGeometryCollectionWKThelper(localCurrentShapeIndex);
+                    
+                    if (currentShapeIndex < shapeEndIndex) {
+                        appendToWKTBuffers("), ");
+                    } else {
+                        appendToWKTBuffers(")");
+                    }
+
+                    continue;
+                case COMPOUNDCURVE:
+                    if (currentFigureIndex == figures.length - 1) {
+                        pointIndexEnd = numberOfPoints;
+                    } else {
+                        pointIndexEnd = figures[currentFigureIndex + 1].getPointOffset();
+                    }
+
+                    int increment = calculateSegmentIncrement(currentSegmentIndex, pointIndexEnd - 
+                            figures[currentFigureIndex].getPointOffset());
+
+                    segmentIndexIncrement = increment;
+                    segmentIndexEnd = currentSegmentIndex + increment;
+                    figureIndexIncrement++;
+                    currentShapeIndex++;
+                    break;
+                case FULLGLOBE:
+                    appendToWKTBuffers("FULLGLOBE");
+                    break;
+                default:
+                    break;
+            }
+            
+            constructWKT(this, isd, pointIndexEnd, figureIndexEnd, segmentIndexEnd, shapeIndexEnd);
+            currentFigureIndex = currentFigureIndex + figureIndexIncrement;
+            currentSegmentIndex = currentSegmentIndex + segmentIndexIncrement;
+            currentShapeIndex = currentShapeIndex + shapeIndexIncrement;
+            
+            if (currentShapeIndex < shapeEndIndex) {
+                appendToWKTBuffers(", ");
+            }
+        }
+    }
+
+    /**
+     * Calculates how many segments will be used by this shape.
+     * Needed to determine when the shape that uses segments (e.g. CompoundCurve) needs to stop reading
+     * in cases where the CompoundCurve is included as part of GeometryCollection.
+     * 
+     * @param segmentStart .
+     * @param pointDifference number of points that were assigned to this segment to be used.
+     * @return the number of segments that will be used by this shape.
+     */
+    private int calculateSegmentIncrement(int segmentStart,
+            int pointDifference) {
+        
+        int segmentIncrement = 0;
+        
+        while (pointDifference > 0) {
+            switch (segments[segmentStart].getSegmentType()) {
+                case 0:
+                    pointDifference = pointDifference - 1;
+                    
+                    if (segmentStart == segments.length - 1 || pointDifference < 1) { // last segment
+                        break;
+                    } else if (segments[segmentStart + 1].getSegmentType() != 0) { // one point will be reused
+                        pointDifference = pointDifference + 1;
+                    }
+                    break;
+                case 1:
+                    pointDifference = pointDifference - 2;
+                    
+                    if (segmentStart == segments.length - 1 || pointDifference < 1) { // last segment
+                        break;
+                    } else if (segments[segmentStart + 1].getSegmentType() != 1) { // one point will be reused
+                        pointDifference = pointDifference + 1;
+                    }
+                    break;
+                case 2:
+                    pointDifference = pointDifference - 2;
+                    
+                    if (segmentStart == segments.length - 1 || pointDifference < 1) { // last segment
+                        break;
+                    } else if (segments[segmentStart + 1].getSegmentType() != 0) { // one point will be reused
+                        pointDifference = pointDifference + 1;
+                    }
+                    break;
+                case 3:
+                    pointDifference = pointDifference - 3;
+                    
+                    if (segmentStart == segments.length - 1 || pointDifference < 1) { // last segment
+                        break;
+                    } else if (segments[segmentStart + 1].getSegmentType() != 1) { // one point will be reused
+                        pointDifference = pointDifference + 1;
+                    }
+                    break;
+                default:
+                    return segmentIncrement;
+            }
+            segmentStart++;
+            segmentIncrement++;
+        }
+        
+        return segmentIncrement;
+    }
+
+    private void skipFirstPointWkt() {
+        int numOfCoordinates = 0;
+        
+        while (numOfCoordinates < 4) {
+            if (wkt.charAt(currentWktPos) == '-') {
+                currentWktPos++;
+            }
+            
+            if (wkt.charAt(currentWktPos) == ')') {
+                break;
+            }
+            
+            while (currentWktPos < wkt.length() && 
+                    (Character.isDigit(wkt.charAt(currentWktPos))
+                            || wkt.charAt(currentWktPos) == '.'       
+                            || wkt.charAt(currentWktPos) == 'E'
+                            || wkt.charAt(currentWktPos) == 'e')) {
+                currentWktPos++;
+            }
+            
+            skipWhiteSpaces();
+            if (wkt.charAt(currentWktPos) == ',') {
+                currentWktPos++;
+                skipWhiteSpaces();
+                numOfCoordinates++;
+                break;
+            }
+            skipWhiteSpaces();
+            
+            numOfCoordinates++;
+        }
+    }
+    
+    private void readComma() {
+        skipWhiteSpaces();
+        if (wkt.charAt(currentWktPos) == ',') {
+            currentWktPos++;
+            skipWhiteSpaces();
+        } else {
+            throw new IllegalArgumentException("Illegal character at wkt position " + currentWktPos);
+        }
+    }
+    
+    private void skipWhiteSpaces() {
+        while (currentWktPos < wkt.length() && Character.isWhitespace(wkt.charAt(currentWktPos))) {
+            currentWktPos++;
+        }
+    }
+}
+
+/**
+ * Class to hold and represent the internal makings of a Figure.
+ *
+ */
+class Figure {
+    private byte figuresAttribute;
+    private int pointOffset;
+    
+    Figure(byte figuresAttribute, int pointOffset) {
+        this.figuresAttribute = figuresAttribute;
+        this.pointOffset = pointOffset;
+    }
+    
+    public byte getFiguresAttribute() {
+        return figuresAttribute;
+    }
+    
+    public int getPointOffset() {
+        return pointOffset;
+    }
+    
+    public void setFiguresAttribute(byte fa) {
+        figuresAttribute = fa;
+    }
+}
+
+/**
+ * Class to hold and represent the internal makings of a Shape.
+ *
+ */
+class Shape {
+    private int parentOffset;
+    private int figureOffset;
+    private byte openGISType;
+    
+    Shape(int parentOffset, int figureOffset, byte openGISType) {
+        this.parentOffset = parentOffset;
+        this.figureOffset = figureOffset;
+        this.openGISType = openGISType;
+    }
+    
+    public int getParentOffset() {
+        return parentOffset;
+    }
+    
+    public int getFigureOffset() {
+        return figureOffset;
+    }
+    
+    public byte getOpenGISType() {
+        return openGISType;
+    }
+    
+    public void setFigureOffset(int fo) {
+        figureOffset = fo;
+    }
+    
+}
+
+/**
+ * Class to hold and represent the internal makings of a Segment.
+ *
+ */
+class Segment {
+    private byte segmentType;
+    
+    Segment(byte segmentType) {
+        this.segmentType = segmentType;
+    }
+    
+    public byte getSegmentType() {
+        return segmentType;
+    }
+}
+
+/**
+ * Class to hold and represent the internal makings of a Point.
+ *
+ */
+class Point {
+    private final double x;
+    private final double y;
+    private final double z;
+    private final double m;
+    
+    Point(double x, double y, double z, double m) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.m = m;
+    }
+    
+    public double getX() {
+        return x;
+    }
+    
+    public double getY() {
+        return y;
+    }
+    
+    public double getZ() {
+        return z;
+    }
+    
+    public double getM() {
+        return m;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java
index 7d7608433..512363b4a 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java
@@ -16,6 +16,7 @@
 import java.sql.SQLException;
 import java.sql.SQLWarning;
 import java.sql.Statement;
+import java.sql.SQLTimeoutException;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.ListIterator;
@@ -188,7 +189,7 @@ final ExecuteProperties getExecProps() {
      *
      * The TDSCommand is assumed to be a statement execution command (StmtExecCmd, PrepStmtExecCmd, PrepStmtBatchExecCmd).
      */
-    final void executeStatement(TDSCommand newStmtCmd) throws SQLServerException {
+    final void executeStatement(TDSCommand newStmtCmd) throws SQLServerException, SQLTimeoutException {
         // Ensure that any response left over from a previous execution has been
         // completely processed. There may be ENVCHANGEs in that response that
         // we must acknowledge before proceeding.
@@ -202,6 +203,11 @@ final void executeStatement(TDSCommand newStmtCmd) throws SQLServerException {
         try {
             // (Re)execute this Statement with the new command
             executeCommand(newStmtCmd);
+        } catch (SQLServerException e) {
+        	if (e.getDriverErrorCode() == SQLServerException.ERROR_QUERY_TIMEOUT)
+        		throw new SQLTimeoutException(e.getMessage(), e.getSQLState(), e.getErrorCode(), e.getCause());
+        	else
+        		throw e;
         }
         finally {
             lastStmtExecCmd = newStmtCmd;
@@ -217,7 +223,7 @@ final void executeStatement(TDSCommand newStmtCmd) throws SQLServerException {
      * This method does not prevent applications from simultaneously executing commands from multiple threads. The assumption is that apps only call
      * cancel() from another thread while the command is executing.
      */
-    final void executeCommand(TDSCommand newCommand) throws SQLServerException {
+    final void executeCommand(TDSCommand newCommand) throws SQLServerException{
         // Set the new command as the current command so that
         // its execution can be cancelled from another thread
         currentCommand = newCommand;
@@ -650,18 +656,18 @@ public void closeOnCompletion() throws SQLException {
      *                The SQL was invalid.
      * @return a JDBC result set.
      */
-    public java.sql.ResultSet executeQuery(String sql) throws SQLServerException {
+    public java.sql.ResultSet executeQuery(String sql) throws SQLServerException, SQLTimeoutException {
         loggerExternal.entering(getClassNameLogging(), "executeQuery", sql);
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
         }
         checkClosed();
-        executeStatement(new StmtExecCmd(this, sql, EXECUTE_QUERY, NO_GENERATED_KEYS));
+    	executeStatement(new StmtExecCmd(this, sql, EXECUTE_QUERY, NO_GENERATED_KEYS));
         loggerExternal.exiting(getClassNameLogging(), "executeQuery", resultSet);
         return resultSet;
     }
 
-    final SQLServerResultSet executeQueryInternal(String sql) throws SQLServerException {
+    final SQLServerResultSet executeQueryInternal(String sql) throws SQLServerException, SQLTimeoutException {
         checkClosed();
         executeStatement(new StmtExecCmd(this, sql, EXECUTE_QUERY_INTERNAL, NO_GENERATED_KEYS));
         return resultSet;
@@ -676,7 +682,7 @@ final SQLServerResultSet executeQueryInternal(String sql) throws SQLServerExcept
      *                The SQL was invalid.
      * @return The number of rows updated.
      */
-    public int executeUpdate(String sql) throws SQLServerException {
+    public int executeUpdate(String sql) throws SQLServerException, SQLTimeoutException {
         loggerExternal.entering(getClassNameLogging(), "executeUpdate", sql);
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
@@ -702,7 +708,7 @@ public int executeUpdate(String sql) throws SQLServerException {
      *                The SQL was invalid.
      * @return The number of rows updated.
      */
-    public long executeLargeUpdate(String sql) throws SQLServerException {
+    public long executeLargeUpdate(String sql) throws SQLServerException, SQLTimeoutException {
         DriverJDBCVersion.checkSupportsJDBC42();
 
         loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate", sql);
@@ -725,7 +731,7 @@ public long executeLargeUpdate(String sql) throws SQLServerException {
      *                The SQL statement was not valid.
      * @return True if a result set was generated.
      */
-    public boolean execute(String sql) throws SQLServerException {
+    public boolean execute(String sql) throws SQLServerException, SQLTimeoutException {
         loggerExternal.entering(getClassNameLogging(), "execute", sql);
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
@@ -1687,7 +1693,7 @@ public void clearBatch() throws SQLServerException {
     /**
      * Send a batch of statements to the database.
      */
-    public int[] executeBatch() throws SQLServerException, BatchUpdateException {
+    public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQLTimeoutException {
         loggerExternal.entering(getClassNameLogging(), "executeBatch");
         if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) {
             loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString());
@@ -1764,7 +1770,7 @@ public int[] executeBatch() throws SQLServerException, BatchUpdateException {
         }
     } // executeBatch
 
-    public long[] executeLargeBatch() throws SQLServerException, BatchUpdateException {
+    public long[] executeLargeBatch() throws SQLServerException, BatchUpdateException, SQLTimeoutException {
         DriverJDBCVersion.checkSupportsJDBC42();
 
         loggerExternal.entering(getClassNameLogging(), "executeLargeBatch");
@@ -1960,7 +1966,7 @@ private void doExecuteCursored(StmtExecCmd execCmd,
     }
 
     public final boolean execute(java.lang.String sql,
-            int autoGeneratedKeys) throws SQLServerException {
+            int autoGeneratedKeys) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) {
             loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, autoGeneratedKeys});
             if (Util.IsActivityTraceOn()) {
@@ -1980,7 +1986,7 @@ public final boolean execute(java.lang.String sql,
     }
 
     public final boolean execute(java.lang.String sql,
-            int[] columnIndexes) throws SQLServerException {
+            int[] columnIndexes) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
             loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, columnIndexes});
         checkClosed();
@@ -1993,7 +1999,7 @@ public final boolean execute(java.lang.String sql,
     }
 
     public final boolean execute(java.lang.String sql,
-            java.lang.String[] columnNames) throws SQLServerException {
+            java.lang.String[] columnNames) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
             loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, columnNames});
         checkClosed();
@@ -2006,7 +2012,7 @@ public final boolean execute(java.lang.String sql,
     }
 
     public final int executeUpdate(String sql,
-            int autoGeneratedKeys) throws SQLServerException {
+            int autoGeneratedKeys) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) {
             loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, autoGeneratedKeys});
             if (Util.IsActivityTraceOn()) {
@@ -2031,7 +2037,7 @@ public final int executeUpdate(String sql,
     }
 
     public final long executeLargeUpdate(String sql,
-            int autoGeneratedKeys) throws SQLServerException {
+            int autoGeneratedKeys) throws SQLServerException, SQLTimeoutException {
         DriverJDBCVersion.checkSupportsJDBC42();
 
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) {
@@ -2052,7 +2058,7 @@ public final long executeLargeUpdate(String sql,
     }
 
     public final int executeUpdate(java.lang.String sql,
-            int[] columnIndexes) throws SQLServerException {
+            int[] columnIndexes) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
             loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, columnIndexes});
         checkClosed();
@@ -2065,7 +2071,7 @@ public final int executeUpdate(java.lang.String sql,
     }
 
     public final long executeLargeUpdate(java.lang.String sql,
-            int[] columnIndexes) throws SQLServerException {
+            int[] columnIndexes) throws SQLServerException, SQLTimeoutException {
         DriverJDBCVersion.checkSupportsJDBC42();
 
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
@@ -2080,7 +2086,7 @@ public final long executeLargeUpdate(java.lang.String sql,
     }
 
     public final int executeUpdate(java.lang.String sql,
-            String[] columnNames) throws SQLServerException {
+            String[] columnNames) throws SQLServerException, SQLTimeoutException {
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
             loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, columnNames});
         checkClosed();
@@ -2093,7 +2099,7 @@ public final int executeUpdate(java.lang.String sql,
     }
 
     public final long executeLargeUpdate(java.lang.String sql,
-            String[] columnNames) throws SQLServerException {
+            String[] columnNames) throws SQLServerException, SQLTimeoutException {
         DriverJDBCVersion.checkSupportsJDBC42();
 
         if (loggerExternal.isLoggable(java.util.logging.Level.FINER))
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java
index 53ff357d4..be00a276a 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java
@@ -11,6 +11,7 @@
 import java.sql.CallableStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.SQLTimeoutException;
 import java.sql.Statement;
 import java.sql.Types;
 import java.text.MessageFormat;
@@ -408,7 +409,11 @@ private String typeDisplay(int type) {
                                 if (xaLogger.isLoggable(Level.FINER))
                                     xaLogger.finer(toString() + " exception:" + eX);
                                 throw eX;
-                            }
+                            } catch (SQLTimeoutException e4) {
+                                if (xaLogger.isLoggable(Level.FINER))
+                                    xaLogger.finer(toString() + " exception:" + e4);
+                                throw new SQLServerException(e4.getMessage(), SQLState.STATEMENT_CANCELED, DriverError.NOT_SET, null);
+			    }
 
                             // Check for error response from xp_sqljdbc_xa_init.
                             int initStatus = initCS.getInt(1);
@@ -726,7 +731,7 @@ else if (-1 != version.indexOf('.')) {
                 }
             }
         }
-        catch (SQLServerException ex) {
+        catch (SQLServerException | SQLTimeoutException ex) {
             if (xaLogger.isLoggable(Level.FINER))
                 xaLogger.finer(toString() + " exception:" + ex);
             XAException e = new XAException(ex.toString());
diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java
index 584cfd681..a0767b6fc 100644
--- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java
+++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java
@@ -1631,6 +1631,12 @@ final void executeOp(DTVExecuteOp op) throws SQLServerException {
                     else if (JDBCType.SQL_VARIANT == jdbcType) {
                         op.execute(this, String.valueOf(value));
                     }
+                    else if (JDBCType.GEOMETRY == jdbcType) {
+                        op.execute(this, ((Geometry) value).serialize());
+                    }
+                    else if (JDBCType.GEOGRAPHY == jdbcType) {
+                        op.execute(this, ((Geography) value).serialize());
+                    }
                     else {
                         if (null != cryptoMeta) {
                             // if streaming types check for allowed data length in AE
diff --git a/src/main/java/microsoft/sql/Types.java b/src/main/java/microsoft/sql/Types.java
index 9f510c2ec..b2e7cb5d0 100644
--- a/src/main/java/microsoft/sql/Types.java
+++ b/src/main/java/microsoft/sql/Types.java
@@ -57,4 +57,14 @@ private Types() {
      * The constant in the Java programming language, sometimes referred to as a type code, that identifies the Microsoft SQL type SQL_VARIANT.
      */
     public static final int SQL_VARIANT = -156;
+    
+    /**
+     * The constant in the Java programming language, sometimes referred to as a type code, that identifies the Microsoft SQL type GEOMETRY.
+     */
+    public static final int GEOMETRY = -157;
+    
+    /**
+     * The constant in the Java programming language, sometimes referred to as a type code, that identifies the Microsoft SQL type GEOGRAPHY.
+     */
+    public static final int GEOGRAPHY = -158;
 }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/AlwaysEncrypted/AESetup.java b/src/test/java/com/microsoft/sqlserver/jdbc/AlwaysEncrypted/AESetup.java
index dd4d588df..0c31108ac 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/AlwaysEncrypted/AESetup.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/AlwaysEncrypted/AESetup.java
@@ -31,7 +31,6 @@
 import com.microsoft.sqlserver.jdbc.SQLServerColumnEncryptionJavaKeyStoreProvider;
 import com.microsoft.sqlserver.jdbc.SQLServerColumnEncryptionKeyStoreProvider;
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
 import com.microsoft.sqlserver.jdbc.SQLServerStatement;
 import com.microsoft.sqlserver.jdbc.SQLServerStatementColumnEncryptionSetting;
@@ -119,11 +118,10 @@ static void setUpConnection() throws TestAbortedException, Exception {
      * Dropping all CMKs and CEKs and any open resources. Technically, dropAll depends on the state of the class so it shouldn't be static, but the
      * AfterAll annotation requires it to be static.
      * 
-     * @throws SQLServerException
      * @throws SQLException
      */
     @AfterAll
-    private static void dropAll() throws SQLServerException, SQLException {
+    private static void dropAll() throws SQLException {
         dropTables(stmt);
         dropCEK(stmt);
         dropCMK(stmt);
@@ -2058,10 +2056,9 @@ protected static void populateNumericNormalCase(String[] numericValues) throws S
     /**
      * Dropping column encryption key
      * 
-     * @throws SQLServerException
      * @throws SQLException
      */
-    private static void dropCEK(SQLServerStatement stmt) throws SQLServerException, SQLException {
+    private static void dropCEK(SQLServerStatement stmt) throws SQLException {
         String cekSql = " if exists (SELECT name from sys.column_encryption_keys where name='" + cekName + "')" + " begin"
                 + " drop column encryption key " + cekName + " end";
         stmt.execute(cekSql);
@@ -2070,10 +2067,9 @@ private static void dropCEK(SQLServerStatement stmt) throws SQLServerException,
     /**
      * Dropping column master key
      * 
-     * @throws SQLServerException
      * @throws SQLException
      */
-    private static void dropCMK(SQLServerStatement stmt) throws SQLServerException, SQLException {
+    private static void dropCMK(SQLServerStatement stmt) throws SQLException {
         String cekSql = " if exists (SELECT name from sys.column_master_keys where name='" + cmkName + "')" + " begin" + " drop column master key "
                 + cmkName + " end";
         stmt.execute(cekSql);
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/AlwaysEncrypted/CallableStatementTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/AlwaysEncrypted/CallableStatementTest.java
index cc6a67e29..bc0c8f173 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/AlwaysEncrypted/CallableStatementTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/AlwaysEncrypted/CallableStatementTest.java
@@ -26,7 +26,6 @@
 import java.util.LinkedList;
 
 import com.microsoft.sqlserver.jdbc.SQLServerCallableStatement;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
 import com.microsoft.sqlserver.jdbc.SQLServerResultSet;
 import com.microsoft.sqlserver.testframework.Utils;
@@ -83,7 +82,6 @@ public class CallableStatementTest extends AESetup {
     /**
      * Initialize the tables for this class. This method will execute AFTER the parent class (AESetup) finishes initializing.
      * 
-     * @throws SQLServerException
      * @throws SQLException
      */
     @BeforeAll
@@ -113,7 +111,7 @@ public static void initCallableStatementTest() throws SQLException {
     }
 
     @AfterAll
-    private static void dropAll() throws SQLServerException, SQLException {
+    private static void dropAll() throws SQLException {
         dropTables();
     }
 
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/UtilTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/UtilTest.java
index 85f27900b..783a8fc03 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/UtilTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/UtilTest.java
@@ -9,6 +9,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import java.sql.SQLException;
 import java.util.UUID;
 
 import org.junit.jupiter.api.Test;
@@ -23,7 +24,7 @@
 public class UtilTest {
 
     @Test
-    public void readGUIDtoUUID() throws SQLServerException {
+    public void readGUIDtoUUID() throws SQLException {
         UUID expected = UUID.fromString("6F9619FF-8B86-D011-B42D-00C04FC964FF");
         byte[] guid = new byte[] {-1, 25, -106, 111, -122, -117, 17, -48, -76, 45, 0, -64, 79, -55, 100, -1};
         assertEquals(expected, Util.readGUIDtoUUID(guid));
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyCSVTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyCSVTest.java
index ebf311225..ebd648a3c 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyCSVTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyCSVTest.java
@@ -30,7 +30,6 @@
 import com.microsoft.sqlserver.jdbc.ISQLServerBulkRecord;
 import com.microsoft.sqlserver.jdbc.SQLServerBulkCSVFileRecord;
 import com.microsoft.sqlserver.jdbc.SQLServerBulkCopy;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.DBConnection;
 import com.microsoft.sqlserver.testframework.DBResultSet;
@@ -80,7 +79,7 @@ void testCSV() {
         try (SQLServerBulkCSVFileRecord fileRecord = new SQLServerBulkCSVFileRecord(filePath + inputFile, encoding, delimiter, true)) {
             testBulkCopyCSV(fileRecord, true);
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             fail(e.getMessage());
         }
     }
@@ -94,7 +93,7 @@ void testCSVFirstLineNotColumnName() {
         try (SQLServerBulkCSVFileRecord fileRecord = new SQLServerBulkCSVFileRecord(filePath + inputFileNoColumnName, encoding, delimiter, false)) {
             testBulkCopyCSV(fileRecord, false);
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             fail(e.getMessage());
         }
     }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyConnectionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyConnectionTest.java
index f56039813..abcae31a8 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyConnectionTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyConnectionTest.java
@@ -29,7 +29,6 @@
 import com.microsoft.sqlserver.jdbc.SQLServerBulkCopy;
 import com.microsoft.sqlserver.jdbc.SQLServerBulkCopyOptions;
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 
 /**
  * Test BulkCopy Connection Constructor and BulkCopyOption
@@ -87,7 +86,7 @@ public void execute() {
     @Test
     @DisplayName("BulkCopy:test uninitialized Connection")
     void testInvalidConnection1() {
-        assertThrows(SQLServerException.class, new org.junit.jupiter.api.function.Executable() {
+        assertThrows(SQLException.class, new org.junit.jupiter.api.function.Executable() {
             @Override
             public void execute() throws SQLException {
                 try(Connection con = null;
@@ -104,9 +103,9 @@ public void execute() throws SQLException {
     @Test
     @DisplayName("BulkCopy:test uninitialized SQLServerConnection")
     void testInvalidConnection2() {
-        assertThrows(SQLServerException.class, new org.junit.jupiter.api.function.Executable() {
+        assertThrows(SQLException.class, new org.junit.jupiter.api.function.Executable() {
             @Override
-            public void execute() throws SQLServerException {
+            public void execute() throws SQLException {
                 try(SQLServerConnection con = null;
                 	SQLServerBulkCopy bulkCopy = new SQLServerBulkCopy(con)) {
                 	//do nothing
@@ -121,9 +120,9 @@ public void execute() throws SQLServerException {
     @Test
     @DisplayName("BulkCopy:test empty connenction string")
     void testInvalidConnection3() {
-        assertThrows(SQLServerException.class, new org.junit.jupiter.api.function.Executable() {
+        assertThrows(SQLException.class, new org.junit.jupiter.api.function.Executable() {
             @Override
-            public void execute() throws SQLServerException {
+            public void execute() throws SQLException {
                 String connectionUrl = " ";
                 try(SQLServerBulkCopy bulkCopy = new SQLServerBulkCopy(connectionUrl)) {
                 	//do nothing
@@ -138,9 +137,9 @@ public void execute() throws SQLServerException {
     @Test
     @DisplayName("BulkCopy:test null connenction string")
     void testInvalidConnection4() {
-        assertThrows(SQLServerException.class, new org.junit.jupiter.api.function.Executable() {
+        assertThrows(SQLException.class, new org.junit.jupiter.api.function.Executable() {
             @Override
-            public void execute() throws SQLServerException {
+            public void execute() throws SQLException {
                 String connectionUrl = null;
                 try(SQLServerBulkCopy bulkCopy = new SQLServerBulkCopy(connectionUrl)) {
                 	//do nothing
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyTimeoutTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyTimeoutTest.java
index 3773e75fa..0db8f67a7 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyTimeoutTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/BulkCopyTimeoutTest.java
@@ -9,6 +9,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.sql.SQLException;
 import java.util.concurrent.ThreadLocalRandom;
 
 import org.junit.jupiter.api.DisplayName;
@@ -17,7 +18,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerBulkCopyOptions;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 
 /**
  * Test the timeout in SQLServerBulkCopyOptions. Source table is created with large row count so skip data validation.
@@ -33,31 +33,31 @@ public class BulkCopyTimeoutTest extends BulkCopyTestSetUp {
     /**
      * BulkCopy:test zero timeout
      * 
-     * @throws SQLServerException
+     * @throws SQLException
      */
     @Test
     @DisplayName("BulkCopy:test zero timeout")
-    void testZeroTimeOut() throws SQLServerException {
+    void testZeroTimeOut() throws SQLException {
         testBulkCopyWithTimeout(0);
     }
 
     /**
-     * To verify SQLServerException: The timeout argument cannot be negative.
+     * To verify SQLException: The timeout argument cannot be negative.
      * 
-     * @throws SQLServerException
+     * @throws SQLException
      */
     @Test
     @DisplayName("BulkCopy:test negative timeout")
-    void testNegativeTimeOut() throws SQLServerException {
-        assertThrows(SQLServerException.class, new org.junit.jupiter.api.function.Executable() {
+    void testNegativeTimeOut() throws SQLException {
+        assertThrows(SQLException.class, new org.junit.jupiter.api.function.Executable() {
             @Override
-            public void execute() throws SQLServerException {
+            public void execute() throws SQLException {
                 testBulkCopyWithTimeout(-1);
             }
         });
     }
     
-    private void testBulkCopyWithTimeout(int timeout) throws SQLServerException {
+    private void testBulkCopyWithTimeout(int timeout) throws SQLException {
     	BulkCopyTestWrapper bulkWrapper = new BulkCopyTestWrapper(connectionString);
         bulkWrapper.setUsingConnection((0 == ThreadLocalRandom.current().nextInt(2)) ? true : false);
         SQLServerBulkCopyOptions option = new SQLServerBulkCopyOptions();
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/ISQLServerBulkRecordIssuesTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/ISQLServerBulkRecordIssuesTest.java
index bbb83e148..23ba2127c 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/ISQLServerBulkRecordIssuesTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/bulkCopy/ISQLServerBulkRecordIssuesTest.java
@@ -67,7 +67,7 @@ public void testVarchar() throws Exception {
             fail("BulkCopy executed for testVarchar when it it was expected to fail");
         }
         catch (Exception e) {
-            if (e instanceof SQLServerException) {
+            if (e instanceof SQLException) {
                 assertTrue(e.getMessage().contains("The given value of type"), "Invalid Error message: " + e.toString());
             }
             else {
@@ -120,7 +120,7 @@ public void testSmalldatetimeOutofRange() throws Exception {
             fail("BulkCopy executed for testSmalldatetimeOutofRange when it it was expected to fail");
         }
         catch (Exception e) {
-            if (e instanceof SQLServerException) {
+            if (e instanceof SQLException) {
                 assertTrue(e.getMessage().contains("Conversion failed when converting character string to smalldatetime data type"),
                         "Invalid Error message: " + e.toString());
             }
@@ -148,7 +148,7 @@ public void testBinaryColumnAsByte() throws Exception {
             fail("BulkCopy executed for testBinaryColumnAsByte when it it was expected to fail");
         }
         catch (Exception e) {
-            if (e instanceof SQLServerException) {
+            if (e instanceof SQLException) {
                 assertTrue(e.getMessage().contains("The given value of type"), "Invalid Error message: " + e.toString());
             }
             else {
@@ -175,7 +175,7 @@ public void testBinaryColumnAsString() throws Exception {
             fail("BulkCopy executed for testBinaryColumnAsString when it it was expected to fail");
         }
         catch (Exception e) {
-            if (e instanceof SQLServerException) {
+            if (e instanceof SQLException) {
                 assertTrue(e.getMessage().contains("The given value of type"), "Invalid Error message: " + e.toString());
             }
             else {
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java
index 2c4c191f2..287786c0f 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java
@@ -20,7 +20,6 @@
 
 import com.microsoft.sqlserver.jdbc.SQLServerCallableStatement;
 import com.microsoft.sqlserver.jdbc.SQLServerDataSource;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.Utils;
 
@@ -151,8 +150,8 @@ public void inputParamsTest() throws SQLException {
         CallableStatement cs3 = connection.prepareCall(call);
         try {
             cs3.setString("@whatever", "test");
-            fail("SQLServerException should have been thrown");
-        } catch (SQLServerException sse) {
+            fail("SQLException should have been thrown");
+        } catch (SQLException sse) {
             if (!sse.getMessage().startsWith("Parameter @whatever was not defined")) {
                 fail("Unexpected content in exception message");
             }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/connection/ConnectionDriverTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/connection/ConnectionDriverTest.java
index 2acf5f002..3de43f7c1 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/ConnectionDriverTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/ConnectionDriverTest.java
@@ -39,7 +39,6 @@
 import com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource;
 import com.microsoft.sqlserver.jdbc.SQLServerDataSource;
 import com.microsoft.sqlserver.jdbc.SQLServerDriver;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.DBConnection;
 import com.microsoft.sqlserver.testframework.DBTable;
@@ -56,10 +55,10 @@ public class ConnectionDriverTest extends AbstractTest {
     /**
      * test SSL properties
      * 
-     * @throws SQLServerException
+     * @throws SQLException
      */
     @Test
-    public void testConnectionDriver() throws SQLServerException {
+    public void testConnectionDriver() throws SQLException {
         SQLServerDriver d = new SQLServerDriver();
         Properties info = new Properties();
         StringBuffer url = new StringBuffer();
@@ -307,7 +306,7 @@ public void testDeadConnection() throws SQLException {
 	            stmt.execute("SELECT x1.col1 as foo, x2.col1 as bar, x1.col1 as eeep FROM " + tableName + " as x1, " + tableName
 	                    + " as x2; RAISERROR ('Oops', 21, 42) WITH LOG");
 	        }
-	        catch (SQLServerException e) {
+	        catch (SQLException e) {
 	            assertEquals(e.getMessage(), "Connection reset", "Unknown Exception");
 	        }
 	        finally {
@@ -327,7 +326,7 @@ public void testClientConnectionId() throws Exception {
             conn.getClientConnectionId();
             throw new Exception("No exception thrown calling getClientConnectionId on a closed connection");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             assertEquals(e.getMessage(), "The connection is closed.", "Wrong exception message");
         }
 
@@ -339,7 +338,7 @@ public void testClientConnectionId() throws Exception {
             conn.close();
 
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             assertTrue(e.getMessage().indexOf("ClientConnectionId") != -1,
                     "Unexpected: ClientConnectionId is not in exception message due to wrong DB");
         }
@@ -351,14 +350,14 @@ public void testClientConnectionId() throws Exception {
             conn.close();
 
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             assertEquals(false, e.getMessage().indexOf("ClientConnectionId") != -1,
                     "Unexpected: ClientConnectionId is in exception message due to wrong host");
         }
     }
 
     @Test
-    public void testIncorrectDatabase() throws SQLServerException {
+    public void testIncorrectDatabase() throws SQLException {
         long timerStart = 0;
         long timerEnd = 0;
         Connection con = null;
@@ -382,7 +381,7 @@ public void testIncorrectDatabase() throws SQLServerException {
     }
 
     @Test
-    public void testIncorrectUserName() throws SQLServerException {
+    public void testIncorrectUserName() throws SQLException {
         long timerStart = 0;
         long timerEnd = 0;
         Connection con = null;
@@ -406,7 +405,7 @@ public void testIncorrectUserName() throws SQLServerException {
     }
 
     @Test
-    public void testIncorrectPassword() throws SQLServerException {
+    public void testIncorrectPassword() throws SQLException {
         long timerStart = 0;
         long timerEnd = 0;
         Connection con = null;
@@ -430,7 +429,7 @@ public void testIncorrectPassword() throws SQLServerException {
     }
 
     @Test
-    public void testInvalidCombination() throws SQLServerException {
+    public void testInvalidCombination() throws SQLException {
         long timerStart = 0;
         long timerEnd = 0;
         Connection con = null;
@@ -456,7 +455,7 @@ public void testInvalidCombination() throws SQLServerException {
 
     @Test
     @Tag("slow")
-    public void testIncorrectDatabaseWithFailoverPartner() throws SQLServerException {
+    public void testIncorrectDatabaseWithFailoverPartner() throws SQLException {
         long timerStart = 0;
         long timerEnd = 0;
         Connection con = null;
@@ -484,7 +483,7 @@ public void testAbortBadParam() throws SQLException {
         try {
             conn.abort(null);
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             assertTrue(e.getMessage().contains("The argument executor is not valid"));
         }
     }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/connection/DriverVersionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/connection/DriverVersionTest.java
index bbd0ca5d6..bb4176d1d 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/DriverVersionTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/DriverVersionTest.java
@@ -9,6 +9,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.Random;
 
@@ -17,7 +18,6 @@
 import org.junit.platform.runner.JUnitPlatform;
 import org.junit.runner.RunWith;
 
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.util.Util;
 
@@ -39,10 +39,10 @@ public class DriverVersionTest extends AbstractTest {
 
     /**
      * validates version byte array generated by the original method and type casting reminds the same.
-     * @throws SQLServerException 
+     * @throws SQLException 
      */
     @Test
-    public void testConnectionDriver() throws SQLServerException {
+    public void testConnectionDriver() throws SQLException {
         // the original way to create version byte array
         String interfaceLibVersion = generateInterfaceLibVersion();
         byte originalVersionBytes[] = Util.hexStringToByte(interfaceLibVersion);
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/connection/NativeMSSQLDataSourceTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/connection/NativeMSSQLDataSourceTest.java
index 57803a32e..b7d0edc3f 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/NativeMSSQLDataSourceTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/NativeMSSQLDataSourceTest.java
@@ -27,7 +27,6 @@
 import com.microsoft.sqlserver.jdbc.ISQLServerDataSource;
 import com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource;
 import com.microsoft.sqlserver.jdbc.SQLServerDataSource;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerXADataSource;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 
@@ -71,7 +70,7 @@ public void testDSTSPassword() throws ClassNotFoundException, IOException, SQLEx
         try (Connection conn = ds.getConnection()) {}
         ds = testSerial(ds);
         try (Connection conn = ds.getConnection()) {}
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             assertEquals("The DataSource trustStore password needs to be set.", e.getMessage());
         }
     }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/connection/PoolingTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/connection/PoolingTest.java
index 1a51deb34..428c7d0cf 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/PoolingTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/PoolingTest.java
@@ -30,7 +30,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.ISQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerXADataSource;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.DBConnection;
@@ -70,7 +69,7 @@ public void testPooling() throws SQLException {
         try (Connection conn = pc.getConnection()) {
             conn.createStatement().executeQuery("select * from [" + tempTableName + "]");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             // make sure the temporary table is not found.
             if (e.getMessage().startsWith("Invalid object name")) {
                 tempTableFileRemoved = true;
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/connection/TimeoutTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/connection/TimeoutTest.java
index 2141cac42..95446191d 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/connection/TimeoutTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/connection/TimeoutTest.java
@@ -20,7 +20,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.Utils;
 import com.microsoft.sqlserver.testframework.util.RandomUtil;
@@ -52,7 +51,7 @@ public void testDefaultLoginTimeout() {
     }
 
     @Test
-    public void testFailoverInstanceResolution() throws SQLServerException {
+    public void testFailoverInstanceResolution() throws SQLException {
         long timerStart = 0;
         long timerEnd = 0;
         try {
@@ -72,7 +71,7 @@ public void testFailoverInstanceResolution() throws SQLServerException {
     }
 
     @Test
-    public void testFOInstanceResolution2() throws SQLServerException {
+    public void testFOInstanceResolution2() throws SQLException {
         long timerStart = 0;
         long timerEnd = 0;
         try {
@@ -108,7 +107,7 @@ public void testQueryTimeout() throws Exception {
             throw new Exception("Exception for queryTimeout is not thrown.");
         }
         catch (Exception e) {
-            if (!(e instanceof SQLServerException)) {
+            if (!(e instanceof java.sql.SQLTimeoutException)) {
                 throw e;
             }
             assertEquals(e.getMessage(), "The query has timed out.", "Invalid exception message");
@@ -138,14 +137,14 @@ public void testSocketTimeout() throws Exception {
             throw new Exception("Exception for socketTimeout is not thrown.");
         }
         catch (Exception e) {
-            if (!(e instanceof SQLServerException)) {
+            if (!(e instanceof SQLException)) {
                 throw e;
             }
             assertEquals(e.getMessage(), "Read timed out", "Invalid exception message");
         }
         try{
             conn.createStatement().execute("SELECT @@version");
-        }catch (SQLServerException e) {
+        }catch (SQLException e) {
             assertEquals(e.getMessage(), "The connection is closed.", "Invalid exception message");
         }
     }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataForeignKeyTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataForeignKeyTest.java
index b498a6afb..1e67af40c 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataForeignKeyTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataForeignKeyTest.java
@@ -13,6 +13,7 @@
 
 import java.sql.DriverManager;
 import java.sql.SQLException;
+import java.sql.SQLTimeoutException;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -22,7 +23,6 @@
 
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
 import com.microsoft.sqlserver.jdbc.SQLServerDatabaseMetaData;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerResultSet;
 import com.microsoft.sqlserver.jdbc.SQLServerStatement;
 import com.microsoft.sqlserver.testframework.AbstractTest;
@@ -95,10 +95,11 @@ private static void terminateVariation() throws SQLException {
     /**
      * test getImportedKeys() methods
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testGetImportedKeys() throws SQLServerException {
+    public void testGetImportedKeys() throws SQLException {
         SQLServerDatabaseMetaData dmd = (SQLServerDatabaseMetaData) connection.getMetaData();
 
         SQLServerResultSet rs1 = (SQLServerResultSet) dmd.getImportedKeys(null, null, table1);
@@ -114,12 +115,12 @@ public void testGetImportedKeys() throws SQLServerException {
             dmd.getImportedKeys("", schema, table1);
             fail("Exception is not thrown.");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             assertTrue(e.getMessage().startsWith(EXPECTED_ERROR_MESSAGE));
         }
     }
 
-    private void validateGetImportedKeysResults(SQLServerResultSet rs) throws SQLServerException {
+    private void validateGetImportedKeysResults(SQLServerResultSet rs) throws SQLException {
         int expectedRowCount = 4;
         int rowCount = 0;
         
@@ -151,10 +152,11 @@ private void validateGetImportedKeysResults(SQLServerResultSet rs) throws SQLSer
     /**
      * test getExportedKeys() methods
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testGetExportedKeys() throws SQLServerException {
+    public void testGetExportedKeys() throws SQLException {
         String[] tableNames = {table2, table3, table4, table5};
         int[][] values = {
                 // expected UPDATE_RULE, expected DELETE_RULE
@@ -187,7 +189,7 @@ public void testGetExportedKeys() throws SQLServerException {
                 dmd.getExportedKeys("", schema, pkTable);
                 fail("Exception is not thrown.");
             }
-            catch (SQLServerException e) {
+            catch (SQLException e) {
                 assertTrue(e.getMessage().startsWith(EXPECTED_ERROR_MESSAGE));
             }
         }
@@ -196,10 +198,11 @@ public void testGetExportedKeys() throws SQLServerException {
     /**
      * test getCrossReference() methods
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testGetCrossReference() throws SQLServerException {
+    public void testGetCrossReference() throws SQLException {
         String fkTable = table1;
         String[] tableNames = {table2, table3, table4, table5};
         int[][] values = {
@@ -233,7 +236,7 @@ public void testGetCrossReference() throws SQLServerException {
                 dmd.getCrossReference("", schema, pkTable, "", schema, fkTable);
                 fail("Exception is not thrown.");
             }
-            catch (SQLServerException e) {
+            catch (SQLException e) {
                 assertEquals(EXPECTED_ERROR_MESSAGE2, e.getMessage());
             }
         }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java
index 9db744faa..fdc3d917a 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java
@@ -31,7 +31,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerDatabaseMetaData;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.StringUtils;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.Utils;
@@ -62,15 +61,13 @@ public void testDatabaseMetaDataWrapper() throws SQLException {
      * //TODO: OSGI: Test for capability 1.7 for JDK 1.7 and 1.8 for 1.8 //Require-Capability: osgi.ee;filter:="(&(osgi.ee=JavaSE)(version=1.8))" //String
      * capability = attributes.getValue("Require-Capability");  
      * 
-     * @throws SQLServerException
-     *             Our Wrapped Exception
      * @throws SQLException
      *             SQL Exception
      * @throws IOException
      *             IOExcption
      */
     @Test
-    public void testDriverVersion() throws SQLServerException, SQLException, IOException {
+    public void testDriverVersion() throws SQLException, IOException {
         String manifestFile = Utils.getCurrentClassPath() + "META-INF/MANIFEST.MF";
         manifestFile = manifestFile.replace("test-classes", "classes");
 
@@ -113,11 +110,10 @@ public void testDriverVersion() throws SQLServerException, SQLException, IOExcep
     /**
      * Your password should not be in getURL method.
      * 
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testGetURL() throws SQLServerException, SQLException {
+    public void testGetURL() throws SQLException {
         DatabaseMetaData databaseMetaData = connection.getMetaData();
         String url = databaseMetaData.getURL();
         url = url.toLowerCase();
@@ -127,11 +123,10 @@ public void testGetURL() throws SQLServerException, SQLException {
     /**
      * Test getUsername.
      * 
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testDBUserLogin() throws SQLServerException, SQLException {
+    public void testDBUserLogin() throws SQLException {
         DatabaseMetaData databaseMetaData = connection.getMetaData();
 
         String connectionString = getConfiguredProperty("mssql_jdbc_test_connection_properties");
@@ -163,11 +158,10 @@ else if (connectionString.contains("user")) {
 
     /**
      * Testing of {@link SQLServerDatabaseMetaData#getSchemas()}
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testDBSchema() throws SQLServerException, SQLException {
+    public void testDBSchema() throws SQLException {
         DatabaseMetaData databaseMetaData = connection.getMetaData();
 
         ResultSet rs = databaseMetaData.getSchemas();
@@ -180,11 +174,10 @@ public void testDBSchema() throws SQLServerException, SQLException {
     /**
      * Get All Tables.
      * 
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testDBTables() throws SQLServerException, SQLException {
+    public void testDBTables() throws SQLException {
         DatabaseMetaData databaseMetaData = connection.getMetaData();
         
         ResultSet rsCatalog = databaseMetaData.getCatalogs();
@@ -206,11 +199,10 @@ public void testDBTables() throws SQLServerException, SQLException {
      *  <li> Create table with appropriate column size, data types,auto increment, NULLABLE etc.  
      *  <li> Then get databasemetatadata.getColumns to see if there is any mismatch.
      * </ul>
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testGetDBColumn() throws SQLServerException, SQLException {
+    public void testGetDBColumn() throws SQLException {
         DatabaseMetaData databaseMetaData = connection.getMetaData();
         String[] types = {"TABLE"};
         ResultSet rs = databaseMetaData.getTables(null, null, "%", types);
@@ -241,11 +233,10 @@ public void testGetDBColumn() throws SQLServerException, SQLException {
      * <li> We can check if PRIVILEGE is in between CRUD / REFERENCES / SELECT / INSERT etc.
      * <li> IS_GRANTABLE can have only 2 values YES / NO
      * </ul>
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testGetColumnPrivileges() throws SQLServerException, SQLException {
+    public void testGetColumnPrivileges() throws SQLException {
         DatabaseMetaData databaseMetaData = connection.getMetaData();
         String[] types = {"TABLE"};
         ResultSet rsTables = databaseMetaData.getTables(null, null, "%", types);
@@ -273,11 +264,10 @@ public void testGetColumnPrivileges() throws SQLServerException, SQLException {
      * TODO: Check JDBC Specs: Can we have any tables/functions without category? 
      * 
      * Testing {@link SQLServerDatabaseMetaData#getFunctions(String, String, String)} with sending wrong category.
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testGetFunctionsWithWrongParams() throws SQLServerException, SQLException {
+    public void testGetFunctionsWithWrongParams() throws SQLException {
         try {
         DatabaseMetaData databaseMetaData = connection.getMetaData();
         databaseMetaData.getFunctions("", null, "xp_%");
@@ -289,11 +279,10 @@ public void testGetFunctionsWithWrongParams() throws SQLServerException, SQLExce
     
     /**
      * Test {@link SQLServerDatabaseMetaData#getFunctions(String, String, String)}
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testGetFunctions() throws SQLServerException, SQLException {
+    public void testGetFunctions() throws SQLException {
         DatabaseMetaData databaseMetaData = connection.getMetaData();
         ResultSet rs = databaseMetaData.getFunctions(null, null, "xp_%");
         
@@ -311,11 +300,10 @@ public void testGetFunctions() throws SQLServerException, SQLException {
     
     /**
      * Te
-     * @throws SQLServerException
      * @throws SQLException
      */
     @Test
-    public void testGetFunctionColumns()  throws SQLServerException, SQLException{
+    public void testGetFunctionColumns()  throws SQLException{
         DatabaseMetaData databaseMetaData = connection.getMetaData();
         ResultSet rsFunctions = databaseMetaData.getFunctions(null, null, "%");
         
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/SQLServerSpatialDatatypeTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/SQLServerSpatialDatatypeTest.java
new file mode 100644
index 000000000..28bd072db
--- /dev/null
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/SQLServerSpatialDatatypeTest.java
@@ -0,0 +1,917 @@
+/*
+ * Microsoft JDBC Driver for SQL Server
+ * 
+ * Copyright(c) Microsoft Corporation All rights reserved.
+ * 
+ * This program is made available under the terms of the MIT License. See the LICENSE file in the project root for more information.
+ */
+package com.microsoft.sqlserver.jdbc.datatypes;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+import com.microsoft.sqlserver.jdbc.Geography;
+import com.microsoft.sqlserver.jdbc.Geometry;
+import com.microsoft.sqlserver.jdbc.SQLServerConnection;
+import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
+import com.microsoft.sqlserver.jdbc.SQLServerResultSet;
+import com.microsoft.sqlserver.testframework.AbstractTest;
+import com.microsoft.sqlserver.testframework.Utils;
+
+/**
+ * Test Geometry / Geography classes
+ *
+ */
+@RunWith(JUnitPlatform.class)
+public class SQLServerSpatialDatatypeTest extends AbstractTest  {
+
+    static SQLServerConnection con = null;
+    static Statement stmt = null;
+    static String geomTableName = "geometryTestTable";
+    static String geogTableName = "geographyTestTable";
+    static String spatialDatatypeTableName = "spatialDatatypeTestTable";
+    static SQLServerPreparedStatement pstmt = null;
+    static SQLServerResultSet rs = null;
+    static boolean isDenaliOrLater = false;
+
+    @Test
+    public void testPointWkb() throws DecoderException {
+        String geoWKT = "POINT(3 40 5 6)";
+        byte[] geomWKB = Hex.decodeHex("00000000010F0000000000000840000000000000444000000000000014400000000000001840".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E6100000010F0000000000004440000000000000084000000000000014400000000000001840".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testLineStringWkb() throws DecoderException {
+        String geoWKT = "LINESTRING(1 0, 0 1, -1 0)";
+        byte[] geomWKB = Hex.decodeHex("00000000010403000000000000000000F03F00000000000000000000000000000000000000000000F03F000000000000F0BF000000000000000001000000010000000001000000FFFFFFFF0000000002".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E61000000104030000000000000000000000000000000000F03F000000000000F03F00000000000000000000000000000000000000000000F0BF01000000010000000001000000FFFFFFFF0000000002".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testPolygonWkb() throws DecoderException {
+        String geoWKT = "POLYGON((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1))";
+        byte[] geomWKB = Hex.decodeHex("000000000104090000000000000000000000000000000000000000000000000000000000000000000840000000000000084000000000000008400000000000000840000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F00000000000000400000000000000040000000000000F03F000000000000F03F000000000000F03F020000000200000000000500000001000000FFFFFFFF0000000003".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E61000000200090000000000000000000000000000000000000000000000000008400000000000000000000000000000084000000000000008400000000000000000000000000000084000000000000000000000000000000000000000000000F03F000000000000F03F0000000000000040000000000000F03F000000000000F03F0000000000000040000000000000F03F000000000000F03F020000000100000000010500000001000000FFFFFFFF0000000003".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testMultiPointWkb() throws DecoderException {
+        String geoWKT = "MULTIPOINT((2 3), (7 8 9.5))";
+        byte[] geomWKB = Hex.decodeHex("00000000010502000000000000000000004000000000000008400000000000001C400000000000002040000000000000F8FF0000000000002340020000000100000000010100000003000000FFFFFFFF0000000004000000000000000001000000000100000001".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E61000000105020000000000000000000840000000000000004000000000000020400000000000001C40000000000000F8FF0000000000002340020000000100000000010100000003000000FFFFFFFF0000000004000000000000000001000000000100000001".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testMultiLineStringWkb() throws DecoderException {
+        String geoWKT = "MULTILINESTRING((0 2, 1 1), (1 0, 1 1))";
+        byte[] geomWKB = Hex.decodeHex("0000000001040400000000000000000000000000000000000040000000000000F03F000000000000F03F000000000000F03F0000000000000000000000000000F03F000000000000F03F020000000100000000010200000003000000FFFFFFFF0000000005000000000000000002000000000100000002".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E610000001040400000000000000000000400000000000000000000000000000F03F000000000000F03F0000000000000000000000000000F03F000000000000F03F000000000000F03F020000000100000000010200000003000000FFFFFFFF0000000005000000000000000002000000000100000002".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testMultiPolygonWkb() throws DecoderException {
+        String geoWKT = "MULTIPOLYGON(((1 1, 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9)))";
+        byte[] geomWKB = Hex.decodeHex("0000000001010D000000000000000000F03F000000000000F03F000000000000F03F00000000000000400000000000000040000000000000F03F000000000000F03F000000000000F03F000000000000000000000000000000000000000000000000000000000000084000000000000008400000000000000840000000000000084000000000000000000000000000000000000000000000000000000000000022400000000000002240000000000000224000000000000024400000000000002440000000000000224000000000000022400000000000002240000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF0000000000001C40000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF0300000002000000000004000000020900000003000000FFFFFFFF0000000006000000000000000003000000000200000003".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E610000002010D000000000000000000F03F000000000000F03F0000000000000040000000000000F03F000000000000F03F0000000000000040000000000000F03F000000000000F03F000000000000000000000000000000000000000000000840000000000000000000000000000008400000000000000840000000000000000000000000000008400000000000000000000000000000000000000000000022400000000000002240000000000000244000000000000022400000000000002240000000000000244000000000000022400000000000002240000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF0000000000001C40000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF0300000001000000000104000000010900000003000000FFFFFFFF0000000006000000000000000003000000000200000003".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testGeometryCollectionWkb() throws DecoderException {
+        String geoWKT = "GEOMETRYCOLLECTION(POINT(3 3 1), LINESTRING(1 0, 0 1, -1 0), CIRCULARSTRING(1 3, 3 5, 4 7, 7 3, 1 3), POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2), (0 0 2, 1 10 3, 1 0 4, 0 0 2), (0 0 2, 1 10 3, 1 0 4, 0 0 2)), MULTIPOINT((2 3), (7 8 9.5)), MULTILINESTRING((0 2, 1 1), (1 0, 1 1)), MULTIPOLYGON(((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1)), ((9 9, 9 10, 10 9, 9 9))), COMPOUNDCURVE(CIRCULARSTRING(1 0 3, 0 1 3, 9 6 3, 8 7 3, -1 0 3), CIRCULARSTRING(-1 0 3, 7 9 3, -10 2 3), (-10 2 3, 77 77 77, 88 88 88, 2 6 4), (2 6 4, 3 3 6, 7 7 1)), CURVEPOLYGON((0 0, 0 0, 0 0, 0 0), COMPOUNDCURVE((0 -23.43778, 0 23.43778), CIRCULARSTRING(0 23.43778, -45 -23.43778, 0 -23.43778)), COMPOUNDCURVE((0 -23.43778, 7 7, 0 23.43778), CIRCULARSTRING(0 23.43778, 8 8, 8 8, -45 23.43778, -90 23.43778), (-90 23.43778, -90 -23.43778), CIRCULARSTRING(-90 -23.43778, -45 -23.43778, 0 -23.43778))), POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2)))";
+        byte[] geomWKB = Hex.decodeHex("0100000002014A00000000000000000008400000000000000840000000000000F03F00000000000000000000000000000000000000000000F03F000000000000F0BF0000000000000000000000000000F03F00000000000008400000000000000840000000000000144000000000000010400000000000001C400000000000001C400000000000000840000000000000F03F000000000000084000000000000000000000000000000000000000000000F03F0000000000002440000000000000F03F00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F03F0000000000002440000000000000F03F00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F03F0000000000002440000000000000F03F000000000000000000000000000000000000000000000000000000000000004000000000000008400000000000001C40000000000000204000000000000000000000000000000040000000000000F03F000000000000F03F000000000000F03F0000000000000000000000000000F03F000000000000F03F0000000000000000000000000000000000000000000000000000000000000840000000000000084000000000000008400000000000000840000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F00000000000000400000000000000040000000000000F03F000000000000F03F000000000000F03F00000000000022400000000000002240000000000000224000000000000024400000000000002440000000000000224000000000000022400000000000002240000000000000F03F00000000000000000000000000000000000000000000F03F0000000000002240000000000000184000000000000020400000000000001C40000000000000F0BF00000000000000000000000000001C40000000000000224000000000000024C00000000000000040000000000040534000000000004053400000000000005640000000000000564000000000000000400000000000001840000000000000084000000000000008400000000000001C400000000000001C40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C7D79E59127037C00000000000000000C7D79E591270374000000000008046C0C7D79E59127037C00000000000000000C7D79E59127037C00000000000000000C7D79E59127037C00000000000001C400000000000001C400000000000000000C7D79E5912703740000000000000204000000000000020400000000000002040000000000000204000000000008046C0C7D79E591270374000000000008056C0C7D79E591270374000000000008056C0C7D79E59127037C000000000008046C0C7D79E59127037C00000000000000000C7D79E59127037C000000000000000000000000000000000000000000000F03F0000000000002440000000000000F03F000000000000000000000000000000000000000000000000000000000000F03F000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000004000000000000008400000000000001040000000000000004000000000000000400000000000000840000000000000104000000000000000400000000000000040000000000000084000000000000010400000000000000040000000000000F8FF0000000000002340000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF00000000000008400000000000000840000000000000084000000000000008400000000000000840000000000000084000000000000008400000000000405340000000000000564000000000000010400000000000001840000000000000F03F000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF0000000000000040000000000000084000000000000010400000000000000040120000000100000000010100000002040000000109000000010D00000001110000000115000000011600000001170000000119000000011B00000001200000000124000000032800000001340000000338000000033C000000014600000011000000FFFFFFFF0000000007000000000000000001000000000100000002000000000200000008000000000300000003000000000600000004050000000600000001050000000700000001000000000800000005080000000800000002080000000900000002000000000A000000060B0000000A000000030B0000000C00000003000000000D00000009000000000E0000000A0000000011000000031000000003010302000002000203020003010203".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("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".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testCircularStringWkb() throws DecoderException {
+        String geoWKT = "CIRCULARSTRING(2 1 3 4, 1 2 3, 0 7 3, 1 0 3, 2 1 3)";
+        byte[] geomWKB = Hex.decodeHex("000000000207050000000000000000000040000000000000F03F000000000000F03F000000000000004000000000000000000000000000001C40000000000000F03F00000000000000000000000000000040000000000000F03F000000000000084000000000000008400000000000000840000000000000084000000000000008400000000000001040000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF01000000020000000001000000FFFFFFFF0000000008".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E6100000020705000000000000000000F03F00000000000000400000000000000040000000000000F03F0000000000001C4000000000000000000000000000000000000000000000F03F000000000000F03F0000000000000040000000000000084000000000000008400000000000000840000000000000084000000000000008400000000000001040000000000000F8FF000000000000F8FF000000000000F8FF000000000000F8FF01000000020000000001000000FFFFFFFF0000000008".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testCompoundCurveWkb() throws DecoderException {
+        String geoWKT = "COMPOUNDCURVE(CIRCULARSTRING(1 0 3, 0 1 3, 9 6 3, 8 7 3, -1 0 3), CIRCULARSTRING(-1 0 3, 7 9 3, -10 2 3), (-10 2 3, 77 77 77, 88 88 88, 2 6 4), (2 6 4, 3 3 6, 7 7 1))";
+        byte[] geomWKB = Hex.decodeHex("0000000002050C000000000000000000F03F00000000000000000000000000000000000000000000F03F0000000000002240000000000000184000000000000020400000000000001C40000000000000F0BF00000000000000000000000000001C40000000000000224000000000000024C00000000000000040000000000040534000000000004053400000000000005640000000000000564000000000000000400000000000001840000000000000084000000000000008400000000000001C400000000000001C4000000000000008400000000000000840000000000000084000000000000008400000000000000840000000000000084000000000000008400000000000405340000000000000564000000000000010400000000000001840000000000000F03F01000000030000000001000000FFFFFFFF0000000009080000000301030200000200".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E610000002050C0000000000000000000000000000000000F03F000000000000F03F0000000000000000000000000000184000000000000022400000000000001C4000000000000020400000000000000000000000000000F0BF00000000000022400000000000001C40000000000000004000000000000024C0000000000040534000000000004053400000000000005640000000000000564000000000000018400000000000000040000000000000084000000000000008400000000000001C400000000000001C4000000000000008400000000000000840000000000000084000000000000008400000000000000840000000000000084000000000000008400000000000405340000000000000564000000000000010400000000000001840000000000000F03F01000000030000000001000000FFFFFFFF0000000009080000000301030200000200".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+    
+    @Test
+    public void testCurvePolygonWkb() throws DecoderException {
+        String geoWKT = "CURVEPOLYGON((0 0, 0 0, 0 0, 0 0), CIRCULARSTRING(1 3, 3 5, 4 7, 7 3, 1 3), COMPOUNDCURVE((0 -23.43778, 0 23.43778), CIRCULARSTRING(0 23.43778, -45 -23.43778, 0 -23.43778)), COMPOUNDCURVE((0 -23.43778, 7 7, 0 23.43778), CIRCULARSTRING(0 23.43778, 8 8, 8 8, -45 23.43778, -90 23.43778), (-90 23.43778, -90 -23.43778), CIRCULARSTRING(-90 -23.43778, -45 -23.43778, 0 -23.43778)))";
+        byte[] geomWKB = Hex.decodeHex("0A00000002001700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F03F00000000000008400000000000000840000000000000144000000000000010400000000000001C400000000000001C400000000000000840000000000000F03F00000000000008400000000000000000C7D79E59127037C00000000000000000C7D79E591270374000000000008046C0C7D79E59127037C00000000000000000C7D79E59127037C00000000000000000C7D79E59127037C00000000000001C400000000000001C400000000000000000C7D79E5912703740000000000000204000000000000020400000000000002040000000000000204000000000008046C0C7D79E591270374000000000008056C0C7D79E591270374000000000008056C0C7D79E59127037C000000000008046C0C7D79E59127037C00000000000000000C7D79E59127037C004000000010000000002040000000309000000030D00000001000000FFFFFFFF000000000A080000000203020003010203".toCharArray());
+        byte[] geogWKB = Hex.decodeHex("E6100000020017000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000840000000000000F03F000000000000144000000000000008400000000000001C40000000000000104000000000000008400000000000001C400000000000000840000000000000F03FC7D79E59127037C00000000000000000C7D79E59127037400000000000000000C7D79E59127037C000000000008046C0C7D79E59127037C00000000000000000C7D79E59127037C000000000000000000000000000001C400000000000001C40C7D79E591270374000000000000000000000000000002040000000000000204000000000000020400000000000002040C7D79E591270374000000000008046C0C7D79E591270374000000000008056C0C7D79E59127037C000000000008056C0C7D79E59127037C000000000008046C0C7D79E59127037C0000000000000000004000000010000000002040000000309000000030D00000001000000FFFFFFFF000000000A080000000203020003010203".toCharArray());
+        Geometry geomWKT = Geometry.deserialize(geomWKB);
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geomWKT.asTextZM(), geoWKT);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+    
+    @Test
+    public void testFullGlobeWkb() throws DecoderException {
+        String geoWKT = "FULLGLOBE";
+        byte[] geogWKB = Hex.decodeHex("E61000000224000000000000000001000000FFFFFFFFFFFFFFFF0B".toCharArray());
+        Geography geogWKT = Geography.deserialize(geogWKB);
+        assertEquals(geogWKT.asTextZM(), geoWKT);
+    }
+
+    @Test
+    public void testPointWkt() throws SQLException {
+        beforeEachSetup();
+        String geoWKT = "POINT(3 40 5 6)";
+        testWkt(geoWKT);
+        beforeEachSetup();
+        geoWKT = "POINT EMPTY";
+        testWkt(geoWKT);
+    }
+
+    @Test
+    public void testLineStringWkt() throws SQLException {
+        beforeEachSetup();
+        String geoWKT = "LINESTRING(1 0, 0 1, -1 0)";
+        testWkt(geoWKT);
+        beforeEachSetup();
+        geoWKT = "LINESTRING EMPTY";
+        testWkt(geoWKT);
+    }
+
+    @Test
+    public void testPolygonWkt() throws SQLException {
+        beforeEachSetup();
+        String geoWKT = "POLYGON((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1))";
+        testWkt(geoWKT);
+        beforeEachSetup();
+        geoWKT = "POLYGON EMPTY";
+        testWkt(geoWKT);
+    }
+
+    @Test
+    public void testMultiPointWkt() throws SQLException {
+        beforeEachSetup();
+        String geoWKT = "MULTIPOINT((2 3), (7 8 9.5))";
+        testWkt(geoWKT);
+        beforeEachSetup();
+        geoWKT = "MULTIPOINT EMPTY";
+        testWkt(geoWKT);
+    }
+
+    @Test
+    public void testMultiLineStringWkt() throws SQLException {
+        beforeEachSetup();
+        String geoWKT = "MULTILINESTRING((0 2, 1 1), (1 0, 1 1))";
+        testWkt(geoWKT);
+        beforeEachSetup();
+        geoWKT = "MULTILINESTRING EMPTY";
+        testWkt(geoWKT);
+    }
+
+    @Test
+    public void testMultiPolygonWkt() throws SQLException {
+        beforeEachSetup();
+        String geoWKT = "MULTIPOLYGON(((1 1, 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9)))";
+        testWkt(geoWKT);
+        beforeEachSetup();
+        geoWKT = "MULTIPOLYGON EMPTY";
+        testWkt(geoWKT);
+    }
+
+    @Test
+    public void testGeometryCollectionWkt() throws SQLException {
+        String geoWKT;
+        if (isDenaliOrLater) {
+            beforeEachSetup();
+            geoWKT = "GEOMETRYCOLLECTION(POINT(3 3 1), LINESTRING(1 0, 0 1, -1 0), CIRCULARSTRING(1 3, 3 5, 4 7, 7 3, 1 3), POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2), (0 0 2, 1 10 3, 1 0 4, 0 0 2), (0 0 2, 1 10 3, 1 0 4, 0 0 2)), MULTIPOINT((2 3), (7 8 9.5)), MULTILINESTRING((0 2, 1 1), (1 0, 1 1)), MULTIPOLYGON(((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1)), ((9 9, 9 10, 10 9, 9 9))), COMPOUNDCURVE(CIRCULARSTRING(1 0 3, 0 1 3, 9 6 3, 8 7 3, -1 0 3), CIRCULARSTRING(-1 0 3, 7 9 3, -10 2 3), (-10 2 3, 77 77 77, 88 88 88, 2 6 4), (2 6 4, 3 3 6, 7 7 1)), CURVEPOLYGON((0 0, 0 0, 0 0, 0 0), COMPOUNDCURVE((0 -23.43778, 0 23.43778), CIRCULARSTRING(0 23.43778, -45 -23.43778, 0 -23.43778)), COMPOUNDCURVE((0 -23.43778, 7 7, 0 23.43778), CIRCULARSTRING(0 23.43778, 8 8, 8 8, -45 23.43778, -90 23.43778), (-90 23.43778, -90 -23.43778), CIRCULARSTRING(-90 -23.43778, -45 -23.43778, 0 -23.43778))), POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2)))";
+            testWkt(geoWKT);
+        }
+        beforeEachSetup();
+        geoWKT = "GEOMETRYCOLLECTION EMPTY";
+        testWkt(geoWKT);
+        beforeEachSetup();
+        geoWKT = "GEOMETRYCOLLECTION(GEOMETRYCOLLECTION EMPTY)";
+        testWkt(geoWKT);
+        beforeEachSetup();
+        geoWKT = "GEOMETRYCOLLECTION(POINT(3 3 1), GEOMETRYCOLLECTION EMPTY, MULTIPOLYGON(((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1)), EMPTY, EMPTY, ((0 0, 1 1, 2 2, 0 0)), EMPTY), GEOMETRYCOLLECTION EMPTY)";
+        testWkt(geoWKT);
+    }
+
+    @Test
+    public void testCircularStringWkt() throws SQLException {
+        if (isDenaliOrLater) {
+            beforeEachSetup();
+            String geoWKT = "CIRCULARSTRING(2 1 3 4, 1 2 3, 0 7 3, 1 0 3, 2 1 3)";
+            testWkt(geoWKT);
+            beforeEachSetup();
+            geoWKT = "CIRCULARSTRING EMPTY";
+            testWkt(geoWKT);
+        }
+    }
+
+    @Test
+    public void testCompoundCurveWkt() throws SQLException {
+        if (isDenaliOrLater) {
+            beforeEachSetup();
+            String geoWKT = "COMPOUNDCURVE(CIRCULARSTRING(1 0 3, 0 1 3, 9 6 3, 8 7 3, -1 0 3), CIRCULARSTRING(-1 0 3, 7 9 3, -10 2 3), (-10 2 3, 77 77 77, 88 88 88, 2 6 4), (2 6 4, 3 3 6, 7 7 1))";
+            testWkt(geoWKT);
+            beforeEachSetup();
+            geoWKT = "COMPOUNDCURVE EMPTY";
+            testWkt(geoWKT);
+        }
+    }
+    
+    @Test
+    public void testCurvePolygonWkt() throws SQLException {
+        if (isDenaliOrLater) {
+            beforeEachSetup();
+            String geoWKT = "CURVEPOLYGON((0 0, 0 0, 0 0, 0 0), CIRCULARSTRING(1 3, 3 5, 4 7, 7 3, 1 3), COMPOUNDCURVE((0 -23.43778, 0 23.43778), CIRCULARSTRING(0 23.43778, -45 -23.43778, 0 -23.43778)), COMPOUNDCURVE((0 -23.43778, 7 7, 0 23.43778), CIRCULARSTRING(0 23.43778, 8 8, 8 8, -45 23.43778, -90 23.43778), (-90 23.43778, -90 -23.43778), CIRCULARSTRING(-90 -23.43778, -45 -23.43778, 0 -23.43778)))";
+            testWkt(geoWKT);
+            beforeEachSetup();
+            geoWKT = "CURVEPOLYGON EMPTY";
+            testWkt(geoWKT);
+        }
+    }
+    
+    @Test
+    public void testFullGlobeWkt() throws SQLException {
+        if (isDenaliOrLater) {
+            beforeEachSetup();
+            
+            String geoWKT = "FULLGLOBE";
+            Geography geogWKT = Geography.STGeomFromText(geoWKT, 4326);
+
+            try {
+                Geometry.STGeomFromText(geoWKT, 0);
+            }
+            catch (IllegalArgumentException e) {
+                assertEquals(e.getMessage(), "Fullglobe is not supported for Geometry.");
+            }
+            
+            pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geogTableName + " values (?)");  
+            pstmt.setGeography(1, geogWKT);
+            pstmt.execute();
+            
+            rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geogTableName);
+            rs.next();
+            assertEquals(rs.getGeography(1).asTextZM(), geoWKT);
+        }
+    }
+    
+    @Test
+    public void testIrregularCases() throws SQLException {
+        beforeEachSetup();
+        
+        String geoWKT = "  GeOMETRyCOLlECTION(POINT(       3e2  2E1 1  ), GEOMETRYCOLLECTION  EmPTy  , GeometryCollection(GEometryCOLLEction(GEometryCOLLEction Empty)), "
+                + "POLYGON(  (0 0 2,   1 10 3, 1 0 4,   0 0 2))  )";
+        String geoWKTSS = "GEOMETRYCOLLECTION(POINT(300 20 1), GEOMETRYCOLLECTION EMPTY, GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(GEOMETRYCOLLECTION EMPTY)), POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2)))";
+        
+        testWkt(geoWKT, geoWKTSS);
+    }
+    
+    @Test
+    public void testIllegalCases() throws SQLException {
+        //Not enough closing bracket case
+        String geoWKT = "MULTIPOLYGON(((1 1, 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9))";
+        
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Reached unexpected end of WKT. Please make sure WKT is valid.");
+        }
+        
+        //Not enough closing and opening bracket case
+        geoWKT = "MULTIPOLYGON((1 1, 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9))";
+        
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Illegal character at wkt position 14");
+        }
+        
+        //Too many closing bracket
+        geoWKT = "MULTIPOLYGON(((1 1, 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9))))";
+        
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Illegal character at wkt position 91");
+        }
+        
+        //Too many opening bracket
+        geoWKT = "MULTIPOLYGON((((1 1, 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9)))";
+        
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Illegal character at wkt position 15");
+        }
+        
+        //Too many coordinates
+        geoWKT = "MULTIPOLYGON(((1 1 3 4 5, 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9)))";
+        
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Illegal character at wkt position 23");
+        }
+        
+        //Too little coordinates
+        geoWKT = "MULTIPOLYGON(((1 , 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9)))";
+        
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Illegal character at wkt position 17");
+        }
+        
+        //Incorrect data type
+        geoWKT = "IvnalidPolygon(((1 , 1 2, 2 1, 1 1), (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9)))";
+        
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Illegal character at wkt position 14");
+        }
+        
+        // too many commas
+        geoWKT = "MULTIPOLYGON(((1 1, 1 2, 2 1, 1 1),, (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9)))";
+
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Illegal character at wkt position 35");
+        }
+        
+        // too little commas
+        geoWKT = "MULTIPOLYGON(((1 1, 1 2, 2 1, 1 1) (0 0, 0 3, 3 3, 3 0, 0 0 7)), ((9 9, 9 10, 10 9, 9 9)))";
+        
+        try {
+            testWkt(geoWKT);
+        }
+        catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(), "Illegal character at wkt position 35");
+        }
+    }
+    
+    @Test
+    public void testAllTypes() throws SQLException {
+        if (isDenaliOrLater) {
+            beforeEachSetup();
+            
+            String geoWKTPoint = "POINT(30 12.12312312 5 6)";
+            String geoWKTLineString = "LINESTRING(1 1, 2 4 3, 3 9 123 332)";
+            String geoWKTCircularString = "CIRCULARSTRING(1 1, 2 4, 3 9)";
+            String geoWKTCompoundCurve = "COMPOUNDCURVE((1 1, 1 3), (1 3, 3 3), (3 3, 3 1), (3 1, 1 1))";
+            String geoWKTCurvePolygon = "CURVEPOLYGON(CIRCULARSTRING(2 4, 4 2, 6 4, 4 6, 2 4))";
+            String geoWKTPolygon = "POLYGON((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1))";
+            String geoWKTMultiPoint = "MULTIPOINT((2 3), (7 8 9.5))";
+            String geoWKTMultiLineString = "MULTILINESTRING((0 2, 1 1), (1 0, 1 1))";
+            String geoWKTMultiPolygon = "MULTIPOLYGON(((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1)), ((9 9, 9 10, 10 9, 9 9)))";
+            String geoWKTGeometryCollection = "GEOMETRYCOLLECTION(POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2)), POINT(3 3 1 2.5), LINESTRING(1 0, 0 1, -1 0), GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(POINT(1 2 3 4))), GEOMETRYCOLLECTION(GEOMETRYCOLLECTION EMPTY), CURVEPOLYGON((0 0, 0 0, 0 0, 0 0), CIRCULARSTRING(1 3, 3 5, 4 7, 7 3, 1 3), COMPOUNDCURVE((0 -23.43778, 0 23.43778), CIRCULARSTRING(0 23.43778, -45 -23.43778, 0 -23.43778)), COMPOUNDCURVE((0 -23.43778, 7 7, 0 23.43778), CIRCULARSTRING(0 23.43778, 8 8, 8 8, -45 23.43778, -90 23.43778), (-90 23.43778, -90 -23.43778), CIRCULARSTRING(-90 -23.43778, -45 -23.43778, 0 -23.43778))))";
+            
+            List<String> geoWKTList = new ArrayList<String>();
+            
+            geoWKTList.add(geoWKTPoint);
+            geoWKTList.add(geoWKTLineString);
+            geoWKTList.add(geoWKTCircularString);
+            geoWKTList.add(geoWKTCompoundCurve);
+            geoWKTList.add(geoWKTCurvePolygon);
+            geoWKTList.add(geoWKTPolygon);
+            geoWKTList.add(geoWKTMultiPoint);
+            geoWKTList.add(geoWKTMultiLineString);
+            geoWKTList.add(geoWKTMultiPolygon);
+            geoWKTList.add(geoWKTGeometryCollection);
+            
+            Geometry geomWKT;
+            Geography geogWKT;
+            
+            //Geometry
+            pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geomTableName + " values (?)");    
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTPoint, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTLineString, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTCircularString, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTCompoundCurve, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTCurvePolygon, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTPolygon, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTMultiPoint, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTMultiLineString, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTMultiPolygon, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTGeometryCollection, 0);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.executeUpdate();
+            
+            rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geomTableName);
+            for (int i = 0; i < geoWKTList.size(); i++) {
+                rs.next();
+                assertEquals(rs.getGeometry(1).asTextZM(), geoWKTList.get(i));
+            }
+            
+            //Geography
+            pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geogTableName + " values (?)");    
+            
+            geogWKT = Geography.STGeomFromText(geoWKTPoint, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTLineString, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTCircularString, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTCompoundCurve, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTCurvePolygon, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTPolygon, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTMultiPoint, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTMultiLineString, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTMultiPolygon, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            geogWKT = Geography.STGeomFromText(geoWKTGeometryCollection, 4326);
+            pstmt.setGeography(1, geogWKT);
+            
+            pstmt.executeUpdate();
+            
+            rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geogTableName);
+            for (int i = 0; i < geoWKTList.size(); i++) {
+                rs.next();
+                assertEquals(rs.getGeography(1).asTextZM(), geoWKTList.get(i));
+            }
+        }
+    }
+    
+    @Test
+    public void testMixedAllTypes() throws SQLException {
+        if (isDenaliOrLater) {
+            beforeEachSetupSpatialDatatype();
+            
+            String geoWKTPoint = "POINT(30 12.12312312 5 6)";
+            String geoWKTLineString = "LINESTRING(1 1, 2 4 3, 3 9 123 332)";
+            String geoWKTCircularString = "CIRCULARSTRING(1 1, 2 4, 3 9)";
+            String geoWKTCompoundCurve = "COMPOUNDCURVE((1 1, 1 3), (1 3, 3 3), (3 3, 3 1), (3 1, 1 1))";
+            String geoWKTCurvePolygon = "CURVEPOLYGON(CIRCULARSTRING(2 4, 4 2, 6 4, 4 6, 2 4))";
+            String geoWKTPolygon = "POLYGON((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1))";
+            String geoWKTMultiPoint = "MULTIPOINT((2 3), (7 8 9.5))";
+            String geoWKTMultiLineString = "MULTILINESTRING((0 2, 1 1), (1 0, 1 1))";
+            String geoWKTMultiPolygon = "MULTIPOLYGON(((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 1 2, 2 1, 1 1)), ((9 9, 9 10, 10 9, 9 9)))";
+            String geoWKTGeometryCollection = "GEOMETRYCOLLECTION(POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2)), POINT(3 3 1 2.5), LINESTRING(1 0, 0 1, -1 0), GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(POINT(1 2 3 4))), GEOMETRYCOLLECTION(GEOMETRYCOLLECTION EMPTY), CURVEPOLYGON((0 0, 0 0, 0 0, 0 0), CIRCULARSTRING(1 3, 3 5, 4 7, 7 3, 1 3), COMPOUNDCURVE((0 -23.43778, 0 23.43778), CIRCULARSTRING(0 23.43778, -45 -23.43778, 0 -23.43778)), COMPOUNDCURVE((0 -23.43778, 7 7, 0 23.43778), CIRCULARSTRING(0 23.43778, 8 8, 8 8, -45 23.43778, -90 23.43778), (-90 23.43778, -90 -23.43778), CIRCULARSTRING(-90 -23.43778, -45 -23.43778, 0 -23.43778))))";
+            
+            String s = "some string";
+            Double d = 31.34;
+            int i2 = 5;
+            
+            List<String> geoWKTList = new ArrayList<String>();
+            
+            geoWKTList.add(geoWKTPoint);
+            geoWKTList.add(geoWKTLineString);
+            geoWKTList.add(geoWKTCircularString);
+            geoWKTList.add(geoWKTCompoundCurve);
+            geoWKTList.add(geoWKTCurvePolygon);
+            geoWKTList.add(geoWKTPolygon);
+            geoWKTList.add(geoWKTMultiPoint);
+            geoWKTList.add(geoWKTMultiLineString);
+            geoWKTList.add(geoWKTMultiPolygon);
+            geoWKTList.add(geoWKTGeometryCollection);
+            
+            Geometry geomWKT;
+            Geography geogWKT;
+            
+            pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ spatialDatatypeTableName + " values (?, ?, ?, ?, ?)");    
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTPoint, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTPoint, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTLineString, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTLineString, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTCircularString, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTCircularString, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTCompoundCurve, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTCompoundCurve, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTCurvePolygon, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTCurvePolygon, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+
+            geomWKT = Geometry.STGeomFromText(geoWKTPolygon, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTPolygon, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTMultiPoint, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTMultiPoint, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTMultiLineString, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTMultiLineString, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTMultiPolygon, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTMultiPolygon, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            geomWKT = Geometry.STGeomFromText(geoWKTGeometryCollection, 0);
+            geogWKT = Geography.STGeomFromText(geoWKTGeometryCollection, 4326);
+            pstmt.setGeometry(1, geomWKT);
+            pstmt.setGeography(2, geogWKT);
+            pstmt.setString(3, s);
+            pstmt.setDouble(4, d);
+            pstmt.setInt(5, i2);
+            
+            pstmt.executeUpdate();
+            
+            rs = (SQLServerResultSet) stmt.executeQuery("select * from " + spatialDatatypeTableName);
+            for (int i = 0; i < geoWKTList.size(); i++) {
+                rs.next();
+                assertEquals(rs.getGeometry(1).asTextZM(), geoWKTList.get(i));
+                assertEquals(rs.getGeography(2).asTextZM(), geoWKTList.get(i));
+                assertEquals(rs.getString(3), s);
+                assertEquals((Double) rs.getDouble(4), d);
+                assertEquals(rs.getInt(5), i2);
+            }
+        }
+    }
+
+    @Test
+    public void testDecimalRounding() throws SQLException {
+        beforeEachSetup();
+        
+        String geoWKT = "POINT(3 40.7777777777777777777 5 6)";
+        String geoWKTSS = "POINT(3 40.77777777777778 5 6)";
+        
+        testWkt(geoWKT, geoWKTSS);
+    }
+    
+    @Test
+    public void testParse() throws SQLException {
+        beforeEachSetup();
+        
+        String geoWKT = "GEOMETRYCOLLECTION(POINT(300 20 1), GEOMETRYCOLLECTION EMPTY, GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(GEOMETRYCOLLECTION EMPTY)), POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2)))";
+        
+        Geometry geomWKT = Geometry.parse(geoWKT);
+        Geography geogWKT = Geography.parse(geoWKT);
+        
+        pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geomTableName + " values (?)");    
+        pstmt.setGeometry(1, geomWKT);
+        pstmt.execute();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geomTableName);
+        rs.next();
+        assertEquals(rs.getGeometry(1).asTextZM(), geoWKT);
+        assertEquals(rs.getGeometry(1).getSrid(), 0);
+        
+        pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geogTableName + " values (?)");  
+        pstmt.setGeography(1, geogWKT);
+        pstmt.execute();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geogTableName);
+        rs.next();
+        assertEquals(rs.getGeography(1).asTextZM(), geoWKT);
+        assertEquals(rs.getGeography(1).getSrid(), 4326);
+    }
+    
+    @Test
+    public void testPoint() throws SQLException {
+        beforeEachSetup();
+        
+        String geoWKT = "POINT(1 2)";
+        
+        Geometry geomWKT = Geometry.point(1, 2, 0);
+        Geography geogWKT = Geography.point(1, 2, 4326);
+        
+        pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geomTableName + " values (?)");    
+        pstmt.setGeometry(1, geomWKT);
+        pstmt.execute();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geomTableName);
+        rs.next();
+        assertEquals(rs.getGeometry(1).asTextZM(), geoWKT);
+        assertEquals(rs.getGeometry(1).getSrid(), 0);
+        
+        pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geogTableName + " values (?)");  
+        pstmt.setGeography(1, geogWKT);
+        pstmt.execute();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geogTableName);
+        rs.next();
+        assertEquals(rs.getGeography(1).asTextZM(), geoWKT);
+        assertEquals(rs.getGeography(1).getSrid(), 4326);
+    }
+    
+    @Test
+    public void testSTAsText() throws SQLException {
+        beforeEachSetup();
+        
+        String geoWKT = "GEOMETRYCOLLECTION(POINT(300 20 1), GEOMETRYCOLLECTION EMPTY, GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(GEOMETRYCOLLECTION EMPTY)), POLYGON((0 0 2, 1 10 3, 1 0 4, 0 0 2)))";
+        String geoWKTSS = "GEOMETRYCOLLECTION(POINT(300 20), GEOMETRYCOLLECTION EMPTY, GEOMETRYCOLLECTION(GEOMETRYCOLLECTION(GEOMETRYCOLLECTION EMPTY)), POLYGON((0 0, 1 10, 1 0, 0 0)))";
+        
+        Geometry geomWKT = Geometry.STGeomFromText(geoWKT, 0);
+        Geography geogWKT = Geography.STGeomFromText(geoWKT, 4326);
+        
+        pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geomTableName + " values (?)");    
+        pstmt.setGeometry(1, geomWKT);
+        pstmt.execute();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geomTableName);
+        rs.next();
+        assertEquals(rs.getGeometry(1).STAsText(), geoWKTSS);
+        
+        pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geogTableName + " values (?)");  
+        pstmt.setGeography(1, geogWKT);
+        pstmt.execute();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geogTableName);
+        rs.next();
+        assertEquals(rs.getGeography(1).STAsText(), geoWKTSS);
+    }
+    
+    @Test
+    public void testSTAsBinary() throws SQLException {
+        beforeEachSetup();
+        
+        String geoWKT = "POINT(3 40 5 6)";
+        String geoWKT2 = "POINT(3 40)";
+        
+        Geometry geomWKT = Geometry.STGeomFromText(geoWKT, 0);
+        Geography geogWKT = Geography.STGeomFromText(geoWKT, 4326);
+        
+        byte[] geomWKB = geomWKT.STAsBinary();
+        byte[] geogWKB = geogWKT.STAsBinary();
+        
+        Geometry geomWKT2 = Geometry.STGeomFromText(geoWKT2, 0);
+        Geography geogWKT2 = Geography.STGeomFromText(geoWKT2, 4326);
+        
+        byte[] geomWKB2 = geomWKT2.STAsBinary();
+        byte[] geogWKB2 = geogWKT2.STAsBinary();
+        
+        assertEquals(geomWKB, geomWKB2);
+        assertEquals(geogWKB, geogWKB2);
+    }
+    
+    private void beforeEachSetup() throws SQLException {
+        Utils.dropTableIfExists(geomTableName, stmt);
+        Utils.dropTableIfExists(geogTableName, stmt);
+        stmt.executeUpdate("Create table " + geomTableName + " (c1 geometry)");
+        stmt.executeUpdate("Create table " + geogTableName + " (c1 geography)");
+    }
+    
+    private void beforeEachSetupSpatialDatatype() throws SQLException {
+        Utils.dropTableIfExists(spatialDatatypeTableName, stmt);
+        stmt.executeUpdate("Create table " + spatialDatatypeTableName + 
+                " (c1 geometry,"
+                + "c2 geography,"
+                + "c3 nvarchar(512),"
+                + "c4 decimal(28,4),"
+                + "c5 int)");
+    }
+    
+    private void testWkt(String geoWKT) throws SQLException {
+        testWkt(geoWKT, geoWKT);
+    }
+    
+    private void testWkt(String geoWKT, String geoWKTSS) throws SQLException {
+        Geometry geomWKT = Geometry.STGeomFromText(geoWKT, 0);
+        Geography geogWKT = Geography.STGeomFromText(geoWKT, 4326);
+        
+        pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geomTableName + " values (?)");    
+        pstmt.setGeometry(1, geomWKT);
+        pstmt.execute();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geomTableName);
+        rs.next();
+        assertEquals(rs.getGeometry(1).asTextZM(), geoWKTSS);
+        
+        pstmt = (SQLServerPreparedStatement) con.prepareStatement("insert into "+ geogTableName + " values (?)");  
+        pstmt.setGeography(1, geogWKT);
+        pstmt.execute();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select c1 from " + geogTableName);
+        rs.next();
+        assertEquals(rs.getGeography(1).asTextZM(), geoWKTSS);
+    }
+    
+    /**
+     * Prepare test
+     * 
+     * @throws SQLException
+     * @throws SecurityException
+     * @throws IOException
+     */
+    @BeforeAll
+    public static void setupHere() throws SQLException, SecurityException, IOException {
+        con = (SQLServerConnection) DriverManager.getConnection(connectionString);
+        stmt = con.createStatement();
+        
+        rs = (SQLServerResultSet) stmt.executeQuery("select SERVERPROPERTY ( 'ProductVersion' )");
+        
+        rs.next();
+        
+        try {
+            int version = Integer.parseInt(rs.getString(1).substring(0, 2));
+            
+            // if major version is greater than or equal to 11, it's SQL Server 2012 or above.
+            if (version >= 11) {
+                isDenaliOrLater = true;
+            }
+        } catch (Exception e) {
+            // Do nothing.
+        }
+    }
+
+    /**
+     * drop the tables
+     * 
+     * @throws SQLException
+     */
+    @AfterAll
+    public static void afterAll() throws SQLException {
+        Utils.dropTableIfExists(geomTableName, stmt);
+        Utils.dropTableIfExists(geogTableName, stmt);
+
+        if (null != stmt) {
+            stmt.close();
+        }
+
+        if (null != pstmt) {
+            pstmt.close();
+        }
+
+        if (null != rs) {
+            rs.close();
+        }
+
+        if (null != con) {
+            con.close();
+        }
+    }
+}
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/TVPWithSqlVariantTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/TVPWithSqlVariantTest.java
index 2e1fe11f6..d51d7455f 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/TVPWithSqlVariantTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/datatypes/TVPWithSqlVariantTest.java
@@ -15,6 +15,7 @@
 import java.sql.Date;
 import java.sql.DriverManager;
 import java.sql.SQLException;
+import java.sql.SQLTimeoutException;
 import java.util.Random;
 
 import org.junit.jupiter.api.AfterAll;
@@ -27,7 +28,6 @@
 import com.microsoft.sqlserver.jdbc.SQLServerCallableStatement;
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
 import com.microsoft.sqlserver.jdbc.SQLServerDataTable;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
 import com.microsoft.sqlserver.jdbc.SQLServerResultSet;
 import com.microsoft.sqlserver.jdbc.SQLServerStatement;
@@ -51,10 +51,11 @@ public class TVPWithSqlVariantTest extends AbstractTest {
     /**
      * Test a previous failure regarding to numeric precision. Issue #211
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testInt() throws SQLServerException {
+    public void testInt() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         tvp.addRow(12);
@@ -76,10 +77,11 @@ public void testInt() throws SQLServerException {
     /**
      * Test with date value
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testDate() throws SQLServerException {
+    public void testDate() throws SQLException {
         SqlDate sqlDate = new SqlDate();
         Date date = (Date) sqlDate.createdata();
         tvp = new SQLServerDataTable();
@@ -100,10 +102,11 @@ public void testDate() throws SQLServerException {
     /**
      * Test with money value
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testMoney() throws SQLServerException {
+    public void testMoney() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         String[] numeric = createNumericValues();
@@ -123,10 +126,11 @@ public void testMoney() throws SQLServerException {
     /**
      * Test with small int value
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testSmallInt() throws SQLServerException {
+    public void testSmallInt() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         String[] numeric = createNumericValues();
@@ -148,10 +152,11 @@ public void testSmallInt() throws SQLServerException {
     /**
      * Test with bigint value
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testBigInt() throws SQLServerException {
+    public void testBigInt() throws SQLException {
         Random r = new Random();
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
@@ -173,10 +178,11 @@ public void testBigInt() throws SQLServerException {
     /**
      * Test with boolean value
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testBoolean() throws SQLServerException {
+    public void testBoolean() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         String[] numeric = createNumericValues();
@@ -196,10 +202,11 @@ public void testBoolean() throws SQLServerException {
     /**
      * Test with float value
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testFloat() throws SQLServerException {
+    public void testFloat() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         String[] numeric = createNumericValues();
@@ -219,10 +226,11 @@ public void testFloat() throws SQLServerException {
     /**
      * Test with nvarchar
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testNvarChar() throws SQLServerException {
+    public void testNvarChar() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         String colValue = "س";
@@ -242,10 +250,11 @@ public void testNvarChar() throws SQLServerException {
     /**
      * Test with varchar8000
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testVarChar8000() throws SQLServerException {
+    public void testVarChar8000() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         StringBuffer buffer = new StringBuffer();
@@ -270,10 +279,10 @@ public void testVarChar8000() throws SQLServerException {
     /**
      * Check that we throw proper error message when inserting more than 8000
      * 
-     * @throws SQLServerException
+     * @throws SQLException
      */
     @Test
-    public void testLongVarChar() throws SQLServerException {
+    public void testLongVarChar() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
 
@@ -289,7 +298,7 @@ public void testLongVarChar() throws SQLServerException {
         try {
             pstmt.execute();
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             assertTrue(e.getMessage().contains("SQL_VARIANT does not support string values of length greater than 8000."));
         }
         catch (Exception e) {
@@ -305,10 +314,11 @@ public void testLongVarChar() throws SQLServerException {
     /**
      * Test ith datetime
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testDateTime() throws SQLServerException {
+    public void testDateTime() throws SQLException {
         java.sql.Timestamp timestamp = java.sql.Timestamp.valueOf("2007-09-23 10:10:10.0");
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
@@ -330,10 +340,11 @@ public void testDateTime() throws SQLServerException {
     /**
      * Test with null value
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test // TODO We need to check this later. Right now sending null with TVP is not supported
-    public void testNull() throws SQLServerException {
+    public void testNull() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         try {
@@ -358,10 +369,11 @@ public void testNull() throws SQLServerException {
     /**
      * Test with stored procedure
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testIntStoredProcedure() throws SQLServerException {
+    public void testIntStoredProcedure() throws SQLException {
         java.sql.Timestamp timestamp = java.sql.Timestamp.valueOf("2007-09-23 10:10:10.0");
         final String sql = "{call " + procedureName + "(?)}";
         tvp = new SQLServerDataTable();
@@ -382,16 +394,16 @@ public void testIntStoredProcedure() throws SQLServerException {
     /**
      * Test for allowing duplicate columns
      * 
-     * @throws SQLServerException
+     * @throws SQLException
      */
     @Test
-    public void testDuplicateColumn() throws SQLServerException {
+    public void testDuplicateColumn() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", microsoft.sql.Types.SQL_VARIANT);
         tvp.addColumnMetadata("c2", microsoft.sql.Types.SQL_VARIANT);
         try {
             tvp.addColumnMetadata("c2", microsoft.sql.Types.SQL_VARIANT);
-        } catch (SQLServerException e) {
+        } catch (SQLException e) {
             assertEquals(e.getMessage(), "A column name c2 already belongs to this SQLServerDataTable.");
         }
     }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/exception/ExceptionTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/exception/ExceptionTest.java
index 7ba6cbc36..37dd3e6b6 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/exception/ExceptionTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/exception/ExceptionTest.java
@@ -20,7 +20,6 @@
 
 import com.microsoft.sqlserver.jdbc.SQLServerBulkCSVFileRecord;
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.Utils;
 
@@ -29,7 +28,7 @@ public class ExceptionTest extends AbstractTest {
     static String inputFile = "BulkCopyCSVTestInput.csv";
 
     /**
-     * Test the SQLServerException has the proper cause when encoding is not supported.
+     * Test the SQLException has the proper cause when encoding is not supported.
      * 
      * @throws Exception
      */
@@ -41,7 +40,7 @@ public void testBulkCSVFileRecordExceptionCause() throws Exception {
             SQLServerBulkCSVFileRecord scvFileRecord = new SQLServerBulkCSVFileRecord(filePath + inputFile, "invalid_encoding", true);
         }
         catch (Exception e) {
-            if (!(e instanceof SQLServerException)) {
+            if (!(e instanceof SQLException)) {
                 throw e;
             }
 
@@ -54,7 +53,7 @@ public void testBulkCSVFileRecordExceptionCause() throws Exception {
     final int waitForDelaySeconds = 10;
 
     /**
-     * Test the SQLServerException has the proper cause when socket timeout occurs.
+     * Test the SQLException has the proper cause when socket timeout occurs.
      * 
      * @throws Exception
      * 
@@ -75,7 +74,7 @@ public void testSocketTimeoutExceptionCause() throws Exception {
                 throw new Exception("Exception for socketTimeout is not thrown.");
             }
             catch (Exception e) {
-                if (!(e instanceof SQLServerException)) {
+                if (!(e instanceof SQLException)) {
                     throw e;
                 }
 
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/fips/FipsTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/fips/FipsTest.java
index 3a257328a..66b88933f 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/fips/FipsTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/fips/FipsTest.java
@@ -8,6 +8,7 @@
 package com.microsoft.sqlserver.jdbc.fips;
 
 import java.sql.Connection;
+import java.sql.SQLException;
 import java.util.Properties;
 
 import org.junit.jupiter.api.Assertions;
@@ -17,7 +18,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerDataSource;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.StringUtils;
 import com.microsoft.sqlserver.testframework.PrepUtil;
 import com.microsoft.sqlserver.testframework.Utils;
@@ -50,7 +50,7 @@ public void fipsTrustServerCertificateTest() throws Exception {
             Connection con = PrepUtil.getConnection(connectionString, props);
             Assertions.fail("It should fail as we are not passing appropriate params");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             Assertions.assertTrue(
                     e.getMessage().contains("Unable to verify FIPS mode settings."),
                     "Should create exception for invalid TrustServerCertificate value");
@@ -70,7 +70,7 @@ public void fipsEncryptTest() throws Exception {
             Connection con = PrepUtil.getConnection(connectionString, props);
             Assertions.fail("It should fail as we are not passing appropriate params");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             Assertions.assertTrue(
                     e.getMessage().contains("Unable to verify FIPS mode settings."),
                     "Should create exception for invalid encrypt value");
@@ -125,7 +125,7 @@ public void fipsDatSourceEncrypt() {
 
             Assertions.fail("It should fail as we are not passing appropriate params");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             Assertions.assertTrue(
                     e.getMessage().contains("Unable to verify FIPS mode settings."),
                     "Should create exception for invalid encrypt value");
@@ -146,7 +146,7 @@ public void fipsDataSourceTrustServerCertificateTest() throws Exception {
             Connection con = ds.getConnection();
             Assertions.fail("It should fail as we are not passing appropriate params");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             Assertions.assertTrue(
                     e.getMessage().contains("Unable to verify FIPS mode settings."),
                     "Should create exception for invalid TrustServerCertificate value");
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/parametermetadata/ParameterMetaDataTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/parametermetadata/ParameterMetaDataTest.java
index 6419d2199..7a59ba809 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/parametermetadata/ParameterMetaDataTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/parametermetadata/ParameterMetaDataTest.java
@@ -21,7 +21,6 @@
 import org.junit.platform.runner.JUnitPlatform;
 import org.junit.runner.RunWith;
 
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.Utils;
 import com.microsoft.sqlserver.testframework.util.RandomUtil;
@@ -56,7 +55,7 @@ public void testParameterMetaDataWrapper() throws SQLException {
     }
 
     /**
-     * Test SQLServerException is not wrapped with another SQLServerException.
+     * Test SQLException is not wrapped with another SQLException.
      * 
      * @throws SQLException
      */
@@ -67,9 +66,9 @@ public void testSQLServerExceptionNotWrapped() throws SQLException {
 
             pstmt.getParameterMetaData();
         }
-        catch (SQLServerException e) {
-            assertTrue(!e.getMessage().contains("com.microsoft.sqlserver.jdbc.SQLServerException"),
-                    "SQLServerException should not be wrapped by another SQLServerException.");
+        catch (SQLException e) {
+            assertTrue(!e.getMessage().contains("com.microsoft.sqlserver.jdbc.SQLException"),
+                    "SQLException should not be wrapped by another SQLException.");
         }
     }
     
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/ssl/trustmanager/CustomTrustManagerTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/ssl/trustmanager/CustomTrustManagerTest.java
index 6874ca363..67aa770f7 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/ssl/trustmanager/CustomTrustManagerTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/ssl/trustmanager/CustomTrustManagerTest.java
@@ -1,6 +1,7 @@
 package com.microsoft.sqlserver.jdbc.ssl.trustmanager;
 
 import java.sql.DriverManager;
+import java.sql.SQLException;
 
 import static org.junit.Assert.*;
 import org.junit.jupiter.api.Test;
@@ -8,7 +9,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 
 @RunWith(JUnitPlatform.class)
@@ -52,7 +52,7 @@ public void testWithInvalidTrustManager() throws Exception {
         try (SQLServerConnection con = (SQLServerConnection) DriverManager.getConnection(url)) {
             fail();
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             assertTrue(e.getMessage().contains("The class specified by the trustManagerClass property must implement javax.net.ssl.TrustManager"));
         }
     }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPIssuesTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPIssuesTest.java
index 26087ff36..41118d594 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPIssuesTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPIssuesTest.java
@@ -24,7 +24,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerCallableStatement;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
 import com.microsoft.sqlserver.jdbc.SQLServerStatement;
 import com.microsoft.sqlserver.testframework.AbstractTest;
@@ -82,7 +81,7 @@ public void testExceptionWithInvalidStoredProcedureName() throws Exception {
             throw new Exception("Expected Exception for invalied stored procedure name is not thrown.");
         }
         catch (Exception e) {
-            if (e instanceof SQLServerException) {
+            if (e instanceof SQLException) {
                 assertTrue(e.getMessage().contains("Could not find stored procedure"), "Invalid Error Message.");
             }
             else {
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPNumericTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPNumericTest.java
index 11225805a..e96496e84 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPNumericTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPNumericTest.java
@@ -8,6 +8,7 @@
 package com.microsoft.sqlserver.jdbc.tvp;
 
 import java.sql.SQLException;
+import java.sql.SQLTimeoutException;
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -16,7 +17,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerDataTable;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.DBConnection;
@@ -40,10 +40,11 @@ public class TVPNumericTest extends AbstractTest {
     /**
      * Test a previous failure regarding to numeric precision. Issue #211
      * 
-     * @throws SQLServerException
+     * @throws SQLException
+     * @throws SQLTimeoutException 
      */
     @Test
-    public void testNumericPresicionIssue211() throws SQLServerException {
+    public void testNumericPresicionIssue211() throws SQLException {
         tvp = new SQLServerDataTable();
         tvp.addColumnMetadata("c1", java.sql.Types.NUMERIC);
 
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPResultSetCursorTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPResultSetCursorTest.java
index 1374dc5c9..8dbd7e368 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPResultSetCursorTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPResultSetCursorTest.java
@@ -26,7 +26,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerCallableStatement;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.Utils;
@@ -204,7 +203,7 @@ public void testInvalidTVPName() throws SQLException {
         try {
             pstmt.execute();
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             if (!e.getMessage().contains("Cannot find data type")) {
                 throw e;
             }
@@ -251,7 +250,7 @@ public void testInvalidStoredProcedureName() throws SQLException {
         try {
             pstmt.execute();
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             if (!e.getMessage().contains("Could not find stored procedure")) {
                 throw e;
             }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/TestSavepoint.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/TestSavepoint.java
index 8670ca769..34db2491f 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/TestSavepoint.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/TestSavepoint.java
@@ -20,7 +20,6 @@
 import org.junit.platform.runner.JUnitPlatform;
 import org.junit.runner.RunWith;
 
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerSavepoint;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.util.RandomUtil;
@@ -54,7 +53,7 @@ public void testSavePointName() throws SQLException {
             savePoint.getSavepointId();
             assertTrue(false, "Expecting Exception as trying to get SavePointId when we created savepoint with name");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
         }
 
         connection.rollback();
@@ -78,7 +77,7 @@ public void testSavePointId() throws SQLException {
             savePoint.getSavepointName();
             assertTrue(false, "Expecting Exception as trying to get SavePointname when we created savepoint without name");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
         }
 
         assertTrue(savePoint.getSavepointId() != 0, "SavePoint should not be 0");
@@ -118,7 +117,7 @@ public void testSavePointWithAutoCommit() throws SQLException {
             connection.setSavepoint(null);
             assertTrue(false, "Expecting Exception as can not set SetPoint when AutoCommit mode is set to true.");
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
         }
 
     }
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/lobs/lobsTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/lobs/lobsTest.java
index af9499fa9..232eb49b7 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/lobs/lobsTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/lobs/lobsTest.java
@@ -221,6 +221,59 @@ else if (lobClass == Blob.class)
         }
     }
 
+    @Test
+    @DisplayName("testFreedBlobs")
+    private void testFreedBlobs(Class lobClass,
+            boolean isResultSet) throws SQLException {
+        String types[] = {"varbinary(max)"};
+        try {
+        	table = createTable(table, types, false);  // create empty table
+            int size = 10000;
+
+            byte[] data = new byte[size];
+            ThreadLocalRandom.current().nextBytes(data);
+
+            Blob blob = null;
+            InputStream stream = null;
+            for (int i = 0; i < 5; i++)
+            {
+                PreparedStatement ps = conn.prepareStatement("INSERT INTO " + table.getEscapedTableName() + "  VALUES(?)");
+                blob = conn.createBlob();
+                blob.setBytes(1, data);
+                ps.setBlob(1, blob);
+                ps.executeUpdate();
+            }
+
+            byte[] chunk = new byte[size];
+            ResultSet rs = stmt.executeQuery("select * from " + table.getEscapedTableName());
+            for (int i = 0; i < 5; i++)
+            {
+                rs.next();
+                
+                blob = rs.getBlob(1);
+                stream = blob.getBinaryStream();
+                while (stream.available() > 0)
+                	stream.read();
+                blob.free();
+                try {
+                	stream = blob.getBinaryStream();
+                } catch (SQLException e) {
+                    assertTrue(e.getMessage().contains("This Blob object has been freed."));
+                }
+            }
+            rs.close();
+            try {
+            	stream = blob.getBinaryStream();
+            } catch (SQLException e) {
+                assertTrue(e.getMessage().contains("This Blob object has been freed."));
+            }
+        }
+        catch (Exception e) {
+            this.dropTables(table);
+            e.printStackTrace();
+        }
+    }
+
     @Test
     @DisplayName("testMultipleCloseCharacterStream")
     public void testMultipleCloseCharacterStream() throws Exception {
@@ -413,6 +466,92 @@ public void testUpdatorClob() throws Exception {
         String types[] = {"varchar(max)"};
         testUpdateLobs(types, Clob.class);
     }
+    
+    @Test
+    @DisplayName("readBlobStreamAfterClosingRS") 
+    public void readBlobStreamAfterClosingRS() throws Exception {
+        String types[] = {"varbinary(max)"};
+        table = createTable(table, types, false);  // create empty table
+        int size = 10000;
+
+        byte[] data = new byte[size];
+        ThreadLocalRandom.current().nextBytes(data);
+
+        Blob blob = null;
+        InputStream stream = null;
+        PreparedStatement ps = conn.prepareStatement("INSERT INTO " + table.getEscapedTableName() + "  VALUES(?)");
+        blob = conn.createBlob();
+        blob.setBytes(1, data);
+        ps.setBlob(1, blob);
+        ps.executeUpdate();
+
+        byte[] chunk = new byte[size];
+        ResultSet rs = stmt.executeQuery("select * from " + table.getEscapedTableName());
+        rs.next();
+        
+        blob = rs.getBlob(1);
+        stream = blob.getBinaryStream();
+        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        int read = 0;
+        while ((read = stream.read(chunk)) > 0)
+            buffer.write(chunk, 0, read);
+        assertEquals(chunk.length, size);
+        rs.close();
+        stream = blob.getBinaryStream();
+        buffer = new ByteArrayOutputStream();
+        read = 0;
+        while ((read = stream.read(chunk)) > 0)
+            buffer.write(chunk, 0, read);
+        assertEquals(chunk.length, size);
+
+        if (null != blob)
+            blob.free();
+        dropTables(table);
+    }
+    
+    @Test
+    @DisplayName("readMultipleBlobStreamsThenCloseRS")
+    public void readMultipleBlobStreamsThenCloseRS() throws Exception {
+    	String types[] = {"varbinary(max)"};
+    	table = createTable(table, types, false);
+    	int size = 10000;
+    	
+    	byte[] data = new byte[size];
+    	Blob[] blobs = {null, null, null, null, null};
+        InputStream stream = null;
+        for (int i = 0; i < 5; i++)//create 5 blobs
+        {
+            PreparedStatement ps = conn.prepareStatement("INSERT INTO " + table.getEscapedTableName() + "  VALUES(?)");
+            blobs[i] = conn.createBlob();
+            ThreadLocalRandom.current().nextBytes(data);
+            blobs[i].setBytes(1, data);
+            ps.setBlob(1, blobs[i]);
+            ps.executeUpdate();
+        }
+        byte[] chunk = new byte[size];
+        ResultSet rs = stmt.executeQuery("select * from " + table.getEscapedTableName());
+        for (int i = 0; i < 5; i++)
+        {
+        	rs.next();
+        	blobs[i] = rs.getBlob(1);
+        	stream = blobs[i].getBinaryStream();
+        	ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        	int read = 0;
+        	while ((read = stream.read(chunk)) > 0)
+        		buffer.write(chunk, 0, read);
+        	assertEquals(chunk.length, size);
+        }
+        rs.close();
+        for (int i = 0; i < 5; i++)
+        {
+        	stream = blobs[i].getBinaryStream();
+        	ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        	int read = 0;
+        	while ((read = stream.read(chunk)) > 0)
+        		buffer.write(chunk, 0, read);
+        	assertEquals(chunk.length, size);
+        }
+    }
 
     private void testUpdateLobs(String types[],
             Class lobClass) throws Exception {
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecuteWithErrorsTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecuteWithErrorsTest.java
index afe9db6f7..38c16ce95 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecuteWithErrorsTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/BatchExecuteWithErrorsTest.java
@@ -196,7 +196,7 @@ public void Repro47239() throws SQLException {
         }
         conn.rollback();
 
-        // Defect 128801: Rollback (with conversion error) should throw SQLServerException
+        // Defect 128801: Rollback (with conversion error) should throw SQLException
         stmt.addBatch(dateConversionError);
         stmt.addBatch(insertStmt);
         stmt.addBatch(insertStmt);
@@ -401,7 +401,7 @@ public void Repro47239large() throws Exception {
         }
         conn.rollback();
 
-        // Defect 128801: Rollback (with conversion error) should throw SQLServerException
+        // Defect 128801: Rollback (with conversion error) should throw SQLException
         stmt.addBatch(dateConversionError);
         stmt.addBatch(insertStmt);
         stmt.addBatch(insertStmt);
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/PQImpsTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/PQImpsTest.java
index 7d786dc46..e95107671 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/PQImpsTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/PQImpsTest.java
@@ -26,7 +26,6 @@
 import org.junit.runner.RunWith;
 
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerParameterMetaData;
 import com.microsoft.sqlserver.testframework.AbstractSQLGenerator;
 import com.microsoft.sqlserver.testframework.AbstractTest;
@@ -209,7 +208,7 @@ public void MultipleTypesTableTest() throws Exception {
                 testMixedWithHardcodedValues();
             }
         }
-        catch (SQLServerException e) {
+        catch (SQLException e) {
             fail(e.toString());
         }
 
@@ -1339,10 +1338,10 @@ public void testQueryWithSingleLineCommentsDeletion() throws SQLException {
     /**
      * test column name with end comment mark and space
      * 
-     * @throws SQLServerException
+     * @throws SQLException
      */
     @Test
-    public void testQueryWithSpaceAndEndCommentMarkInColumnName() throws SQLServerException {
+    public void testQueryWithSpaceAndEndCommentMarkInColumnName() throws SQLException {
         pstmt = connection.prepareStatement("SELECT [c1*/someString withspace] from " + spaceTable);
 
         try {
@@ -1356,10 +1355,10 @@ public void testQueryWithSpaceAndEndCommentMarkInColumnName() throws SQLServerEx
     /**
      * test getting parameter count with a complex query with multiple table
      * 
-     * @throws SQLServerException
+     * @throws SQLException
      */
     @Test
-    public void testComplexQueryWithMultipleTables() throws SQLServerException {
+    public void testComplexQueryWithMultipleTables() throws SQLException {
         pstmt = connection.prepareStatement(
                 "insert into " + charTable + " (c1) select ? where not exists (select * from " + charTable2 + " where table2c1 = ?)");
 
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/PreparedStatementTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/PreparedStatementTest.java
index 58c7969ab..e4e0d09f0 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/PreparedStatementTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/PreparedStatementTest.java
@@ -32,7 +32,6 @@
 
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
 import com.microsoft.sqlserver.jdbc.SQLServerDataSource;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 
@@ -188,7 +187,7 @@ public void testStatementPooling() throws SQLException {
                     try {
                         assertSame(1, pstmt.executeUpdate());
                     }
-                    catch (SQLServerException e) {
+                    catch (SQLException e) {
                         // Error "Prepared handle GAH" is expected to happen. But it should not terminate the execution with RAISERROR.
                         // Since the original "Could not find prepared statement with handle" error does not terminate the execution after it.
                         if (!e.getMessage().contains("Prepared handle GAH")) {
diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/WrapperTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/WrapperTest.java
index 47f92cbf7..754ceca1d 100644
--- a/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/WrapperTest.java
+++ b/src/test/java/com/microsoft/sqlserver/jdbc/unit/statement/WrapperTest.java
@@ -13,6 +13,7 @@
 import java.sql.CallableStatement;
 import java.sql.Connection;
 import java.sql.DriverManager;
+import java.sql.SQLException;
 import java.sql.Statement;
 
 import org.junit.jupiter.api.Test;
@@ -21,7 +22,6 @@
 
 import com.microsoft.sqlserver.jdbc.ISQLServerPreparedStatement;
 import com.microsoft.sqlserver.jdbc.SQLServerCallableStatement;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerStatement;
 import com.microsoft.sqlserver.testframework.AbstractTest;
 import com.microsoft.sqlserver.testframework.DBConnection;
@@ -124,7 +124,7 @@ public void unWrapFailureTest() throws Exception {
             stmt.unwrap(Class.forName(str));
             assertTrue(false, "An exception should have been thrown. This code should not be reached");
         }
-        catch (SQLServerException ex) {
+        catch (SQLException ex) {
             Throwable t = ex.getCause();
             Class exceptionClass = Class.forName("java.lang.ClassCastException");
             assertEquals(t.getClass(), exceptionClass, "The cause in the exception class does not match");
diff --git a/src/test/java/com/microsoft/sqlserver/testframework/DBConnection.java b/src/test/java/com/microsoft/sqlserver/testframework/DBConnection.java
index a6ae11d07..65ea02934 100644
--- a/src/test/java/com/microsoft/sqlserver/testframework/DBConnection.java
+++ b/src/test/java/com/microsoft/sqlserver/testframework/DBConnection.java
@@ -16,7 +16,6 @@
 import java.sql.SQLException;
 
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 
 /*
  * Wrapper class for SQLServerConnection
@@ -97,9 +96,9 @@ public DBStatement createStatement(int type,
      * 
      * @param rsType
      * @return
-     * @throws SQLServerException
+     * @throws SQLException
      */
-    public DBStatement createStatement(DBResultSetTypes rsType) throws SQLServerException {
+    public DBStatement createStatement(DBResultSetTypes rsType) throws SQLException {
         DBStatement dbstatement = new DBStatement(this);
         return dbstatement.createStatement(rsType.resultsetCursor, rsType.resultSetConcurrency);
     }
diff --git a/src/test/java/com/microsoft/sqlserver/testframework/DBStatement.java b/src/test/java/com/microsoft/sqlserver/testframework/DBStatement.java
index 00b006026..d047ac873 100644
--- a/src/test/java/com/microsoft/sqlserver/testframework/DBStatement.java
+++ b/src/test/java/com/microsoft/sqlserver/testframework/DBStatement.java
@@ -13,7 +13,6 @@
 import java.sql.Statement;
 
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 
 /**
  * wrapper method for Statement object
@@ -45,7 +44,7 @@ DBStatement statement() {
         return this;
     }
 
-    DBStatement createStatement() throws SQLServerException {
+    DBStatement createStatement() throws SQLException {
         // TODO: add cursor and holdability
         statement = ((SQLServerConnection) parent().product()).createStatement();
         setInternal(statement);
@@ -53,7 +52,7 @@ DBStatement createStatement() throws SQLServerException {
     }
 
     DBStatement createStatement(int type,
-            int concurrency) throws SQLServerException {
+            int concurrency) throws SQLException {
         // TODO: add cursor and holdability
         statement = ((SQLServerConnection) parent().product()).createStatement(type, concurrency);
         setInternal(statement);
diff --git a/src/test/java/com/microsoft/sqlserver/testframework/util/ComparisonUtil.java b/src/test/java/com/microsoft/sqlserver/testframework/util/ComparisonUtil.java
index c942f8c9a..b297a3924 100644
--- a/src/test/java/com/microsoft/sqlserver/testframework/util/ComparisonUtil.java
+++ b/src/test/java/com/microsoft/sqlserver/testframework/util/ComparisonUtil.java
@@ -92,16 +92,16 @@ public static void compareExpectedAndActual(int dataType,
         else
             switch (dataType) {
                 case java.sql.Types.BIGINT:
-                    assertTrue((((Long) expectedValue).longValue() == ((Long) actualValue).longValue()), "Unexpected bigint value");
+                    assertTrue((((Long) expectedValue).longValue() == ((Long) actualValue).longValue()), "Unexpected bigint value. Expected:" + ((Long) expectedValue).longValue() + " Actual:" + ((Long) actualValue).longValue());
                     break;
 
                 case java.sql.Types.INTEGER:
-                    assertTrue((((Integer) expectedValue).intValue() == ((Integer) actualValue).intValue()), "Unexpected int value");
+                    assertTrue((((Integer) expectedValue).intValue() == ((Integer) actualValue).intValue()), "Unexpected int value. Expected:" + ((Integer) expectedValue).intValue() + " Actual:" + ((Integer) actualValue).intValue());
                     break;
 
                 case java.sql.Types.SMALLINT:
                 case java.sql.Types.TINYINT:
-                    assertTrue((((Short) expectedValue).shortValue() == ((Short) actualValue).shortValue()), "Unexpected smallint/tinyint value");
+                    assertTrue((((Short) expectedValue).shortValue() == ((Short) actualValue).shortValue()), "Unexpected smallint/tinyint value. Expected:" + ((Short) expectedValue).shortValue() + " Actual:" + ((Short) actualValue).shortValue());
                     break;
 
                 case java.sql.Types.BIT:
@@ -115,11 +115,11 @@ public static void compareExpectedAndActual(int dataType,
                     break;
 
                 case java.sql.Types.DOUBLE:
-                    assertTrue((((Double) expectedValue).doubleValue() == ((Double) actualValue).doubleValue()), "Unexpected float value");
+                    assertTrue((((Double) expectedValue).doubleValue() == ((Double) actualValue).doubleValue()), "Unexpected double value. Expected:" + ((Double) expectedValue).doubleValue() + " Actual:" + ((Double) actualValue).doubleValue());
                     break;
 
                 case java.sql.Types.REAL:
-                    assertTrue((((Float) expectedValue).floatValue() == ((Float) actualValue).floatValue()), "Unexpected real value");
+                    assertTrue((((Float) expectedValue).floatValue() == ((Float) actualValue).floatValue()), "Unexpected real/float value. Expected:" + ((Float) expectedValue).floatValue() + " Actual:" + ((Float) actualValue).floatValue());
                     break;
 
                 case java.sql.Types.VARCHAR:
diff --git a/src/test/java/com/microsoft/sqlserver/testframework/util/Util.java b/src/test/java/com/microsoft/sqlserver/testframework/util/Util.java
index 336c2d304..fc0df86b9 100644
--- a/src/test/java/com/microsoft/sqlserver/testframework/util/Util.java
+++ b/src/test/java/com/microsoft/sqlserver/testframework/util/Util.java
@@ -11,7 +11,6 @@
 
 import com.microsoft.sqlserver.jdbc.SQLServerConnection;
 import com.microsoft.sqlserver.jdbc.SQLServerDatabaseMetaData;
-import com.microsoft.sqlserver.jdbc.SQLServerException;
 import com.microsoft.sqlserver.jdbc.SQLServerStatementColumnEncryptionSetting;
 
 /**
@@ -329,9 +328,9 @@ public static String bytesToHexString(byte[] b,
      * @param value
      *            charArray
      * @return
-     * @throws SQLServerException
+     * @throws SQLException
      */
-    static byte CharToHex(char value) throws SQLServerException {
+    static byte CharToHex(char value) throws SQLException {
         byte ret = 0;
         if (value >= 'A' && value <= 'F') {
             ret = (byte) (value - 'A' + 10);
@@ -354,9 +353,9 @@ else if (value >= '0' && value <= '9') {
      * @param hexV
      *            a hexized string representation of bytes
      * @return
-     * @throws SQLServerException
+     * @throws SQLException
      */
-    public static byte[] hexStringToByte(String hexV) throws SQLServerException {
+    public static byte[] hexStringToByte(String hexV) throws SQLException {
         int len = hexV.length();
         char orig[] = hexV.toCharArray();
         if ((len % 2) != 0) {