From a63984969e3e100a5d6d5b2308be2f896698f75d Mon Sep 17 00:00:00 2001
From: Thomas Fussell <thomas.fussell@gmail.com>
Date: Fri, 16 Oct 2015 18:35:11 -0400
Subject: [PATCH] improve date handling and printing

---
 include/xlnt/cell/cell.hpp            |  16 +-
 include/xlnt/reader/reader.hpp        |   4 +-
 include/xlnt/styles/number_format.hpp |  40 ++-
 include/xlnt/writer/style_writer.hpp  |   3 +-
 samples/sample1.xlsx                  | Bin 492148 -> 491964 bytes
 source/cell.cpp                       | 424 ++++++++++++++++++++++++--
 source/detail/cell_impl.hpp           |   3 +-
 source/number_format.cpp              |  17 +-
 source/reader.cpp                     |  52 ++--
 source/style_writer.cpp               |  20 ++
 source/workbook.cpp                   |  10 +-
 source/workbook_writer.cpp            |   2 +-
 tests/test_cell.hpp                   |   7 +-
 tests/test_read.hpp                   |   2 +-
 tests/test_style.hpp                  | 319 -------------------
 tests/test_style_writer.hpp           | 284 +++++++++++++++++
 tests/test_worksheet.hpp              |   7 -
 17 files changed, 813 insertions(+), 397 deletions(-)
 delete mode 100644 tests/test_style.hpp
 create mode 100644 tests/test_style_writer.hpp

diff --git a/include/xlnt/cell/cell.hpp b/include/xlnt/cell/cell.hpp
index 30f5f63e..82ddf70d 100644
--- a/include/xlnt/cell/cell.hpp
+++ b/include/xlnt/cell/cell.hpp
@@ -115,7 +115,7 @@ public:
     // style shortcuts
     std::string get_number_format();
     std::string get_number_format() const;
-    void set_number_format(const std::string &format_code);
+    void set_number_format(const std::string &format_code, int index = -1);
     font &get_font();
     const font &get_font() const;
     fill &get_fill();
@@ -144,6 +144,16 @@ public:
     bool has_formula() const;
 
     // printing
+    
+    /// <summary>
+    /// Returns a string describing this cell like <Cell Sheet.A1>.
+    /// </summary>
+    std::string to_repr() const;
+    
+    /// <summary>
+    /// Returns a string representing the value of this cell. If the data type is not a string,
+    /// it will be converted according to the number format.
+    /// </summary>
     std::string to_string() const;
     
     // merging
@@ -161,8 +171,6 @@ public:
     // operators
     cell &operator=(const cell &rhs);
     
-    std::ostream &print(std::ostream &stream, bool convert) const;
-    
     bool operator==(const cell &comparand) const;
     bool operator==(std::nullptr_t) const;
 
@@ -178,7 +186,7 @@ private:
 
 inline std::ostream &operator<<(std::ostream &stream, const xlnt::cell &cell)
 {
-    return cell.print(stream, true);
+    return stream << cell.to_string();
 }
     
 } // namespace xlnt
diff --git a/include/xlnt/reader/reader.hpp b/include/xlnt/reader/reader.hpp
index a94d527c..001dd855 100644
--- a/include/xlnt/reader/reader.hpp
+++ b/include/xlnt/reader/reader.hpp
@@ -46,8 +46,8 @@ public:
     static std::vector<relationship> read_relationships(zip_file &content, const std::string &filename);
     static std::vector<std::pair<std::string, std::string>> read_content_types(zip_file &archive);
     static std::string determine_document_type(const std::vector<std::pair<std::string, std::string>> &override_types);
-    static worksheet read_worksheet(std::istream &handle, workbook &wb, const std::string &title, const std::vector<std::string> &string_table);
-    static void read_worksheet(worksheet ws, const std::string &xml_string, const std::vector<std::string> &string_table, const std::vector<int> &number_format_ids);
+    static worksheet read_worksheet(std::istream &handle, workbook &wb, const std::string &title, const std::vector<std::string> &string_table, const std::unordered_map<int, std::string> &custom_number_formats);
+    static void read_worksheet(worksheet ws, const std::string &xml_string, const std::vector<std::string> &string_table, const std::vector<int> &number_format_ids, const std::unordered_map<int, std::string> &custom_number_formats);
     static std::vector<std::string> read_shared_string(const std::string &xml_string);
     static std::string read_dimension(const std::string &xml_string);
     static document_properties read_properties_core(const std::string &xml_string);
diff --git a/include/xlnt/styles/number_format.hpp b/include/xlnt/styles/number_format.hpp
index 08579886..dde0e70c 100644
--- a/include/xlnt/styles/number_format.hpp
+++ b/include/xlnt/styles/number_format.hpp
@@ -90,11 +90,45 @@ public:
     static bool is_builtin(const std::string &format);
     
     number_format() : format_code_(format::general), format_index_(0) {}
-    number_format(format code) : format_code_(code) {}
+    number_format(format code) : format_code_(code), format_index_(reversed_builtin_formats().at(format_strings().at(code))) {}
     
     format get_format_code() const { return format_code_; }
-    void set_format_code(format format_code) { format_code_ = format_code; }
-    void set_format_code_string(const std::string &format_code) { custom_format_code_ = format_code; format_code_ = format::unknown; }
+    
+    void set_format_code(format format_code, int index = -1)
+    {
+        format_code_ = format_code;
+        
+        if(format_code_ != format::unknown)
+        {
+            set_format_code_string(format_strings().at(format_code), index);
+        }
+    }
+    
+    void set_format_code_string(const std::string &format_code, int index)
+    {
+        custom_format_code_ = format_code;
+        format_index_ = index;
+        
+        const auto &reversed = reversed_builtin_formats();
+        auto match = reversed.find(format_code);
+        
+        format_code_ = format::unknown;
+        
+        if(match != reversed.end())
+        {
+            format_index_ = match->second;
+            
+            for(const auto &p : format_strings())
+            {
+                if(p.second == format_code)
+                {
+                    format_code_ = p.first;
+                    break;
+                }
+            }
+        }
+        
+    }
     std::string get_format_code_string() const;
 
 private:
