diff --git a/lexical_cast_test.cpp b/lexical_cast_test.cpp
index 1dd5a63..1eecc57 100644
--- a/lexical_cast_test.cpp
+++ b/lexical_cast_test.cpp
@@ -2,11 +2,13 @@
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
-//  Copyright Terje Slettebų and Kevlin Henney, 2003.
+//  Copyright Terje Slettebų and Kevlin Henney, 2005.
 //
 //  Distributed under the Boost
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+//
+// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
 
 #include <boost/config.hpp>
 
@@ -40,6 +42,8 @@ void test_conversion_from_wchar_t();
 void test_conversion_to_wchar_t();
 void test_conversion_from_wstring();
 void test_conversion_to_wstring();
+void test_bad_lexical_cast();
+void test_no_whitespace_stripping();
 
 unit_test_framework::test_suite *init_unit_test_suite(int, char **)
 {
@@ -58,6 +62,8 @@ unit_test_framework::test_suite *init_unit_test_suite(int, char **)
     suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
     suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
     #endif
+    suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
+    suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
     return suite;
 }
 
@@ -67,99 +73,96 @@ void test_conversion_to_char()
     BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
     BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
     BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
-    BOOST_CHECK_THROW(lexical_cast<char>(123), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
     BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
     BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
     BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
     BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
     BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
-    BOOST_CHECK_THROW(lexical_cast<char>(""), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<char>("Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
     BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
     BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
     BOOST_CHECK_THROW(
-        lexical_cast<char>(std::string("")), boost::bad_lexical_cast);
+        lexical_cast<char>(std::string("")), bad_lexical_cast);
     BOOST_CHECK_THROW(
-        lexical_cast<char>(std::string("Test")), boost::bad_lexical_cast);
+        lexical_cast<char>(std::string("Test")), bad_lexical_cast);
 }
 
 void test_conversion_to_int()
 {
-    BOOST_CHECK_EQUAL(1,lexical_cast<int>('1'));
-    BOOST_CHECK_EQUAL(0,lexical_cast<int>('0'));
-    BOOST_CHECK_THROW(lexical_cast<int>('A'),boost::bad_lexical_cast);
-    BOOST_CHECK_EQUAL(1,lexical_cast<int>(1));
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
+    BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
+    BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
     BOOST_CHECK_EQUAL(
         (std::numeric_limits<int>::max)(),
         lexical_cast<int>((std::numeric_limits<int>::max)()));
-    BOOST_CHECK_EQUAL(1,lexical_cast<int>(1.0));
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
 
-    BOOST_CHECK_THROW(lexical_cast<int>(1.23), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
 
-    BOOST_CHECK_THROW(lexical_cast<int>(1e20), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
     BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
     BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
     BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
     BOOST_CHECK_THROW(
-        lexical_cast<int>(" 123"), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>(""), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>("Test"), boost::bad_lexical_cast);
+        lexical_cast<int>(" 123"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
     BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
-    BOOST_CHECK_EQUAL(123,lexical_cast<int>(std::string("123")));
+    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
     BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string(" 123")), boost::bad_lexical_cast);
+        lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
     BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string("")), boost::bad_lexical_cast);
+        lexical_cast<int>(std::string("")), bad_lexical_cast);
     BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string("Test")), boost::bad_lexical_cast);
+        lexical_cast<int>(std::string("Test")), bad_lexical_cast);
 }
 
 void test_conversion_to_double()
 {
-    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>('1'));
-    BOOST_CHECK_THROW(lexical_cast<double>('A'), boost::bad_lexical_cast);
-    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(1));
-    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(1.23));
-    BOOST_CHECK_CLOSE(
-        (std::numeric_limits<double>::max)() / 2,
-        lexical_cast<double>((std::numeric_limits<double>::max)() / 2),
-        std::numeric_limits<double>::epsilon());
-    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(true));
-    BOOST_CHECK_EQUAL(0.0, lexical_cast<double>(false));
-    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>("1.23"));
-    BOOST_CHECK_THROW(lexical_cast<double>(""), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>("Test"), boost::bad_lexical_cast);
-    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(std::string("1.23")));
+    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_THROW(lexical_cast<double>('A'), bad_lexical_cast);
+    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_CLOSE(1.234567890, 1.234567890, std::numeric_limits<double>::epsilon());
+    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_CLOSE(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_THROW(lexical_cast<double>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>("Test"), bad_lexical_cast);
+    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
     BOOST_CHECK_THROW(
-        lexical_cast<double>(std::string("")), boost::bad_lexical_cast);
+        lexical_cast<double>(std::string("")), bad_lexical_cast);
     BOOST_CHECK_THROW(
-        lexical_cast<double>(std::string("Test")), boost::bad_lexical_cast);
+        lexical_cast<double>(std::string("Test")), bad_lexical_cast);
 }
 
 void test_conversion_to_bool()
 {
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
-    BOOST_CHECK_THROW(lexical_cast<bool>('A'), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
-    BOOST_CHECK_THROW(lexical_cast<bool>(123), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(123), bad_lexical_cast);
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
-    BOOST_CHECK_THROW(lexical_cast<bool>(""), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
     BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::string("")), boost::bad_lexical_cast);
+        lexical_cast<bool>(std::string("")), bad_lexical_cast);
     BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::string("Test")), boost::bad_lexical_cast);