diff --git a/include/xlnt/writer/style_writer.hpp b/include/xlnt/writer/style_writer.hpp
index 716093ff..abd551b4 100644
--- a/include/xlnt/writer/style_writer.hpp
+++ b/include/xlnt/writer/style_writer.hpp
@@ -43,6 +43,8 @@ public:
     std::string write_table() const;
     std::vector<style> get_styles() const;
     
+    std::string write_number_formats();
+    
 private:
     std::vector<style> get_style_list(const workbook &wb) const;
     std::unordered_map<int, std::string> write_fonts() const;
@@ -53,7 +55,6 @@ private:
     void write_cell_style();
     void write_dxfs();
     void write_table_styles();
-    void write_number_formats();
     
     std::vector<style> style_list_;
     workbook &wb_;
diff --git a/samples/sample1.xlsx b/samples/sample1.xlsx
index c495bef40dd30883ffba5ad1872bd5bdd0205cae..2b37bd1450f1b389f719fa247973e72b26279dfd 100644
GIT binary patch
delta 2195
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

delta 2464
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

diff --git a/source/cell.cpp b/source/cell.cpp
index a67f87e4..53b7811b 100644
--- a/source/cell.cpp
+++ b/source/cell.cpp
@@ -16,6 +16,361 @@
 #include "detail/cell_impl.hpp"
 #include "detail/comment_impl.hpp"
 
+namespace {
+
+enum class condition_type
+{
+    less_than,
+    less_or_equal,
+    equal,
+    greater_than,
+    greater_or_equal,
+    invalid
+};
+    
+struct section
+{
+    bool has_value = false;
+    std::string value;
+    bool has_color = false;
+    std::string color;
+    bool has_condition = false;
+    condition_type condition = condition_type::invalid;
+    std::string condition_value;
+    
+    section &operator=(const section &other)
+    {
+        has_value = other.has_value;
+        value = other.value;
+        has_color = other.has_color;
+        color = other.color;
+        has_condition = other.has_condition;
+        condition = other.condition;
+        condition_value = other.condition_value;
+        
+        return *this;
+    }
+};
+    
+struct format_sections
+{
+    section first;
+    section second;
+    section third;
+    section fourth;
+};
+
+// copied from named_range.cpp, keep in sync
+/// <summary>
+/// Return a vector containing string split at each delim.
+/// </summary>
+/// <remark>
+/// This should maybe be in a utility header so it can be used elsewhere.
+/// </remarks>
+std::vector<std::string> split_string(const std::string &string, char delim)
+{
+    std::vector<std::string> split;
+    std::string::size_type previous_index = 0;
+    auto separator_index = string.find(delim);
+    
+    while(separator_index != std::string::npos)
+    {
+        auto part = string.substr(previous_index, separator_index - previous_index);
+        split.push_back(part);
+        
+        previous_index = separator_index + 1;
+        separator_index = string.find(delim, previous_index);
+    }
+    
+    split.push_back(string.substr(previous_index));
+    
+    return split;
+}
+
+bool is_valid_color(const std::string &color)
+{
+    static const std::vector<std::string> colors = { "Black", "Green"
+        "White", "Blue", "Magenta", "Yellow", "Cyan", "Red" };
+    return std::find(colors.begin(), colors.end(), color) != colors.end();
+}
+    
+bool parse_condition(const std::string &string, section &s)
+{
+    s.has_condition = false;
+    s.condition = condition_type::invalid;
+    s.condition_value.clear();
+    
+    if(string[0] == '<')
+    {
+        s.has_condition = true;
+        
+        if(string[1] == '=')
+        {
+            s.condition = condition_type::less_or_equal;
+            s.condition_value = string.substr(2);
+        }
+        else
+        {
+            s.condition = condition_type::less_than;
+            s.condition_value = string.substr(1);
+        }
+    }
+    if(string[0] == '>')
+    {
+        s.has_condition = true;
+        
+        if(string[1] == '=')
+        {
+            s.condition = condition_type::greater_or_equal;
+            s.condition_value = string.substr(2);
+        }
+        else
+        {
+            s.condition = condition_type::greater_than;
+            s.condition_value = string.substr(1);
+        }
+    }
+    else if(string[0] == '=')
+    {
+        s.has_condition = true;
+        s.condition = condition_type::equal;
+        s.condition_value = string.substr(1);
+    }
+    
+    return s.has_condition;
+}
+
+section parse_section(const std::string &section_string)
+{
+    std::string intermediate = section_string;
+    
+    section s;
+    std::string first_bracket_part, second_bracket_part;
+    static const std::vector<std::string> bracket_times = { "h", "hh", "m", "mm", "s", "ss" };
+    
+    if(section_string[0] == '[')
+    {
+        auto close_bracket_pos = section_string.find(']');
+        
+        if(close_bracket_pos == std::string::npos)
+        {
+            throw std::runtime_error("missing close bracket");
+        }
+        
+        first_bracket_part = intermediate.substr(1, close_bracket_pos - 1);
+        
+        if(std::find(bracket_times.begin(), bracket_times.end(), first_bracket_part) !=  bracket_times.end())
+        {
+            first_bracket_part.clear();
+        }
+        else
+        {
+            intermediate = intermediate.substr(close_bracket_pos);
+        }
+    }
+    
+    if(!first_bracket_part.empty() && intermediate[0] == '[')
+    {
+        auto close_bracket_pos = section_string.find(']');
+        
+        if(close_bracket_pos == std::string::npos)
+        {
+            throw std::runtime_error("missing close bracket");
+        }
+        
+        second_bracket_part = intermediate.substr(1, close_bracket_pos - 1);
+        
+        if(std::find(bracket_times.begin(), bracket_times.end(), second_bracket_part) !=  bracket_times.end())
+        {
+            second_bracket_part.clear();
+        }
+        else
+        {
+            intermediate = intermediate.substr(close_bracket_pos);
+        }
+    }
+    
+    if(!first_bracket_part.empty())
+    {
+        if(is_valid_color(first_bracket_part))
+        {
+            s.color = first_bracket_part;
+            s.has_color = true;
+        }
+        else if(!parse_condition(first_bracket_part, s))
+        {
+            throw std::runtime_error("invalid condition");
+        }
+    }
+    
+    if(!second_bracket_part.empty())
+    {
+        if(is_valid_color(second_bracket_part))
+        {
+            if(s.has_color)
+            {
+                throw std::runtime_error("two colors in one section");
+            }
+            
+            s.color = second_bracket_part;
+            s.has_color = true;
+        }
+        else if(s.has_condition)
+        {
+            throw std::runtime_error("two conditions in one section");
+        }
+        else if(!parse_condition(second_bracket_part, s))
+        {
+            throw std::runtime_error("invalid condition");
+        }
+    }
+    
+    s.value = intermediate;
+    s.has_value = true;
+    
+    return s;
+}
+    
+format_sections parse_format_sections(const std::string &combined)
+{
+    format_sections result = {};
+    
+    auto split = split_string(combined, ';');
+    
+    if(split.empty())
+    {
+        throw std::runtime_error("empty string");
+    }
+    
+    result.first = parse_section(split[0]);
+    
+    if(!result.first.has_condition)
+    {
+        result.second = result.first;
+        result.third = result.first;
+    }
+    
+    if(split.size() > 1)
+    {
+        result.second = parse_section(split[1]);
+    }
+    
+    if(split.size() > 2)
+    {
+        if(result.first.has_condition && !result.second.has_condition)
+        {
+            throw std::runtime_error("first two sections should have conditions");
+        }
+        
+        result.third = parse_section(split[2]);
+        
+        if(result.third.has_condition)
+        {
+            throw std::runtime_error("third section shouldn't have a condition");
+        }
+    }
+    
+    if(split.size() > 3)
+    {
+        if(result.first.has_condition)
+        {
+            throw std::runtime_error("too many parts");
+        }
+        
+        result.fourth = parse_section(split[3]);
+    }
+    
+    if(split.size() > 4)
+    {
+        throw std::runtime_error("too many parts");
+    }
+    
+    return result;
+}
+
+std::string format_section(long double number, const section &format)
+{
+    if(number == static_cast<long long int>(number))
+    {
+        return std::to_string(static_cast<long long int>(number));
+    }
+    
+    return std::to_string(number);
+}
+
+std::string format_section(const std::string &text, const section &format)
+{
+    auto arobase_index = format.value.find('@');
+    
+    std::string first_part, middle_part, last_part;
+    
+    if(arobase_index != std::string::npos)
+    {
+        first_part = format.value.substr(0, arobase_index);
+        middle_part = text;
+        last_part = format.value.substr(arobase_index + 1);
+    }
+    else
+    {
+        first_part = format.value;
+    }
+    
+    auto unquote = [](std::string &s)
+    {
+        if(!s.empty())
+        {
+            if(s.front() != '"' || s.back() != '"') return false;
+            s = s.substr(0, s.size() - 2);
+        }
+        
+        return true;
+    };
+    
+    if(!unquote(first_part) || !unquote(last_part))
+    {
+        throw std::runtime_error(std::string("additional text must be enclosed in quotes: ") + format.value);
+    }
+    
+    return first_part + middle_part + last_part;
+}
+
+std::string format_number(long double number, const std::string &format)
+{
+    auto sections = parse_format_sections(format);
+    
+    if(number > 0)
+    {
+        return format_section(number, sections.first);
+    }
+    else if(number < 0)
+    {
+        return format_section(number, sections.second);
+    }
+    
+    // number == 0
+    return format_section(number, sections.third);
+}
+
+std::string format_text(const std::string &text, const std::string &format)
+{
+    if(format == "General") return text;
+    auto sections = parse_format_sections(format);
+    return format_section(text, sections.fourth);
+}
+
+bool is_date_format(const std::string &format_string)
+{
+    auto not_in = format_string.find_first_not_of("/-:, mMyYdDhHsS");
+    return not_in == std::string::npos;
+}
+
+const std::string PercentRegex("^\\-?(?P<number>[0-9]*\\.?[0-9]*\\s?)\%$");
+const std::string TimeRegex("^(([0-1]{0,1}[0-9]{2}):([0-5][0-9]):?([0-5][0-9])?$)|"
+                            "^(([0-5][0-9]):([0-5][0-9])?\\.(\\d{1,6}))");
+const std::string NumberRegex("^-?([\\d]|[\\d]+\\.[\\d]*|\\.[\\d]+|[1-9][\\d]+\\.?[\\d]*)((E|e)[-+]?[\\d]+)?$");
+    
+}
+
 namespace xlnt {
     
 const xlnt::color xlnt::color::black(0);
@@ -259,7 +614,25 @@ bool cell::is_merged() const
 
 bool cell::is_date() const
 {
-    return d_->is_date_ || (d_->style_ != nullptr && get_style().get_number_format().get_format_code() == number_format::format::date_xlsx14);
+    if(get_data_type() == type::numeric && has_style())
+    {
+        auto number_format = get_style().get_number_format().get_format_code_string();
+        
+        if(number_format != "General")
+        {
+            try
+            {
+                auto sections = parse_format_sections(number_format);
+                return is_date_format(sections.first.value);
+            }
+            catch(std::exception)
+            {
+                return false;
+            }
+        }
+    }
+    
+    return false;
 }
 
 cell_reference cell::get_reference() const
@@ -303,7 +676,7 @@ bool operator<(cell left, cell right)
     return left.get_reference() < right.get_reference();
 }
 
-std::string cell::to_string() const
+std::string cell::to_repr() const
 {
     return "<Cell " + worksheet(d_->parent_).get_title() + "." + get_reference().to_string() + ">";
 }
@@ -658,9 +1031,9 @@ timedelta cell::get_value() const
     //return timedelta::from_number(d_->value_numeric_);
 }
 
-void cell::set_number_format(const std::string &format_string)
+void cell::set_number_format(const std::string &format_string, int index)
 {
-    get_style().get_number_format().set_format_code_string(format_string);
+    get_style().get_number_format().set_format_code_string(format_string, index);
 }
 
 template<>
@@ -674,36 +1047,27 @@ bool cell::has_value() const
     return d_->type_ != cell::type::null;
 }
 