+        lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
 }
 
 void test_conversion_to_string()
@@ -169,8 +172,8 @@ void test_conversion_to_string()
     BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
     BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
     BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
-    BOOST_CHECK_EQUAL("1",lexical_cast<std::string>(true));
-    BOOST_CHECK_EQUAL("0",lexical_cast<std::string>(false));
+    BOOST_CHECK_EQUAL("1", lexical_cast<std::string>(true));
+    BOOST_CHECK_EQUAL("0", lexical_cast<std::string>(false));
     BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
     BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
     BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
@@ -192,9 +195,9 @@ void test_conversion_from_to_wchar_t_alias()
 
 void test_conversion_to_pointer()
 {
-    BOOST_CHECK_THROW(lexical_cast<char *>("Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char *>("Test"), bad_lexical_cast);
     #ifndef DISABLE_WIDE_CHAR_SUPPORT
-    BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), bad_lexical_cast);
     #endif
 }
 
@@ -202,26 +205,26 @@ void test_conversion_from_wchar_t()
 {
     #ifndef DISABLE_WIDE_CHAR_SUPPORT
     BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
-    BOOST_CHECK_THROW(lexical_cast<int>(L'A'), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(L'A'), bad_lexical_cast);
 
     BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
-    BOOST_CHECK_THROW(lexical_cast<int>(L""), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(L""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), bad_lexical_cast);
 
     BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
-    BOOST_CHECK_THROW(lexical_cast<double>(L'A'), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>(L'A'), bad_lexical_cast);
 
     BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
-    BOOST_CHECK_THROW(lexical_cast<double>(L""), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>(L""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), bad_lexical_cast);
 
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
-    BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), bad_lexical_cast);
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
-    BOOST_CHECK_THROW(lexical_cast<bool>(L""), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(L""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), bad_lexical_cast);
     #endif
 }
 
@@ -230,7 +233,7 @@ void test_conversion_to_wchar_t()
     #ifndef DISABLE_WIDE_CHAR_SUPPORT
     BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
     BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
     BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
     BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
     BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
@@ -239,14 +242,14 @@ void test_conversion_to_wchar_t()
     BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
     BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
     BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), boost::bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
     BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
     BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
     BOOST_CHECK_THROW(
-        lexical_cast<wchar_t>(std::wstring(L"")), boost::bad_lexical_cast);
+        lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
     BOOST_CHECK_THROW(
-        lexical_cast<wchar_t>(std::wstring(L"Test")), boost::bad_lexical_cast);
+        lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
     #endif
 }
 
@@ -255,16 +258,16 @@ void test_conversion_from_wstring()
     #ifndef DISABLE_WIDE_CHAR_SUPPORT
     BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
     BOOST_CHECK_THROW(
-        lexical_cast<int>(std::wstring(L"")), boost::bad_lexical_cast);
+        lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
     BOOST_CHECK_THROW(
-        lexical_cast<int>(std::wstring(L"Test")), boost::bad_lexical_cast);
+        lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
 
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
     BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::wstring(L"")), boost::bad_lexical_cast);
+        lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
     BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::wstring(L"Test")), boost::bad_lexical_cast);
+        lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
     #endif
 }
 
@@ -286,3 +289,24 @@ void test_conversion_to_wstring()
     BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
     #endif
 }
+
+void test_bad_lexical_cast()
+{
+    try
+    {
+        lexical_cast<int>(std::string("Test"));
+
+        BOOST_CHECK(false); // Exception expected
+    }
+    catch(const bad_lexical_cast &e)
+    {
+        BOOST_CHECK(e.source_type() == typeid(std::string));
+        BOOST_CHECK(e.target_type() == typeid(int));
+    }
+}
+
+void test_no_whitespace_stripping()
+{
+    BOOST_CHECK_THROW(lexical_cast<int>(" 123"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>("123 "), bad_lexical_cast);
+}