-std::ostream &cell::print(std::ostream &stream, bool convert) const
+std::string cell::to_string() const
 {
-    if(!convert)
+    std::string number_format = "General";
+    
+    if(has_style())
     {
-        return stream << get_value<std::string>();
+        number_format = get_style().get_number_format().get_format_code_string();
     }
-    else
+    
+    switch(get_data_type())
     {
-        switch(get_data_type())
-        {
-        case type::null:
-            return stream << "";
-        case type::string:
-            return stream << get_value<std::string>();
-        case type::numeric:
-            if(is_date())
-            {
-                return stream << get_value<datetime>().to_string(get_parent().get_parent().get_properties().excel_base_date);
-            }
-            else
-            {
-                return stream << get_value<long double>();
-            }
-        case type::error:
-            return stream << get_value<std::string>();
-        case type::formula:
-            return stream << d_->formula_;
-        default:
-            return stream;
-        }
+        case cell::type::null:
+            return "";
+        case cell::type::numeric:
+            return format_number(get_value<long double>(), number_format);
+        case cell::type::string:
+        case cell::type::formula:
+        case cell::type::error:
+            return format_text(get_value<std::string>(), number_format);
+        case cell::type::boolean:
+            return get_value<long double>() == 0 ? "FALSE" : "TRUE";
     }
 }
 
diff --git a/source/detail/cell_impl.hpp b/source/detail/cell_impl.hpp
index 0d999af4..b67770fc 100644
--- a/source/detail/cell_impl.hpp
+++ b/source/detail/cell_impl.hpp
@@ -146,8 +146,7 @@ struct cell_impl
     void set_date(long double number, xlnt::number_format::format format_code)
     {
         is_date_ = true;
-        auto number_format = xlnt::number_format(format_code);
-        get_style(true).set_number_format(number_format);
+        get_style(true).get_number_format().set_format_code(format_code);
         value_numeric_ = number;
         type_ = cell::type::numeric;
     }
diff --git a/source/number_format.cpp b/source/number_format.cpp
index cd0d0e41..57ebd83f 100644
--- a/source/number_format.cpp
+++ b/source/number_format.cpp
@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <regex>
 
 #include <xlnt/styles/number_format.hpp>
 
@@ -108,10 +109,16 @@ const std::unordered_map<number_format::format, std::string, number_format::form
 const std::unordered_map<std::string, int> &number_format::reversed_builtin_formats()
 {
     static std::unordered_map<std::string, int> formats;
+    static bool initialised = false;
 
-    for(auto format_pair : builtin_formats())
+    if(!initialised)
     {
-        formats[format_pair.second] = format_pair.first;
+        for(auto format_pair : builtin_formats())
+        {
+            formats[format_pair.second] = format_pair.first;
+        }
+        
+        initialised = true;
     }
     
     return formats;
@@ -137,12 +144,12 @@ number_format::format number_format::lookup_format(int code)
 
 std::string number_format::get_format_code_string() const
 {
-    if(format_code_ == format::unknown)
+    if(builtin_formats().find(format_index_) == builtin_formats().end())
     {
         return custom_format_code_;
     }
-
-    return format_strings().at(format_code_);
+    
+    return builtin_formats().at(format_index_);
 }
 
 } // namespace xlnt
diff --git a/source/reader.cpp b/source/reader.cpp
index 6698b5ba..ddb49d57 100644
--- a/source/reader.cpp
+++ b/source/reader.cpp
@@ -49,7 +49,7 @@ xlnt::datetime w3cdtf_to_datetime(const std::string &string)
     return result;
 }
     
-void read_worksheet_common(xlnt::worksheet ws, const pugi::xml_node &root_node, const std::vector<std::string> &string_table, const std::vector<int> &number_format_ids)
+void read_worksheet_common(xlnt::worksheet ws, const pugi::xml_node &root_node, const std::vector<std::string> &string_table, const std::vector<int> &number_format_ids, const std::unordered_map<int, std::string> &custom_number_formats)
 {
     auto dimension_node = root_node.child("dimension");
     std::string dimension = dimension_node.attribute("ref").as_string();
@@ -89,11 +89,11 @@ void read_worksheet_common(xlnt::worksheet ws, const pugi::xml_node &root_node,
         }
         else
         {
-            min_column = static_cast<column_t>(full_range.get_top_left().get_column_index() + 1);
-            max_column = static_cast<column_t>(full_range.get_bottom_right().get_column_index() + 1);
+            min_column = static_cast<column_t>(full_range.get_top_left().get_column_index());
+            max_column = static_cast<column_t>(full_range.get_bottom_right().get_column_index());
         }
         
-        for(column_t i = min_column; i < max_column + 1; i++)
+        for(column_t i = min_column; i <= max_column; i++)
         {
             std::string address = xlnt::cell_reference::column_string_from_index(i) + std::to_string(row_index);
             auto cell_node = row_node.find_child_by_attribute("c", "r", address.c_str());
@@ -151,16 +151,32 @@ void read_worksheet_common(xlnt::worksheet ws, const pugi::xml_node &root_node,
                 
                 if(has_style)
                 {
-                    auto number_format_id = number_format_ids.at(static_cast<std::size_t>(std::stoll(style)));
-                    auto format = xlnt::number_format::lookup_format(number_format_id);
-                    
-                    ws.get_cell(address).get_style().get_number_format().set_format_code(format);
-                    
-                    if(format == xlnt::number_format::format::date_xlsx14)
+                    if(number_format_ids.size() > std::stoll(style))
                     {
-                        auto base_date = ws.get_parent().get_properties().excel_base_date;
-                        auto converted = xlnt::date::from_number(std::stoi(value_string), base_date);
-                        ws.get_cell(address).set_value(converted.to_number(xlnt::calendar::windows_1900));
+                        auto number_format_id = number_format_ids.at(static_cast<std::size_t>(std::stoll(style)));
+                        auto format = xlnt::number_format::lookup_format(number_format_id);
+                        
+                        if(format == xlnt::number_format::format::unknown)
+                        {
+                            auto match = custom_number_formats.find(number_format_id);
+                            
+                            if(match != custom_number_formats.end())
+                            {
+                                ws.get_cell(address).get_style().get_number_format().set_format_code_string(match->second, number_format_id);
+                            }
+                        }
+                        else
+                        {
+                            ws.get_cell(address).get_style().get_number_format().set_format_code(format);
+                        }
+                        
+                        //TODO: this is bad
+                        if(ws.get_cell(address).get_style().get_number_format().get_format_code_string().find_first_of("mdyhs") != std::string::npos)
+                        {
+                            auto base_date = ws.get_parent().get_properties().excel_base_date;
+                            auto converted = xlnt::datetime::from_number(std::stold(value_string), base_date);
+                            ws.get_cell(address).set_value(converted.to_number(xlnt::calendar::windows_1900));
+                        }
                     }
                 }
             }
@@ -371,23 +387,23 @@ void reader::fast_parse(worksheet ws, std::istream &xml_source, const std::vecto
 {
     pugi::xml_document doc;
     doc.load(xml_source);
-    read_worksheet_common(ws, doc.child("worksheet"), shared_string, {});
+    read_worksheet_common(ws, doc.child("worksheet"), shared_string, {}, {});
 }
 
-void reader::read_worksheet(worksheet ws, const std::string &xml_string, const std::vector<std::string> &string_table, const std::vector<int> &number_format_ids)
+void reader::read_worksheet(worksheet ws, const std::string &xml_string, const std::vector<std::string> &string_table, const std::vector<int> &number_format_ids, const std::unordered_map<int, std::string> &custom_number_formats)
 {
     pugi::xml_document doc;
     doc.load(xml_string.c_str());
-    read_worksheet_common(ws, doc.child("worksheet"), string_table, number_format_ids);
+    read_worksheet_common(ws, doc.child("worksheet"), string_table, number_format_ids, custom_number_formats);
 }
 
-worksheet xlnt::reader::read_worksheet(std::istream &handle, xlnt::workbook &wb, const std::string &title, const std::vector<std::string> &string_table)
+worksheet xlnt::reader::read_worksheet(std::istream &handle, xlnt::workbook &wb, const std::string &title, const std::vector<std::string> &string_table, const std::unordered_map<int, std::string> &custom_number_formats)
 {
     auto ws = wb.create_sheet();
     ws.set_title(title);
     pugi::xml_document doc;
     doc.load(handle);
-    read_worksheet_common(ws, doc.child("worksheet"), string_table, {});
+    read_worksheet_common(ws, doc.child("worksheet"), string_table, {}, custom_number_formats);
     return ws;
 }
 
diff --git a/source/style_writer.cpp b/source/style_writer.cpp
index 43364488..b345d07b 100644
--- a/source/style_writer.cpp
+++ b/source/style_writer.cpp
@@ -149,5 +149,25 @@ std::string style_writer::write_table() const
 
     return ss.str();
 }
+
+std::string style_writer::write_number_formats()
+{
+    pugi::xml_document doc;
+
+    auto root = doc.append_child("styleSheet");
+    root.append_attribute("xmlns").set_value("http://schemas.openxmlformats.org/spreadsheetml/2006/main");
+    
+    auto num_fmts_node = root.append_child("numFmts");
+    num_fmts_node.append_attribute("count").set_value(1);
+    
+    auto num_fmt_node = num_fmts_node.append_child("numFmt");
+    num_fmt_node.append_attribute("formatCode").set_value("YYYY");
+    num_fmt_node.append_attribute("numFmtId").set_value(164);
+    
+    std::stringstream ss;
+    doc.save(ss);
+    
+    return ss.str();
+}
     
 } // namespace xlnt
diff --git a/source/workbook.cpp b/source/workbook.cpp
index 5c99abc2..79744b55 100644
--- a/source/workbook.cpp
+++ b/source/workbook.cpp
@@ -341,6 +341,7 @@ bool workbook::load(xlnt::zip_file &archive)
     }
 
     std::vector<int> number_format_ids;
+    std::unordered_map<int, std::string> custom_number_formats;
     
     if(archive.has_file("xl/styles.xml"))
     {
@@ -353,6 +354,13 @@ bool workbook::load(xlnt::zip_file &archive)
         {
             number_format_ids.push_back(xf_node.attribute("numFmtId").as_int());
         }
+        
+        auto num_fmts_node = stylesheet_node.child("numFmts");
+        
+        for(auto num_fmt_node : num_fmts_node.children("numFmt"))
+        {
+            custom_number_formats[num_fmt_node.attribute("numFmtId").as_int()] = num_fmt_node.attribute("formatCode").as_string();
+        }
     }
     
     for(auto sheet_node : sheets_node.children("sheet"))
@@ -369,7 +377,7 @@ bool workbook::load(xlnt::zip_file &archive)
         auto ws = create_sheet(sheet_node.attribute("name").as_string(), *rel);
         auto sheet_filename = rel->get_target_uri();
 
-        xlnt::reader::read_worksheet(ws, archive.read(sheet_filename).c_str(), shared_strings, number_format_ids);
+        xlnt::reader::read_worksheet(ws, archive.read(sheet_filename).c_str(), shared_strings, number_format_ids, custom_number_formats);
     }
 
     return true;
diff --git a/source/workbook_writer.cpp b/source/workbook_writer.cpp
index bf3cf20d..7531578f 100644
--- a/source/workbook_writer.cpp
+++ b/source/workbook_writer.cpp
@@ -91,9 +91,9 @@ void excel_writer::write_data(zip_file &archive, bool as_template)
     
     write_charts(archive);
     write_images(archive);
+    write_string_table(archive);
     write_worksheets(archive);
     write_chartsheets(archive);
-    write_string_table(archive);
     write_external_links(archive);
     
     archive.writestr(constants::ArcStyles, style_writer_.write_table());
diff --git a/tests/test_cell.hpp b/tests/test_cell.hpp
index c7d34b7c..bf1308e8 100644
--- a/tests/test_cell.hpp
+++ b/tests/test_cell.hpp
@@ -5,6 +5,7 @@
 #include <cxxtest/TestSuite.h>
 
 #include <xlnt/xlnt.hpp>
+#include <xlnt/reader/reader.hpp>
 
 class test_cell : public CxxTest::TestSuite
 {
@@ -16,7 +17,7 @@ public:
     {
         wb_guess_types.set_guess_types(true);
     }
-
+    
 	void test_infer_numeric()
 	{
 		auto ws = wb_guess_types.create_sheet();
@@ -204,7 +205,7 @@ public:
         
         cell.set_value(xlnt::datetime::today());
         cell.clear_value();
-        TS_ASSERT(cell.is_date());
+        TS_ASSERT(!cell.is_date()); // disagree with openpyxl
         TS_ASSERT(!cell.has_value());
     }
     
@@ -286,7 +287,7 @@ public:
         auto ws = wb[1];
         auto cell = ws.get_cell(xlnt::cell_reference(1, 1));
         
-        TS_ASSERT(cell.to_string() == "<Cell Sheet1.A1>");
+        TS_ASSERT(cell.to_repr() == "<Cell Sheet1.A1>");
     }
     
     void test_comment_assignment()
diff --git a/tests/test_read.hpp b/tests/test_read.hpp
index 8f57b299..3106e333 100644
--- a/tests/test_read.hpp
+++ b/tests/test_read.hpp
@@ -17,7 +17,7 @@ public:
         xlnt::worksheet ws(wb);
         {
             std::ifstream handle(path);
-            ws = xlnt::reader::read_worksheet(handle, wb, "Sheet 2", {"hello"});
+            ws = xlnt::reader::read_worksheet(handle, wb, "Sheet 2", {"hello"}, {});
         }
         TS_ASSERT_DIFFERS(ws, nullptr);
         if(!(ws == nullptr))
diff --git a/tests/test_style.hpp b/tests/test_style.hpp
deleted file mode 100644
index 6ce4e31a..00000000
--- a/tests/test_style.hpp
+++ /dev/null
@@ -1,319 +0,0 @@
-#pragma once
-
-#include <iostream>
-#include <cxxtest/TestSuite.h>
-
-#include <xlnt/xlnt.hpp>
-
-class test_style : public CxxTest::TestSuite
-{
-public:
-    test_style() : writer_(workbook_)
-    {
-        workbook_.set_guess_types(true);
-        auto now = xlnt::datetime::now();
-        auto ws = workbook_.get_active_sheet();
-        ws.get_cell("A1").set_value("12.34%"); // 2
-        ws.get_cell("B1").set_value(now); // 3
-        ws.get_cell("C1").set_value(now);
-        ws.get_cell("D1").set_value("This is a test"); // 1
-        ws.get_cell("E1").set_value("31.31415"); // 3
-        xlnt::style st; // 4
-        st.set_number_format(xlnt::number_format(xlnt::number_format::format::number_00));
-        st.set_protection(xlnt::protection(xlnt::protection::type::unprotected));
-        ws.get_cell("F1").set_style(st);
-        xlnt::style st2; // 5
-        st.set_protection(xlnt::protection(xlnt::protection::type::unprotected));
-        ws.get_cell("G1").set_style(st2);
-        
-    }
-    
-    void test_create_style_table()
-    {
-        TS_SKIP("");
-        //TS_ASSERT_EQUALS(5, writer_.get_styles().size());
-    }
-
-    void test_write_style_table()
-    {
-		TS_SKIP("");
-
-		/*
-        auto path = PathHelper::GetDataDirectory("/writer/expected/simple-styles.xml");
-        pugi::xml_document expected;
-        expected.load_file(path.c_str());
-        
-        auto content = writer_.write_table();
-        pugi::xml_document observed;
-        observed.load(content.c_str());
-        
-        auto diff = Helper::compare_xml(expected, observed);
-        TS_ASSERT(diff);
-		*/
-    }
-
-    void test_no_style()
-    {
-		TS_SKIP("");
-
-		/*
-        xlnt::workbook wb;
-        xlnt::style_writer w(wb);
-        TS_ASSERT_EQUALS(w.get_styles().size(), 1); // there is always the empty (default) style
-		*/
-    }
-
-    void test_nb_style()
-    {
-        TS_SKIP("");
-    }
-
-    void test_style_unicity()
-    {
-        TS_SKIP("");
-    }
-
-    void test_fonts()
-    {
-		TS_SKIP("");
-
-		/*
-        auto expected =
-        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
-        "<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">"
-        "   <fonts count=\"2\">"
-        "      <font>"
-        "         <sz val=\"11\" />"
-        "         <color theme=\"1\" />"
-        "         <name val=\"Calibri\" />"
-        "         <family val=\"2\" />"
-        "         <scheme val=\"minor\" />"
-        "      </font>"
-        "      <font>"
-        "         <sz val=\"12.0\" />"
-        "         <color rgb=\"00000000\" />"
-        "         <name val=\"Calibri\" />"
-        "         <family val=\"2\" />"
-        "         <b />"
-        "      </font>"
-        "   </fonts>"
-        "</styleSheet>";
-        
-        pugi::xml_document expected_doc;
-        expected_doc.load(expected);
-        
-        std::string observed = "";
-        pugi::xml_document observed_doc;
-        observed_doc.load(observed.c_str());
-        
-        auto diff = Helper::compare_xml(expected_doc, observed_doc);
-        TS_ASSERT(diff);
-		*/
-    }
-    
-    void test_fonts_with_underline()
-    {
-		TS_SKIP("");
-
-		/*
-        auto expected =
-        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
-        "<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">"
-        "   <fonts count=\"2\">"
-        "      <font>"
-        "         <sz val=\"11\" />"
-        "         <color theme=\"1\" />"
-        "         <name val=\"Calibri\" />"
-        "         <family val=\"2\" />"
-        "         <scheme val=\"minor\" />"
-        "      </font>"
-        "      <font>"
-        "         <sz val=\"12.0\" />"
-        "         <color rgb=\"00000000\" />"
-        "         <name val=\"Calibri\" />"
-        "         <family val=\"2\" />"
-        "         <b />"
-        "         <u />"
-        "      </font>"
-        "   </fonts>"
-        "</styleSheet>";
-        
-        pugi::xml_document expected_doc;
-        expected_doc.load(expected);
-        
-        std::string observed = "";
-        pugi::xml_document observed_doc;
-        observed_doc.load(observed.c_str());
-        
-        auto diff = Helper::compare_xml(expected_doc, observed_doc);
-        TS_ASSERT(diff);
-		*/
-    }
-
-    void test_fills()
-    {
-		TS_SKIP("");
-
-		/*
-        auto expected =
-        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
-        "<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">"
-        "   <fills count=\"3\">"
-        "      <fill>"
-        "         <patternFill patternType=\"none\" />"
-        "      </fill>"
-        "      <fill>"
-        "         <patternFill patternType=\"gray125\" />"
-        "      </fill>"
-        "      <fill>"
-        "         <patternFill patternType=\"solid\">"
-        "            <fgColor rgb=\"0000FF00\" />"
-        "         </patternFill>"
-        "      </fill>"
-        "   </fills>"
-        "</styleSheet>";
-        
-        pugi::xml_document expected_doc;
-        expected_doc.load(expected);
-        
-        std::string observed = "";
-        pugi::xml_document observed_doc;
-        observed_doc.load(observed.c_str());
-        
-        auto diff = Helper::compare_xml(expected_doc, observed_doc);
-        TS_ASSERT(diff);
-		*/
-    }
-
-    void test_borders()
-    {
-		TS_SKIP("");
-
-		/*
-        auto expected =
-        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
-        "<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">"
-        "   <borders count=\"2\">"
-        "      <border>"
-        "         <left />"
-        "         <right />"
-        "         <top />"
-        "         <bottom />"
-        "         <diagonal />"
-        "      </border>"
-        "      <border>"
-        "         <left />"
-        "         <right />"
-        "         <top style=\"thin\">"
-        "            <color rgb=\"0000FF00\" />"
-        "         </top>"
-        "         <bottom />"
-        "         <diagonal />"
-        "      </border>"
-        "   </borders>"
-        "</styleSheet>";
-        
-        pugi::xml_document expected_doc;
-        expected_doc.load(expected);
-        
-        std::string observed = "";
-        pugi::xml_document observed_doc;
-        observed_doc.load(observed.c_str());
-        
-        auto diff = Helper::compare_xml(expected_doc, observed_doc);
-        TS_ASSERT(diff);
-		*/
-    }
-    
-    void test_write_color()
-    {
-        TS_SKIP("");
-    }
-
-    void test_write_cell_xfs_1()
-    {
-        TS_SKIP("");
-    }
-
-    void test_alignment()
-    {
-        TS_SKIP("");
-    }
-
-    void test_alignment_rotation()
-    {
-        TS_SKIP("");
-    }
-
-    void test_alignment_indent()
-    {
-        TS_SKIP("");
-    }
-    
-    void test_rewrite_styles()
-    {
-        TS_SKIP("");
-    }
-    
-    void test_write_dxf()
-    {
-		TS_SKIP("");
-
-		/*
-        auto expected =
-        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
-        "<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">"
-        "   <dxfs count=\"1\">"
-        "      <dxf>"
-        "         <font>"
-        "            <color rgb=\"FFFFFFFF\" />"
-        "            <b val=\"1\" />"
-        "            <i val=\"1\" />"
-        "            <u val=\"single\" />"
-        "            <strike />"
-        "         </font>"
-        "         <fill>"
-        "            <patternFill patternType=\"solid\">"
-        "               <fgColor rgb=\"FFEE1111\" />"
-        "               <bgColor rgb=\"FFEE1111\" />"
-        "            </patternFill>"
-        "         </fill>"
-        "         <border>"
-        "            <left style=\"medium\">"
-        "               <color rgb=\"000000FF\" />"
-        "            </left>"
-        "            <right style=\"medium\">"
-        "               <color rgb=\"000000FF\" />"
-        "            </right>"
-        "            <top style=\"medium\">"
-        "               <color rgb=\"000000FF\" />"
-        "            </top>"
-        "            <bottom style=\"medium\">"
-        "               <color rgb=\"000000FF\" />"
-        "            </bottom>"
-        "         </border>"
-        "      </dxf>"
-        "   </dxfs>"
-        "</styleSheet>";
-        
-        pugi::xml_document expected_doc;
-        expected_doc.load(expected);
-        
-        std::string observed = "";
-        pugi::xml_document observed_doc;
-        observed_doc.load(observed.c_str());
-        
-        auto diff = Helper::compare_xml(expected_doc, observed_doc);
-        TS_ASSERT(diff);
-		*/
-    }
-    
-    void test_protection()
-    {
-        TS_SKIP("");
-    }
-    
-private:
-    xlnt::workbook workbook_;
-    xlnt::style_writer writer_;
-};
diff --git a/tests/test_style_writer.hpp b/tests/test_style_writer.hpp
new file mode 100644
index 00000000..998847ef
--- /dev/null
+++ b/tests/test_style_writer.hpp
@@ -0,0 +1,284 @@
+#pragma once
+
+#include <iostream>
+#include <cxxtest/TestSuite.h>
+
+#include <xlnt/xlnt.hpp>
+
+class test_style_writer : public CxxTest::TestSuite
+{
+public:
+    void test_write_number_formats()
+    {
+        xlnt::workbook wb;
+        wb.add_number_format("YYYY");
+        xlnt::style_writer writer(wb);
+        auto xml = writer.write_number_formats();
+        std::string expected =
+        "<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">"
+        "    <numFmts count=\"1\">"
+        "    <numFmt formatCode=\"YYYY\" numFmtId=\"164\"></numFmt>"
+        "    </numFmts>"
+        "</styleSheet>";
+        auto diff = Helper::compare_xml(xml, expected);
+        TS_ASSERT(diff);
+    }
+    /*
+    class TestStyleWriter(object):
+    
+    void setup(self):
+    self.workbook = Workbook()
+    self.worksheet = self.workbook.create_sheet()
+    
+    void _test_no_style(self):
+    w = StyleWriter(self.workbook)
+    assert len(w.wb._cell_styles) == 1  # there is always the empty (defaul) style
+    
+    void _test_nb_style(self):
+    for i in range(1, 6):
+    cell = self.worksheet.cell(row=1, column=i)
+    cell.font = Font(size=i)
+    _ = cell.style_id
+    w = StyleWriter(self.workbook)
+    assert len(w.wb._cell_styles) == 6  # 5 + the default
+    
+    cell = self.worksheet.cell('A10')
+    cell.border=Border(top=Side(border_style=borders.BORDER_THIN))
+    _ = cell.style_id
+    w = StyleWriter(self.workbook)
+    assert len(w.wb._cell_styles) == 7
+    
+    
+    void _test_default_xfs(self):
+    w = StyleWriter(self.workbook)
+    fonts = nft = borders = fills = DummyElement()
+    w._write_cell_styles()
+    xml = tostring(w._root)
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <cellXfs count="1">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0" xfId="0"/>
+    </cellXfs>
+    </styleSheet>
+    """
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    void _test_xfs_number_format(self):
+    for idx, nf in enumerate(["0.0%", "0.00%", "0.000%"], 1):
+    cell = self.worksheet.cell(row=idx, column=1)
+    cell.number_format = nf
+    _ = cell.style_id # add to workbook styles
+    w = StyleWriter(self.workbook)
+    w._write_cell_styles()
+    
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <cellXfs count="4">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0" xfId="0"/>
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="164" xfId="0"/>
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="10" xfId="0"/>
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="165" xfId="0"/>
+    </cellXfs>
+    </styleSheet>
+    """
+    
+    xml = tostring(w._root)
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    void _test_xfs_fonts(self):
+    cell = self.worksheet.cell('A1')
+    cell.font = Font(size=12, bold=True)
+    _ = cell.style_id # update workbook styles
+    w = StyleWriter(self.workbook)
+    
+    w._write_cell_styles()
+    xml = tostring(w._root)
+    
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <cellXfs count="2">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0" xfId="0"/>
+    <xf borderId="0" fillId="0" fontId="1" numFmtId="0" xfId="0"/>
+    </cellXfs>
+    </styleSheet>
+    """
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    void _test_xfs_fills(self):
+    cell = self.worksheet.cell('A1')
+    cell.fill = fill=PatternFill(fill_type='solid',
+                                 start_color=Color(colors.DARKYELLOW))
+    _ = cell.style_id # update workbook styles
+    w = StyleWriter(self.workbook)
+    w._write_cell_styles()
+    
+    xml = tostring(w._root)
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <cellXfs count="2">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0" xfId="0"/>
+    <xf borderId="0" fillId="2" fontId="0" numFmtId="0" xfId="0"/>
+    </cellXfs>
+    </styleSheet>
+    """
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    void _test_xfs_borders(self):
+    cell = self.worksheet.cell('A1')
+    cell.border=Border(top=Side(border_style=borders.BORDER_THIN,
+                                color=Color(colors.DARKYELLOW)))
+    _ = cell.style_id # update workbook styles
+    
+    w = StyleWriter(self.workbook)
+    w._write_cell_styles()
+    
+    xml = tostring(w._root)
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <cellXfs count="2">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0" xfId="0"/>
+    <xf borderId="1" fillId="0" fontId="0" numFmtId="0" xfId="0"/>
+    </cellXfs>
+    </styleSheet>
+    """
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    void _test_protection(self):
+    cell = self.worksheet.cell('A1')
+    cell.protection = Protection(locked=True, hidden=True)
+    _ = cell.style_id
+    
+    w = StyleWriter(self.workbook)
+    w._write_cell_styles()
+    xml = tostring(w._root)
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <cellXfs count="2">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0" xfId="0"/>
+    <xf applyProtection="1" borderId="0" fillId="0" fontId="0" numFmtId="0" xfId="0">
+    <protection hidden="1" locked="1"/>
+    </xf>
+    </cellXfs>
+    </styleSheet>
+    """
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    void _test_named_styles(self):
+    writer = StyleWriter(self.workbook)
+    writer._write_named_styles()
+    xml = tostring(writer._root)
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <cellStyleXfs count="1">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0"></xf>
+    </cellStyleXfs>
+    </styleSheet>
+    """
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    void _test_style_names(self):
+    writer = StyleWriter(self.workbook)
+    writer._write_style_names()
+    xml = tostring(writer._root)
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <cellStyles count="1">
+    <cellStyle name="Normal" xfId="0" builtinId="0" hidden="0"/>
+    </cellStyles>
+    </styleSheet>
+    """
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    
+    void _test_simple_styles(datadir):
+    wb = Workbook(guess_types=True)
+    ws = wb.active
+    now = datetime.datetime.now()
+    for idx, v in enumerate(['12.34%', now, 'This is a test', '31.31415', None], 1):
+    ws.append([v])
+    _ = ws.cell(column=1, row=idx).style_id
+    
+# set explicit formats
+    ws['D9'].number_format = numbers.FORMAT_NUMBER_00
+    ws['D9'].protection = Protection(locked=True)
+    ws['D9'].style_id
+    ws['E1'].protection = Protection(hidden=True)
+    ws['E1'].style_id
+    
+    assert len(wb._cell_styles) == 5
+    writer = StyleWriter(wb)
+    
+    datadir.chdir()
+    with open('simple-styles.xml') as reference_file:
+    expected = reference_file.read()
+    xml = writer.write_table()
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+    
+    
+    void _test_empty_workbook():
+    wb = Workbook()
+    writer = StyleWriter(wb)
+    expected = """
+    <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+    <numFmts count="0"/>
+    <fonts count="1">
+    <font>
+    <name val="Calibri"/>
+    <family val="2"/>
+    <color theme="1"/>
+    <sz val="11"/>
+    <scheme val="minor"/>
+    </font>
+    </fonts>
+    <fills count="2">
+    <fill>
+    <patternFill />
+    </fill>
+    <fill>
+    <patternFill patternType="gray125"/>
+    </fill>
+    </fills>
+    <borders count="1">
+    <border>
+    <left/>
+    <right/>
+    <top/>
+    <bottom/>
+    <diagonal/>
+    </border>
+    </borders>
+    <cellStyleXfs count="1">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0"/>
+    </cellStyleXfs>
+    <cellXfs count="1">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0" xfId="0"/>
+    </cellXfs>
+    <cellStyles count="1">
+    <cellStyle builtinId="0" name="Normal" xfId="0" hidden="0"/>
+    </cellStyles>
+    <dxfs count="0"/>
+    <tableStyles count="0" defaultPivotStyle="PivotStyleLight16" defaultTableStyle="TableStyleMedium9"/>
+    </styleSheet>
+    """
+    xml = writer.write_table()
+    diff = compare_xml(xml, expected)
+    assert diff is None, diff
+     */
+};
diff --git a/tests/test_worksheet.hpp b/tests/test_worksheet.hpp
index eb215b91..430ccc88 100644
--- a/tests/test_worksheet.hpp
+++ b/tests/test_worksheet.hpp
@@ -138,13 +138,6 @@ public:
         }
     }
     
-    void test_worksheet_recwarn()
-    {
-        xlnt::worksheet ws(wb_);
-        auto rows = ws.get_range("A1:D4");
-        TS_SKIP(""); // what's recwarn?
-    }
-    
     void test_get_named_range()
     {
         xlnt::worksheet ws(wb_);