├── .github ├── ISSUE_TEMPLATE │ ├── bugreport.md │ └── config.yml └── workflows │ ├── linux.yml │ ├── macos.yml │ └── windows.yml ├── .gitignore ├── CMakeLists.txt ├── LICENSE ├── README.md ├── doc ├── README.md ├── rapidcsv_Converter.md ├── rapidcsv_ConverterParams.md ├── rapidcsv_Document.md ├── rapidcsv_LabelParams.md ├── rapidcsv_LineReaderParams.md ├── rapidcsv_SeparatorParams.md └── rapidcsv_no_converter.md ├── examples ├── cmake-add-subdirectory │ ├── CMakeLists.txt │ ├── README.md │ └── src │ │ └── exprog2.cpp ├── cmake-fetchcontent │ ├── CMakeLists.txt │ ├── README.md │ └── src │ │ └── exprog.cpp ├── colhdr.csv ├── colrowhdr.csv ├── ex001.cpp ├── ex002.cpp ├── ex003.cpp ├── ex004.cpp ├── ex005.cpp ├── ex006.cpp ├── ex007.cpp ├── ex008.cpp ├── ex009.cpp ├── nohdr.csv ├── rowhdr.csv └── semi.csv ├── make.sh ├── src └── rapidcsv.h ├── tests ├── chi-utf16.csv ├── msft.csv ├── perftest.h ├── ptest001.cpp ├── ptest002.cpp ├── test001.cpp ├── test002.cpp ├── test003.cpp ├── test004.cpp ├── test005.cpp ├── test006.cpp ├── test007.cpp ├── test008.cpp ├── test009.cpp ├── test010.cpp ├── test011.cpp ├── test012.cpp ├── test013.cpp ├── test014.cpp ├── test015.cpp ├── test016.cpp ├── test017.cpp ├── test018.cpp ├── test019.cpp ├── test020.cpp ├── test021.cpp ├── test022.cpp ├── test023.cpp ├── test024.cpp ├── test025.cpp ├── test026.cpp ├── test027.cpp ├── test028.cpp ├── test029.cpp ├── test030.cpp ├── test031.cpp ├── test032.cpp ├── test033.cpp ├── test034.cpp ├── test035.cpp ├── test036.cpp ├── test037.cpp ├── test038.cpp ├── test039.cpp ├── test040.cpp ├── test040b.cpp ├── test041.cpp ├── test042.cpp ├── test043.cpp ├── test044.cpp ├── test045.cpp ├── test046.cpp ├── test047.cpp ├── test048.cpp ├── test049.cpp ├── test050.cpp ├── test051.cpp ├── test052.cpp ├── test053.cpp ├── test054.cpp ├── test055.cpp ├── test056.cpp ├── test057.cpp ├── test058.cpp ├── test059.cpp ├── test060.cpp ├── test061.cpp ├── test062.cpp ├── test063.cpp ├── test064.cpp ├── test065.cpp ├── test066.cpp ├── test067.cpp ├── test068.cpp ├── test069.cpp ├── test070.cpp ├── test071.cpp ├── test072.cpp ├── test073.cpp ├── test074.cpp ├── test075.cpp ├── test076.cpp ├── test077.cpp ├── test078.cpp ├── test079.cpp ├── test080.cpp ├── test081.cpp ├── test082.cpp ├── test083.cpp ├── test084.cpp ├── test085.cpp ├── test086.cpp ├── test087.cpp ├── test088.cpp ├── test089.cpp ├── test090.cpp ├── test091.cpp ├── test092.cpp ├── test093.cpp ├── test094.cpp ├── test095.cpp ├── test096.cpp ├── test097.cpp ├── test098.cpp ├── test099.cpp ├── test100.cpp └── unittest.h ├── uncrustify.cfg └── winmake.bat /.github/ISSUE_TEMPLATE/bugreport.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Report a bug by creating a new issue. 4 | labels: bug 5 | assignees: d99kris 6 | --- 7 | 8 | **Description**: 9 | 10 | **How to reproduce it**: 11 | 12 | **Environment**: 13 | - Version: 14 | - OS / distro: 15 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/config.yml: -------------------------------------------------------------------------------- 1 | blank_issues_enabled: false 2 | contact_links: 3 | - name: Feature request 4 | url: https://github.com/d99kris/rapidcsv/discussions/new?category=ideas 5 | about: Suggest a new feature by starting a new discussion. 6 | - name: Question 7 | url: https://github.com/d99kris/rapidcsv/discussions/new?category=q-a 8 | about: Ask a question by starting a new discussion. 9 | -------------------------------------------------------------------------------- /.github/workflows/linux.yml: -------------------------------------------------------------------------------- 1 | name: Linux 2 | 3 | on: 4 | pull_request: 5 | push: 6 | branches: 7 | - master 8 | - main 9 | - dev/* 10 | 11 | jobs: 12 | linux-build: 13 | runs-on: ubuntu-latest 14 | steps: 15 | - name: Checkout 16 | uses: actions/checkout@v1 17 | - name: Build Linux 18 | run: ./make.sh all 19 | -------------------------------------------------------------------------------- /.github/workflows/macos.yml: -------------------------------------------------------------------------------- 1 | name: macOS 2 | 3 | on: 4 | pull_request: 5 | push: 6 | branches: 7 | - master 8 | - main 9 | - dev/* 10 | 11 | jobs: 12 | mac-build: 13 | runs-on: macos-latest 14 | steps: 15 | - name: Checkout 16 | uses: actions/checkout@v1 17 | - name: Build macOS 18 | run: ./make.sh all 19 | -------------------------------------------------------------------------------- /.github/workflows/windows.yml: -------------------------------------------------------------------------------- 1 | name: Windows 2 | 3 | on: [push, pull_request] 4 | 5 | jobs: 6 | windows-build: 7 | runs-on: windows-latest 8 | steps: 9 | - name: Checkout 10 | uses: actions/checkout@v1 11 | - name: Add msbuild to PATH 12 | uses: microsoft/setup-msbuild@v1.1.3 13 | - name: Build Windows 14 | shell: cmd 15 | run: .\winmake.bat all 16 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build-debug 2 | build-release 3 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Project 2 | cmake_minimum_required(VERSION 3.14...3.22 FATAL_ERROR) 3 | project(rapidcsv VERSION 1.0 LANGUAGES CXX) 4 | set (CMAKE_CXX_STANDARD 11) 5 | if(MSVC) 6 | if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") 7 | string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") 8 | else() 9 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") 10 | endif() 11 | add_compile_options("/utf-8") 12 | else() 13 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -Wpedantic -Wshadow -Wpointer-arith \ 14 | -Wcast-qual -Wno-missing-braces -Wswitch-default -Wcast-align \ 15 | -Wunreachable-code -Wundef -Wuninitialized -Wold-style-cast \ 16 | -Wsign-conversion -Weffc++") 17 | endif() 18 | 19 | # Build type 20 | set(DEFAULT_BUILD_TYPE "Release") 21 | if((EXISTS "${CMAKE_SOURCE_DIR}/.svn") OR (EXISTS "${CMAKE_SOURCE_DIR}/.git")) 22 | set(DEFAULT_BUILD_TYPE "Debug") 23 | endif() 24 | if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) 25 | message(STATUS "Using build type '${DEFAULT_BUILD_TYPE}' (default).") 26 | set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}") 27 | else() 28 | message(STATUS "Using build type '${CMAKE_BUILD_TYPE}'.") 29 | endif() 30 | 31 | # Library 32 | add_library(rapidcsv INTERFACE) 33 | target_include_directories(rapidcsv INTERFACE src) 34 | 35 | # Tests 36 | option(RAPIDCSV_BUILD_TESTS "Build tests" OFF) 37 | message(STATUS "Build tests: ${RAPIDCSV_BUILD_TESTS}") 38 | if(RAPIDCSV_BUILD_TESTS) 39 | 40 | # Test init 41 | include(CTest) 42 | enable_testing() 43 | 44 | # Ccache 45 | find_program(CCACHE_PROGRAM ccache) 46 | if(CCACHE_PROGRAM) 47 | message(STATUS "Found ccache") 48 | set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}") 49 | endif() 50 | 51 | # Enable codecvt tests if supported 52 | if (CMAKE_CXX_STANDARD VERSION_LESS "17") 53 | include(CheckIncludeFileCXX) 54 | check_include_file_cxx(codecvt HAS_CODECVT) 55 | if(HAS_CODECVT) 56 | target_compile_definitions(rapidcsv INTERFACE HAS_CODECVT) 57 | endif() 58 | else() 59 | message(STATUS "Skip check for C++ include codecvt - C++${CMAKE_CXX_STANDARD}") 60 | endif() 61 | 62 | # Test macro add_perf_test 63 | macro(add_perf_test testname) 64 | if(CMAKE_BUILD_TYPE MATCHES "Release") 65 | FILE(GLOB sources tests/${testname}*.cpp) 66 | add_executable(${testname} ${sources}) 67 | add_test(NAME ${testname} COMMAND "${PROJECT_BINARY_DIR}/${testname}") 68 | target_link_libraries(${testname} PUBLIC rapidcsv) 69 | endif() 70 | endmacro(add_perf_test) 71 | 72 | # Test macro add_unit_test 73 | macro(add_unit_test testname) 74 | if(CMAKE_BUILD_TYPE MATCHES "Debug") 75 | FILE(GLOB sources tests/${testname}*.cpp) 76 | add_executable(${testname} ${sources}) 77 | add_test(NAME ${testname} COMMAND "${PROJECT_BINARY_DIR}/${testname}") 78 | target_link_libraries(${testname} PUBLIC rapidcsv) 79 | endif() 80 | endmacro(add_unit_test) 81 | 82 | # Unit tests 83 | add_unit_test(test001) 84 | add_unit_test(test002) 85 | add_unit_test(test003) 86 | add_unit_test(test004) 87 | add_unit_test(test005) 88 | add_unit_test(test006) 89 | add_unit_test(test007) 90 | add_unit_test(test008) 91 | add_unit_test(test009) 92 | add_unit_test(test010) 93 | add_unit_test(test011) 94 | add_unit_test(test012) 95 | add_unit_test(test013) 96 | add_unit_test(test014) 97 | add_unit_test(test015) 98 | add_unit_test(test016) 99 | add_unit_test(test017) 100 | add_unit_test(test018) 101 | add_unit_test(test019) 102 | add_unit_test(test020) 103 | add_unit_test(test021) 104 | add_unit_test(test022) 105 | add_unit_test(test023) 106 | add_unit_test(test024) 107 | add_unit_test(test025) 108 | add_unit_test(test026) 109 | add_unit_test(test027) 110 | add_unit_test(test028) 111 | add_unit_test(test029) 112 | add_unit_test(test030) 113 | add_unit_test(test031) 114 | add_unit_test(test032) 115 | add_unit_test(test033) 116 | add_unit_test(test034) 117 | add_unit_test(test035) 118 | add_unit_test(test036) 119 | add_unit_test(test037) 120 | add_unit_test(test038) 121 | add_unit_test(test039) 122 | add_unit_test(test040) 123 | add_unit_test(test041) 124 | add_unit_test(test042) 125 | add_unit_test(test043) 126 | add_unit_test(test044) 127 | add_unit_test(test045) 128 | add_unit_test(test046) 129 | add_unit_test(test047) 130 | add_unit_test(test048) 131 | add_unit_test(test049) 132 | add_unit_test(test050) 133 | add_unit_test(test051) 134 | add_unit_test(test052) 135 | add_unit_test(test053) 136 | add_unit_test(test054) 137 | add_unit_test(test055) 138 | add_unit_test(test056) 139 | if(HAS_CODECVT) 140 | add_unit_test(test057) 141 | add_unit_test(test058) 142 | add_unit_test(test059) 143 | add_unit_test(test060) 144 | endif() 145 | add_unit_test(test061) 146 | add_unit_test(test062) 147 | add_unit_test(test063) 148 | add_unit_test(test064) 149 | add_unit_test(test065) 150 | add_unit_test(test066) 151 | add_unit_test(test067) 152 | add_unit_test(test068) 153 | add_unit_test(test069) 154 | add_unit_test(test070) 155 | add_unit_test(test071) 156 | add_unit_test(test072) 157 | add_unit_test(test073) 158 | add_unit_test(test074) 159 | add_unit_test(test075) 160 | add_unit_test(test076) 161 | add_unit_test(test077) 162 | add_unit_test(test078) 163 | add_unit_test(test079) 164 | add_unit_test(test080) 165 | add_unit_test(test081) 166 | add_unit_test(test082) 167 | add_unit_test(test083) 168 | add_unit_test(test084) 169 | if(HAS_CODECVT) 170 | add_unit_test(test085) 171 | endif() 172 | add_unit_test(test086) 173 | add_unit_test(test087) 174 | add_unit_test(test088) 175 | add_unit_test(test089) 176 | add_unit_test(test090) 177 | add_unit_test(test091) 178 | add_unit_test(test092) 179 | add_unit_test(test093) 180 | add_unit_test(test094) 181 | add_unit_test(test095) 182 | add_unit_test(test096) 183 | add_unit_test(test097) 184 | add_unit_test(test098) 185 | add_unit_test(test099) 186 | add_unit_test(test100) 187 | 188 | # perf tests 189 | add_perf_test(ptest001) 190 | add_perf_test(ptest002) 191 | 192 | # Examples 193 | # Test macro add_example 194 | macro(add_example testname) 195 | if(CMAKE_BUILD_TYPE MATCHES "Debug") 196 | add_executable(${testname} examples/${testname}.cpp) 197 | target_link_libraries(${testname} PUBLIC rapidcsv) 198 | endif() 199 | endmacro(add_example) 200 | 201 | add_example(ex001 examples/ex001.cpp) 202 | add_example(ex002 examples/ex002.cpp) 203 | add_example(ex003 examples/ex003.cpp) 204 | add_example(ex004 examples/ex004.cpp) 205 | add_example(ex005 examples/ex005.cpp) 206 | add_example(ex006 examples/ex006.cpp) 207 | add_example(ex007 examples/ex007.cpp) 208 | add_example(ex008 examples/ex008.cpp) 209 | add_example(ex009 examples/ex009.cpp) 210 | 211 | endif() 212 | 213 | # Install / Uninstall targets for standalone rapidcsv build 214 | if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR) 215 | message(STATUS "Install/uninstall targets enabled.") 216 | 217 | # Install 218 | install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/rapidcsv.h DESTINATION include) 219 | 220 | # Uninstall 221 | add_custom_target(uninstall COMMAND "${CMAKE_COMMAND}" -E remove "${CMAKE_INSTALL_PREFIX}/include/rapidcsv.h" 222 | ) 223 | else() 224 | message(STATUS "Install/uninstall targets disabled.") 225 | endif() 226 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | BSD 3-Clause License 2 | 3 | Copyright (c) 2017, Kristofer Berggren 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | 9 | * Redistributions of source code must retain the above copyright notice, this 10 | list of conditions and the following disclaimer. 11 | 12 | * Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | * Neither the name of the copyright holder nor the names of its 17 | contributors may be used to endorse or promote products derived from 18 | this software without specific prior written permission. 19 | 20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | -------------------------------------------------------------------------------- /doc/README.md: -------------------------------------------------------------------------------- 1 | # API Documentation 2 | - [class rapidcsv::Converter< T >](rapidcsv_Converter.md) 3 | - [class rapidcsv::ConverterParams](rapidcsv_ConverterParams.md) 4 | - [class rapidcsv::Document](rapidcsv_Document.md) 5 | - [class rapidcsv::LabelParams](rapidcsv_LabelParams.md) 6 | - [class rapidcsv::LineReaderParams](rapidcsv_LineReaderParams.md) 7 | - [class rapidcsv::SeparatorParams](rapidcsv_SeparatorParams.md) 8 | - [class rapidcsv::no_converter](rapidcsv_no_converter.md) 9 | -------------------------------------------------------------------------------- /doc/rapidcsv_Converter.md: -------------------------------------------------------------------------------- 1 | ## class rapidcsv::Converter< T > 2 | 3 | Class providing conversion to/from numerical datatypes and strings. Only intended for rapidcsv internal usage, but exposed externally to allow specialization for custom datatype conversions. 4 | 5 | --- 6 | 7 | ```c++ 8 | template Converter (const ConverterParams & pConverterParams) 9 | ``` 10 | Constructor. 11 | 12 | **Parameters** 13 | - `pConverterParams` specifies how conversion of non-numerical values to numerical datatype shall be handled. 14 | 15 | --- 16 | 17 | ```c++ 18 | template void ToStr (const T & pVal, std::string & pStr) 19 | ``` 20 | Converts numerical value to string representation. 21 | 22 | **Parameters** 23 | - `pVal` numerical value 24 | - `pStr` output string 25 | 26 | --- 27 | 28 | ```c++ 29 | template<> void Converter< std::string >::ToStr (const std::string & pVal, std::string & pStr) 30 | ``` 31 | Specialized implementation handling string to string conversion. 32 | 33 | **Parameters** 34 | - `pVal` string 35 | - `pStr` string 36 | 37 | --- 38 | 39 | ```c++ 40 | template void ToVal (const std::string & pStr, T & pVal) 41 | ``` 42 | Converts string holding a numerical value to numerical datatype representation. 43 | 44 | **Parameters** 45 | - `pVal` numerical value 46 | - `pStr` output string 47 | 48 | --- 49 | 50 | ```c++ 51 | template<> void Converter< std::string >::ToVal (const std::string & pStr, std::string & pVal) 52 | ``` 53 | Specialized implementation handling string to string conversion. 54 | 55 | **Parameters** 56 | - `pVal` string 57 | - `pStr` string 58 | 59 | --- 60 | 61 | ###### API documentation generated using [Doxygenmd](https://github.com/d99kris/doxygenmd) 62 | 63 | -------------------------------------------------------------------------------- /doc/rapidcsv_ConverterParams.md: -------------------------------------------------------------------------------- 1 | ## class rapidcsv::ConverterParams 2 | 3 | Datastructure holding parameters controlling how invalid numbers (including empty strings) should be handled. 4 | 5 | --- 6 | 7 | ```c++ 8 | ConverterParams (const bool pHasDefaultConverter = false, const long double pDefaultFloat = std::numeric_limits::signaling_NaN(), const long long pDefaultInteger = 0, const bool pNumericLocale = true) 9 | ``` 10 | Constructor. 11 | 12 | **Parameters** 13 | - `pHasDefaultConverter` specifies if conversion of non-numerical strings shall be converted to a default numerical value, instead of causing an exception to be thrown (default). 14 | - `pDefaultFloat` floating-point default value to represent invalid numbers. 15 | - `pDefaultInteger` integer default value to represent invalid numbers. 16 | - `pNumericLocale` specifies whether to honor LC_NUMERIC locale (default true). 17 | 18 | --- 19 | 20 | ###### API documentation generated using [Doxygenmd](https://github.com/d99kris/doxygenmd) 21 | 22 | -------------------------------------------------------------------------------- /doc/rapidcsv_Document.md: -------------------------------------------------------------------------------- 1 | ## class rapidcsv::Document 2 | 3 | Class representing a CSV document. 4 | 5 | --- 6 | 7 | ```c++ 8 | Document (const std::string & pPath = std::string(), const LabelParams & pLabelParams = LabelParams(), const SeparatorParams & pSeparatorParams = SeparatorParams(), const ConverterParams & pConverterParams = ConverterParams(), const LineReaderParams & pLineReaderParams = LineReaderParams()) 9 | ``` 10 | Constructor. 11 | 12 | **Parameters** 13 | - `pPath` specifies the path of an existing CSV-file to populate the Document data with. 14 | - `pLabelParams` specifies which row and column should be treated as labels. 15 | - `pSeparatorParams` specifies which field and row separators should be used. 16 | - `pConverterParams` specifies how invalid numbers (including empty strings) should be handled. 17 | - `pLineReaderParams` specifies how special line formats should be treated. 18 | 19 | --- 20 | 21 | ```c++ 22 | Document (std::istream & pStream, const LabelParams & pLabelParams = LabelParams(), const SeparatorParams & pSeparatorParams = SeparatorParams(), const ConverterParams & pConverterParams = ConverterParams(), const LineReaderParams & pLineReaderParams = LineReaderParams()) 23 | ``` 24 | Constructor. 25 | 26 | **Parameters** 27 | - `pStream` specifies a binary input stream to read CSV data from. 28 | - `pLabelParams` specifies which row and column should be treated as labels. 29 | - `pSeparatorParams` specifies which field and row separators should be used. 30 | - `pConverterParams` specifies how invalid numbers (including empty strings) should be handled. 31 | - `pLineReaderParams` specifies how special line formats should be treated. 32 | 33 | --- 34 | 35 | ```c++ 36 | void Clear () 37 | ``` 38 | Clears loaded Document data. 39 | 40 | --- 41 | 42 | ```c++ 43 | template T GetCell (const size_t pColumnIdx, const size_t pRowIdx) 44 | ``` 45 | Get cell by index. 46 | 47 | **Parameters** 48 | - `pColumnIdx` zero-based column index. 49 | - `pRowIdx` zero-based row index. 50 | 51 | **Returns:** 52 | - cell data. 53 | 54 | --- 55 | 56 | ```c++ 57 | template T GetCell (const size_t pColumnIdx, const size_t pRowIdx, ConvFunc< T > pToVal) 58 | ``` 59 | Get cell by index. 60 | 61 | **Parameters** 62 | - `pColumnIdx` zero-based column index. 63 | - `pRowIdx` zero-based row index. 64 | - `pToVal` conversion function. 65 | 66 | **Returns:** 67 | - cell data. 68 | 69 | --- 70 | 71 | ```c++ 72 | template T GetCell (const std::string & pColumnName, const std::string & pRowName) 73 | ``` 74 | Get cell by name. 75 | 76 | **Parameters** 77 | - `pColumnName` column label name. 78 | - `pRowName` row label name. 79 | 80 | **Returns:** 81 | - cell data. 82 | 83 | --- 84 | 85 | ```c++ 86 | template T GetCell (const std::string & pColumnName, const std::string & pRowName, ConvFunc< T > pToVal) 87 | ``` 88 | Get cell by name. 89 | 90 | **Parameters** 91 | - `pColumnName` column label name. 92 | - `pRowName` row label name. 93 | - `pToVal` conversion function. 94 | 95 | **Returns:** 96 | - cell data. 97 | 98 | --- 99 | 100 | ```c++ 101 | template T GetCell (const std::string & pColumnName, const size_t pRowIdx) 102 | ``` 103 | Get cell by column name and row index. 104 | 105 | **Parameters** 106 | - `pColumnName` column label name. 107 | - `pRowIdx` zero-based row index. 108 | 109 | **Returns:** 110 | - cell data. 111 | 112 | --- 113 | 114 | ```c++ 115 | template T GetCell (const std::string & pColumnName, const size_t pRowIdx, ConvFunc< T > pToVal) 116 | ``` 117 | Get cell by column name and row index. 118 | 119 | **Parameters** 120 | - `pColumnName` column label name. 121 | - `pRowIdx` zero-based row index. 122 | - `pToVal` conversion function. 123 | 124 | **Returns:** 125 | - cell data. 126 | 127 | --- 128 | 129 | ```c++ 130 | template T GetCell (const size_t pColumnIdx, const std::string & pRowName) 131 | ``` 132 | Get cell by column index and row name. 133 | 134 | **Parameters** 135 | - `pColumnIdx` zero-based column index. 136 | - `pRowName` row label name. 137 | 138 | **Returns:** 139 | - cell data. 140 | 141 | --- 142 | 143 | ```c++ 144 | template T GetCell (const size_t pColumnIdx, const std::string & pRowName, ConvFunc< T > pToVal) 145 | ``` 146 | Get cell by column index and row name. 147 | 148 | **Parameters** 149 | - `pColumnIdx` zero-based column index. 150 | - `pRowName` row label name. 151 | - `pToVal` conversion function. 152 | 153 | **Returns:** 154 | - cell data. 155 | 156 | --- 157 | 158 | ```c++ 159 | template std::vector GetColumn (const size_t pColumnIdx) 160 | ``` 161 | Get column by index. 162 | 163 | **Parameters** 164 | - `pColumnIdx` zero-based column index. 165 | 166 | **Returns:** 167 | - vector of column data. 168 | 169 | --- 170 | 171 | ```c++ 172 | template std::vector GetColumn (const size_t pColumnIdx, ConvFunc< T > pToVal) 173 | ``` 174 | Get column by index. 175 | 176 | **Parameters** 177 | - `pColumnIdx` zero-based column index. 178 | - `pToVal` conversion function. 179 | 180 | **Returns:** 181 | - vector of column data. 182 | 183 | --- 184 | 185 | ```c++ 186 | template std::vector GetColumn (const std::string & pColumnName) 187 | ``` 188 | Get column by name. 189 | 190 | **Parameters** 191 | - `pColumnName` column label name. 192 | 193 | **Returns:** 194 | - vector of column data. 195 | 196 | --- 197 | 198 | ```c++ 199 | template std::vector GetColumn (const std::string & pColumnName, ConvFunc< T > pToVal) 200 | ``` 201 | Get column by name. 202 | 203 | **Parameters** 204 | - `pColumnName` column label name. 205 | - `pToVal` conversion function. 206 | 207 | **Returns:** 208 | - vector of column data. 209 | 210 | --- 211 | 212 | ```c++ 213 | size_t GetColumnCount () 214 | ``` 215 | Get number of data columns (excluding label columns). 216 | 217 | **Returns:** 218 | - column count. 219 | 220 | --- 221 | 222 | ```c++ 223 | int GetColumnIdx (const std::string & pColumnName) 224 | ``` 225 | Get column index by name. 226 | 227 | **Parameters** 228 | - `pColumnName` column label name. 229 | 230 | **Returns:** 231 | - zero-based column index. 232 | 233 | --- 234 | 235 | ```c++ 236 | std::string GetColumnName (const size_t pColumnIdx) 237 | ``` 238 | Get column name. 239 | 240 | **Parameters** 241 | - `pColumnIdx` zero-based column index. 242 | 243 | **Returns:** 244 | - column name. 245 | 246 | --- 247 | 248 | ```c++ 249 | std::vector GetColumnNames () 250 | ``` 251 | Get column names. 252 | 253 | **Returns:** 254 | - vector of column names. 255 | 256 | --- 257 | 258 | ```c++ 259 | template std::vector GetRow (const size_t pRowIdx) 260 | ``` 261 | Get row by index. 262 | 263 | **Parameters** 264 | - `pRowIdx` zero-based row index. 265 | 266 | **Returns:** 267 | - vector of row data. 268 | 269 | --- 270 | 271 | ```c++ 272 | template std::vector GetRow (const size_t pRowIdx, ConvFunc< T > pToVal) 273 | ``` 274 | Get row by index. 275 | 276 | **Parameters** 277 | - `pRowIdx` zero-based row index. 278 | - `pToVal` conversion function. 279 | 280 | **Returns:** 281 | - vector of row data. 282 | 283 | --- 284 | 285 | ```c++ 286 | template std::vector GetRow (const std::string & pRowName) 287 | ``` 288 | Get row by name. 289 | 290 | **Parameters** 291 | - `pRowName` row label name. 292 | 293 | **Returns:** 294 | - vector of row data. 295 | 296 | --- 297 | 298 | ```c++ 299 | template std::vector GetRow (const std::string & pRowName, ConvFunc< T > pToVal) 300 | ``` 301 | Get row by name. 302 | 303 | **Parameters** 304 | - `pRowName` row label name. 305 | - `pToVal` conversion function. 306 | 307 | **Returns:** 308 | - vector of row data. 309 | 310 | --- 311 | 312 | ```c++ 313 | size_t GetRowCount () 314 | ``` 315 | Get number of data rows (excluding label rows). 316 | 317 | **Returns:** 318 | - row count. 319 | 320 | --- 321 | 322 | ```c++ 323 | int GetRowIdx (const std::string & pRowName) 324 | ``` 325 | Get row index by name. 326 | 327 | **Parameters** 328 | - `pRowName` row label name. 329 | 330 | **Returns:** 331 | - zero-based row index. 332 | 333 | --- 334 | 335 | ```c++ 336 | std::string GetRowName (const size_t pRowIdx) 337 | ``` 338 | Get row name. 339 | 340 | **Parameters** 341 | - `pRowIdx` zero-based column index. 342 | 343 | **Returns:** 344 | - row name. 345 | 346 | --- 347 | 348 | ```c++ 349 | std::vector GetRowNames () 350 | ``` 351 | Get row names. 352 | 353 | **Returns:** 354 | - vector of row names. 355 | 356 | --- 357 | 358 | ```c++ 359 | template void InsertColumn (const size_t pColumnIdx, const std::vector< T > & pColumn = std::vector(), const std::string & pColumnName = std::string()) 360 | ``` 361 | Insert column at specified index. 362 | 363 | **Parameters** 364 | - `pColumnIdx` zero-based column index. 365 | - `pColumn` vector of column data (optional argument). 366 | - `pColumnName` column label name (optional argument). 367 | 368 | --- 369 | 370 | ```c++ 371 | template void InsertRow (const size_t pRowIdx, const std::vector< T > & pRow = std::vector(), const std::string & pRowName = std::string()) 372 | ``` 373 | Insert row at specified index. 374 | 375 | **Parameters** 376 | - `pRowIdx` zero-based row index. 377 | - `pRow` vector of row data (optional argument). 378 | - `pRowName` row label name (optional argument). 379 | 380 | --- 381 | 382 | ```c++ 383 | void Load (const std::string & pPath, const LabelParams & pLabelParams = LabelParams(), const SeparatorParams & pSeparatorParams = SeparatorParams(), const ConverterParams & pConverterParams = ConverterParams(), const LineReaderParams & pLineReaderParams = LineReaderParams()) 384 | ``` 385 | Read Document data from file. 386 | 387 | **Parameters** 388 | - `pPath` specifies the path of an existing CSV-file to populate the Document data with. 389 | - `pLabelParams` specifies which row and column should be treated as labels. 390 | - `pSeparatorParams` specifies which field and row separators should be used. 391 | - `pConverterParams` specifies how invalid numbers (including empty strings) should be handled. 392 | - `pLineReaderParams` specifies how special line formats should be treated. 393 | 394 | --- 395 | 396 | ```c++ 397 | void Load (std::istream & pStream, const LabelParams & pLabelParams = LabelParams(), const SeparatorParams & pSeparatorParams = SeparatorParams(), const ConverterParams & pConverterParams = ConverterParams(), const LineReaderParams & pLineReaderParams = LineReaderParams()) 398 | ``` 399 | Read Document data from stream. 400 | 401 | **Parameters** 402 | - `pStream` specifies a binary input stream to read CSV data from. 403 | - `pLabelParams` specifies which row and column should be treated as labels. 404 | - `pSeparatorParams` specifies which field and row separators should be used. 405 | - `pConverterParams` specifies how invalid numbers (including empty strings) should be handled. 406 | - `pLineReaderParams` specifies how special line formats should be treated. 407 | 408 | --- 409 | 410 | ```c++ 411 | void RemoveColumn (const size_t pColumnIdx) 412 | ``` 413 | Remove column by index. 414 | 415 | **Parameters** 416 | - `pColumnIdx` zero-based column index. 417 | 418 | --- 419 | 420 | ```c++ 421 | void RemoveColumn (const std::string & pColumnName) 422 | ``` 423 | Remove column by name. 424 | 425 | **Parameters** 426 | - `pColumnName` column label name. 427 | 428 | --- 429 | 430 | ```c++ 431 | void RemoveRow (const size_t pRowIdx) 432 | ``` 433 | Remove row by index. 434 | 435 | **Parameters** 436 | - `pRowIdx` zero-based row index. 437 | 438 | --- 439 | 440 | ```c++ 441 | void RemoveRow (const std::string & pRowName) 442 | ``` 443 | Remove row by name. 444 | 445 | **Parameters** 446 | - `pRowName` row label name. 447 | 448 | --- 449 | 450 | ```c++ 451 | void Save (const std::string & pPath = std::string()) 452 | ``` 453 | Write Document data to file. 454 | 455 | **Parameters** 456 | - `pPath` optionally specifies the path where the CSV-file will be created (if not specified, the original path provided when creating or loading the Document data will be used). 457 | 458 | --- 459 | 460 | ```c++ 461 | void Save (std::ostream & pStream) 462 | ``` 463 | Write Document data to stream. 464 | 465 | **Parameters** 466 | - `pStream` specifies a binary output stream to write the data to. 467 | 468 | --- 469 | 470 | ```c++ 471 | template void SetCell (const size_t pColumnIdx, const size_t pRowIdx, const T & pCell) 472 | ``` 473 | Set cell by index. 474 | 475 | **Parameters** 476 | - `pRowIdx` zero-based row index. 477 | - `pColumnIdx` zero-based column index. 478 | - `pCell` cell data. 479 | 480 | --- 481 | 482 | ```c++ 483 | template void SetCell (const std::string & pColumnName, const std::string & pRowName, const T & pCell) 484 | ``` 485 | Set cell by name. 486 | 487 | **Parameters** 488 | - `pColumnName` column label name. 489 | - `pRowName` row label name. 490 | - `pCell` cell data. 491 | 492 | --- 493 | 494 | ```c++ 495 | template void SetCell (const size_t pColumnIdx, const std::string & pRowName, const T & pCell) 496 | ``` 497 | Set cell by column index and row name. 498 | 499 | **Parameters** 500 | - `pColumnIdx` zero-based column index. 501 | - `pRowName` row label name. 502 | - `pCell` cell data. 503 | 504 | --- 505 | 506 | ```c++ 507 | template void SetCell (const std::string & pColumnName, const size_t pRowIdx, const T & pCell) 508 | ``` 509 | Set cell by column name and row index. 510 | 511 | **Parameters** 512 | - `pColumnName` column label name. 513 | - `pRowIdx` zero-based row index. 514 | - `pCell` cell data. 515 | 516 | --- 517 | 518 | ```c++ 519 | template void SetColumn (const size_t pColumnIdx, const std::vector< T > & pColumn) 520 | ``` 521 | Set column by index. 522 | 523 | **Parameters** 524 | - `pColumnIdx` zero-based column index. 525 | - `pColumn` vector of column data. 526 | 527 | --- 528 | 529 | ```c++ 530 | template void SetColumn (const std::string & pColumnName, const std::vector< T > & pColumn) 531 | ``` 532 | Set column by name. 533 | 534 | **Parameters** 535 | - `pColumnName` column label name. 536 | - `pColumn` vector of column data. 537 | 538 | --- 539 | 540 | ```c++ 541 | void SetColumnName (size_t pColumnIdx, const std::string & pColumnName) 542 | ``` 543 | Set column name. 544 | 545 | **Parameters** 546 | - `pColumnIdx` zero-based column index. 547 | - `pColumnName` column name. 548 | 549 | --- 550 | 551 | ```c++ 552 | template void SetRow (const size_t pRowIdx, const std::vector< T > & pRow) 553 | ``` 554 | Set row by index. 555 | 556 | **Parameters** 557 | - `pRowIdx` zero-based row index. 558 | - `pRow` vector of row data. 559 | 560 | --- 561 | 562 | ```c++ 563 | template void SetRow (const std::string & pRowName, const std::vector< T > & pRow) 564 | ``` 565 | Set row by name. 566 | 567 | **Parameters** 568 | - `pRowName` row label name. 569 | - `pRow` vector of row data. 570 | 571 | --- 572 | 573 | ```c++ 574 | void SetRowName (size_t pRowIdx, const std::string & pRowName) 575 | ``` 576 | Set row name. 577 | 578 | **Parameters** 579 | - `pRowIdx` zero-based row index. 580 | - `pRowName` row name. 581 | 582 | --- 583 | 584 | ###### API documentation generated using [Doxygenmd](https://github.com/d99kris/doxygenmd) 585 | 586 | -------------------------------------------------------------------------------- /doc/rapidcsv_LabelParams.md: -------------------------------------------------------------------------------- 1 | ## class rapidcsv::LabelParams 2 | 3 | Datastructure holding parameters controlling which row and column should be treated as labels. 4 | 5 | --- 6 | 7 | ```c++ 8 | LabelParams (const int pColumnNameIdx = 0, const int pRowNameIdx = -1) 9 | ``` 10 | Constructor. 11 | 12 | **Parameters** 13 | - `pColumnNameIdx` specifies the zero-based row index of the column labels, setting it to -1 prevents column lookup by label name, and gives access to all rows as document data. Default: 0 14 | - `pRowNameIdx` specifies the zero-based column index of the row labels, setting it to -1 prevents row lookup by label name, and gives access to all columns as document data. Default: -1 15 | 16 | --- 17 | 18 | ###### API documentation generated using [Doxygenmd](https://github.com/d99kris/doxygenmd) 19 | 20 | -------------------------------------------------------------------------------- /doc/rapidcsv_LineReaderParams.md: -------------------------------------------------------------------------------- 1 | ## class rapidcsv::LineReaderParams 2 | 3 | Datastructure holding parameters controlling how special line formats should be treated. 4 | 5 | --- 6 | 7 | ```c++ 8 | LineReaderParams (const bool pSkipCommentLines = false, const char pCommentPrefix = '#', const bool pSkipEmptyLines = false) 9 | ``` 10 | Constructor. 11 | 12 | **Parameters** 13 | - `pSkipCommentLines` specifies whether to skip lines prefixed with mCommentPrefix. Default: false 14 | - `pCommentPrefix` specifies which prefix character to indicate a comment line. Default: # 15 | - `pSkipEmptyLines` specifies whether to skip empty lines. Default: false 16 | 17 | --- 18 | 19 | ###### API documentation generated using [Doxygenmd](https://github.com/d99kris/doxygenmd) 20 | 21 | -------------------------------------------------------------------------------- /doc/rapidcsv_SeparatorParams.md: -------------------------------------------------------------------------------- 1 | ## class rapidcsv::SeparatorParams 2 | 3 | Datastructure holding parameters controlling how the CSV data fields are separated. 4 | 5 | --- 6 | 7 | ```c++ 8 | SeparatorParams (const char pSeparator = ',', const bool pTrim = false, const bool pHasCR = sPlatformHasCR, const bool pQuotedLinebreaks = false, const bool pAutoQuote = true, const char pQuoteChar = '"') 9 | ``` 10 | Constructor. 11 | 12 | **Parameters** 13 | - `pSeparator` specifies the column separator (default ','). 14 | - `pTrim` specifies whether to trim leading and trailing spaces from cells read (default false). 15 | - `pHasCR` specifies whether a new document (i.e. not an existing document read) should use CR/LF instead of only LF (default is to use standard behavior of underlying platforms - CR/LF for Win, and LF for others). 16 | - `pQuotedLinebreaks` specifies whether to allow line breaks in quoted text (default false) 17 | - `pAutoQuote` specifies whether to automatically dequote data during read, and add quotes during write (default true). 18 | - `pQuoteChar` specifies the quote character (default '"'). 19 | 20 | --- 21 | 22 | ###### API documentation generated using [Doxygenmd](https://github.com/d99kris/doxygenmd) 23 | 24 | -------------------------------------------------------------------------------- /doc/rapidcsv_no_converter.md: -------------------------------------------------------------------------------- 1 | ## class rapidcsv::no_converter 2 | 3 | Exception thrown when attempting to access Document data in a datatype which is not supported by the Converter class. 4 | 5 | --- 6 | 7 | ```c++ 8 | const char* what () 9 | ``` 10 | Provides details about the exception. 11 | 12 | **Returns:** 13 | - an explanatory string 14 | 15 | --- 16 | 17 | ###### API documentation generated using [Doxygenmd](https://github.com/d99kris/doxygenmd) 18 | 19 | -------------------------------------------------------------------------------- /examples/cmake-add-subdirectory/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.11 FATAL_ERROR) 2 | project(cmake-addsubdirectory) 3 | set(CMAKE_CXX_STANDARD 11) 4 | 5 | add_subdirectory(rapidcsv) 6 | 7 | add_executable(exprog2 src/exprog2.cpp) 8 | target_link_libraries(exprog2 PUBLIC rapidcsv) 9 | install(TARGETS exprog2 DESTINATION bin) 10 | 11 | add_custom_target(uninstall 12 | COMMAND "${CMAKE_COMMAND}" -E remove "${CMAKE_INSTALL_PREFIX}/bin/exprog2" 13 | ) 14 | -------------------------------------------------------------------------------- /examples/cmake-add-subdirectory/README.md: -------------------------------------------------------------------------------- 1 | CMake Add Subdirectory Example Project 2 | ====================================== 3 | 4 | Build Steps 5 | ----------- 6 | Commands to build the example project: 7 | 8 | ln -s ../.. rapidcsv 9 | mkdir -p build && cd build && cmake .. && make 10 | 11 | 12 | -------------------------------------------------------------------------------- /examples/cmake-add-subdirectory/src/exprog2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | rapidcsv::Document doc("../../colhdr.csv"); 8 | 9 | std::vector col = doc.GetColumn("Close"); 10 | std::cout << "Read " << col.size() << " values." << std::endl; 11 | } 12 | -------------------------------------------------------------------------------- /examples/cmake-fetchcontent/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.11 FATAL_ERROR) 2 | project(cmake-fetchcontent) 3 | set(CMAKE_CXX_STANDARD 11) 4 | 5 | include(FetchContent) 6 | FetchContent_Declare( 7 | rapidcsv 8 | GIT_REPOSITORY "https://github.com/d99kris/rapidcsv.git" 9 | GIT_TAG "v8.50" 10 | ) 11 | FetchContent_MakeAvailable(rapidcsv) 12 | 13 | add_executable(exprog src/exprog.cpp) 14 | target_link_libraries(exprog PUBLIC rapidcsv) 15 | install(TARGETS exprog DESTINATION bin) 16 | 17 | add_custom_target(uninstall 18 | COMMAND "${CMAKE_COMMAND}" -E remove "${CMAKE_INSTALL_PREFIX}/bin/exprog" 19 | ) 20 | -------------------------------------------------------------------------------- /examples/cmake-fetchcontent/README.md: -------------------------------------------------------------------------------- 1 | CMake FetchContent Example Project 2 | ================================== 3 | 4 | Build Steps 5 | ----------- 6 | Commands to build the example project: 7 | 8 | mkdir -p build && cd build && cmake .. && make 9 | 10 | 11 | -------------------------------------------------------------------------------- /examples/cmake-fetchcontent/src/exprog.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | rapidcsv::Document doc("../../colhdr.csv"); 8 | 9 | std::vector col = doc.GetColumn("Close"); 10 | std::cout << "Read " << col.size() << " values." << std::endl; 11 | } 12 | -------------------------------------------------------------------------------- /examples/colhdr.csv: -------------------------------------------------------------------------------- 1 | Open,High,Low,Close,Volume,Adj Close 2 | 64.529999,64.800003,64.139999,64.620003,21705200,64.620003 3 | 64.419998,64.730003,64.190002,64.620003,20235200,64.620003 4 | 64.330002,64.389999,64.050003,64.360001,19259700,64.360001 5 | 64.610001,64.949997,64.449997,64.489998,19384900,64.489998 6 | 64.470001,64.690002,64.300003,64.620003,21234600,64.620003 7 | -------------------------------------------------------------------------------- /examples/colrowhdr.csv: -------------------------------------------------------------------------------- 1 | Date,Open,High,Low,Close,Volume,Adj Close 2 | 2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003 3 | 2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003 4 | 2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001 5 | 2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998 6 | 2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003 7 | -------------------------------------------------------------------------------- /examples/ex001.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | int main() 13 | { 14 | rapidcsv::Document doc("examples/colhdr.csv"); 15 | 16 | std::vector col = doc.GetColumn("Close"); 17 | std::cout << "Read " << col.size() << " values." << std::endl; 18 | } 19 | -------------------------------------------------------------------------------- /examples/ex002.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | int main() 13 | { 14 | rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0)); 15 | 16 | std::vector close = doc.GetRow("2017-02-22"); 17 | std::cout << "Read " << close.size() << " values." << std::endl; 18 | 19 | long long volume = doc.GetCell("Volume", "2017-02-22"); 20 | std::cout << "Volume " << volume << " on 2017-02-22." << std::endl; 21 | } 22 | -------------------------------------------------------------------------------- /examples/ex003.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | int main() 13 | { 14 | rapidcsv::Document doc("examples/rowhdr.csv", rapidcsv::LabelParams(-1, 0)); 15 | 16 | std::vector row = doc.GetRow("2017-02-22"); 17 | std::cout << "Read " << row.size() << " values." << std::endl; 18 | } 19 | -------------------------------------------------------------------------------- /examples/ex004.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | int main() 13 | { 14 | rapidcsv::Document doc("examples/nohdr.csv", rapidcsv::LabelParams(-1, -1)); 15 | 16 | std::vector close = doc.GetColumn(5); 17 | std::cout << "Read " << close.size() << " values." << std::endl; 18 | 19 | long long volume = doc.GetCell(4, 2); 20 | std::cout << "Volume " << volume << " on 2017-02-22." << std::endl; 21 | } 22 | -------------------------------------------------------------------------------- /examples/ex005.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | int main() 13 | { 14 | rapidcsv::Document doc("examples/semi.csv", rapidcsv::LabelParams(0, 0), 15 | rapidcsv::SeparatorParams(';')); 16 | 17 | std::vector close = doc.GetColumn("Close"); 18 | std::cout << "Read " << close.size() << " values." << std::endl; 19 | 20 | long long volume = doc.GetCell("Volume", "2017-02-22"); 21 | std::cout << "Volume " << volume << " on 2017-02-22." << std::endl; 22 | } 23 | -------------------------------------------------------------------------------- /examples/ex006.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | int main() 13 | { 14 | rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0)); 15 | 16 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 17 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 18 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 19 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 20 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 21 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 22 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 23 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 24 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 25 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 26 | std::cout << doc.GetCell("Volume", "2017-02-22") << std::endl; 27 | } 28 | -------------------------------------------------------------------------------- /examples/ex007.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | int main() 13 | { 14 | const std::string& csv = 15 | "Date,Open,High,Low,Close,Volume,Adj Close\n" 16 | "2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003\n" 17 | "2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003\n" 18 | "2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001\n" 19 | "2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998\n" 20 | "2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003\n" 21 | ; 22 | 23 | std::stringstream sstream(csv); 24 | rapidcsv::Document doc(sstream, rapidcsv::LabelParams(0, 0)); 25 | 26 | std::vector close = doc.GetColumn("Close"); 27 | std::cout << "Read " << close.size() << " values." << std::endl; 28 | 29 | long long volume = doc.GetCell("Volume", "2017-02-22"); 30 | std::cout << "Volume " << volume << " on 2017-02-22." << std::endl; 31 | } 32 | -------------------------------------------------------------------------------- /examples/ex008.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | namespace rapidcsv 13 | { 14 | template<> 15 | void Converter::ToVal(const std::string& pStr, int& pVal) const 16 | { 17 | pVal = static_cast(roundf(100.0f * std::stof(pStr))); 18 | } 19 | } 20 | 21 | int main() 22 | { 23 | rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0)); 24 | 25 | std::vector close = doc.GetColumn("Close"); 26 | std::cout << "close[0] = " << close[0] << std::endl; 27 | std::cout << "close[1] = " << close[1] << std::endl; 28 | } 29 | -------------------------------------------------------------------------------- /examples/ex009.cpp: -------------------------------------------------------------------------------- 1 | #if 0 2 | TMP=$(mktemp -d) 3 | c++ -std=c++11 -I src -o ${TMP}/a.out ${0} && ${TMP}/a.out ${@:1} ; RV=${?} 4 | rm -rf ${TMP} 5 | exit ${RV} 6 | #endif 7 | 8 | #include 9 | #include 10 | #include "rapidcsv.h" 11 | 12 | void ConvFixPoint(const std::string& pStr, int& pVal) 13 | { 14 | pVal = static_cast(roundf(100.0f * std::stof(pStr))); 15 | } 16 | 17 | struct MyStruct 18 | { 19 | int val = 0; 20 | }; 21 | 22 | void ConvMyStruct(const std::string& pStr, MyStruct& pVal) 23 | { 24 | pVal.val = static_cast(roundf(100.0f * std::stof(pStr))); 25 | } 26 | 27 | int main() 28 | { 29 | rapidcsv::Document doc("examples/colrowhdr.csv", rapidcsv::LabelParams(0, 0)); 30 | 31 | std::cout << "regular = " << doc.GetCell("Close", "2017-02-21") << "\n"; 32 | std::cout << "fixpointfunc = " << doc.GetCell("Close", "2017-02-21", ConvFixPoint) << "\n"; 33 | 34 | auto convFixLambda = [](const std::string& pStr, int& pVal) { pVal = static_cast(roundf(100.0f * stof(pStr))); }; 35 | std::cout << "fixpointlambda = " << doc.GetCell("Close", "2017-02-21", convFixLambda) << "\n"; 36 | 37 | std::cout << "mystruct = " << doc.GetCell("Close", "2017-02-21", ConvMyStruct).val << "\n"; 38 | } 39 | -------------------------------------------------------------------------------- /examples/nohdr.csv: -------------------------------------------------------------------------------- 1 | 64.529999,64.800003,64.139999,64.620003,21705200,64.620003 2 | 64.419998,64.730003,64.190002,64.620003,20235200,64.620003 3 | 64.330002,64.389999,64.050003,64.360001,19259700,64.360001 4 | 64.610001,64.949997,64.449997,64.489998,19384900,64.489998 5 | 64.470001,64.690002,64.300003,64.620003,21234600,64.620003 6 | -------------------------------------------------------------------------------- /examples/rowhdr.csv: -------------------------------------------------------------------------------- 1 | 2017-02-24,64.529999,64.800003,64.139999,64.620003,21705200,64.620003 2 | 2017-02-23,64.419998,64.730003,64.190002,64.620003,20235200,64.620003 3 | 2017-02-22,64.330002,64.389999,64.050003,64.360001,19259700,64.360001 4 | 2017-02-21,64.610001,64.949997,64.449997,64.489998,19384900,64.489998 5 | 2017-02-17,64.470001,64.690002,64.300003,64.620003,21234600,64.620003 6 | -------------------------------------------------------------------------------- /examples/semi.csv: -------------------------------------------------------------------------------- 1 | Date;Open;High;Low;Close;Volume;Adj Close 2 | 2017-02-24;64.529999;64.800003;64.139999;64.620003;21705200;64.620003 3 | 2017-02-23;64.419998;64.730003;64.190002;64.620003;20235200;64.620003 4 | 2017-02-22;64.330002;64.389999;64.050003;64.360001;19259700;64.360001 5 | 2017-02-21;64.610001;64.949997;64.449997;64.489998;19384900;64.489998 6 | 2017-02-17;64.470001;64.690002;64.300003;64.620003;21234600;64.620003 7 | -------------------------------------------------------------------------------- /make.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | # make.sh 4 | # 5 | # Copyright (C) 2020-2024 Kristofer Berggren 6 | # All rights reserved. 7 | # 8 | # See LICENSE for redistribution information. 9 | 10 | # exiterr 11 | exiterr() 12 | { 13 | >&2 echo "${1}" 14 | exit 1 15 | } 16 | 17 | # process arguments 18 | DEPS="0" 19 | SRC="0" 20 | BUILD="0" 21 | TESTS="0" 22 | DOC="0" 23 | INSTALL="0" 24 | case "${1%/}" in 25 | deps) 26 | DEPS="1" 27 | ;; 28 | 29 | src) 30 | SRC="1" 31 | ;; 32 | 33 | build) 34 | BUILD="1" 35 | ;; 36 | 37 | test*) 38 | BUILD="1" 39 | TESTS="1" 40 | ;; 41 | 42 | doc) 43 | DOC="1" 44 | ;; 45 | 46 | install) 47 | BUILD="1" 48 | INSTALL="1" 49 | ;; 50 | 51 | all) 52 | DEPS="1" 53 | SRC="1" 54 | BUILD="1" 55 | TESTS="1" 56 | DOC="1" 57 | INSTALL="1" 58 | ;; 59 | 60 | *) 61 | echo "usage: make.sh " 62 | echo " deps - install project dependencies" 63 | echo " src - reformat source code" 64 | echo " build - perform build" 65 | echo " tests - perform build and run tests" 66 | echo " doc - perform build and generate documentation" 67 | echo " install - perform build and install" 68 | echo " all - perform all actions above" 69 | exit 1 70 | ;; 71 | esac 72 | 73 | # deps 74 | if [[ "${DEPS}" == "1" ]]; then 75 | OS="$(uname)" 76 | if [ "${OS}" == "Linux" ]; then 77 | DISTRO="$(lsb_release -i | awk -F':\t' '{print $2}')" 78 | if [[ "${DISTRO}" == "Ubuntu" ]]; then 79 | if [[ "${GITHUB_ACTIONS}" == "true" ]]; then 80 | # ensure de_DE locale is present when running CI tests 81 | locale -a | grep -qi "de_DE.utf8" 82 | if [[ "${?}" != "0" ]]; then 83 | sudo locale-gen "de_DE.UTF-8" || exiterr "deps failed (${DISTRO}), exiting." 84 | fi 85 | fi 86 | else 87 | exiterr "deps failed (unsupported linux distro ${DISTRO}), exiting." 88 | fi 89 | elif [ "${OS}" == "Darwin" ]; then 90 | true || exiterr "deps failed (mac), exiting." 91 | else 92 | exiterr "deps failed (unsupported os ${OS}), exiting." 93 | fi 94 | fi 95 | 96 | # src 97 | if [[ "${SRC}" == "1" ]]; then 98 | if [[ -x "$(command -v uncrustify)" ]]; then 99 | TMPDIR=$(mktemp -d) 100 | for SRC in examples/*.cpp; do 101 | DST="${TMPDIR}/$(basename ${SRC})" 102 | printf "\n\n\n\n\n\n" > ${DST} # add 6 blank lines 103 | tail -n +8 ${SRC} >> ${DST} # skip header (first 7 lines) 104 | head -7 ${SRC} > ${DST}.header # store header separately (first 7 lines) 105 | done 106 | 107 | uncrustify -c uncrustify.cfg --replace --no-backup src/rapidcsv.h tests/*.cpp tests/*.h ${TMPDIR}/*.cpp 108 | if [[ "${?}" != "0" ]]; then 109 | rm -rf ${TMPDIR} 110 | echo "src failed, exiting." 111 | exit 1 112 | fi 113 | 114 | for DST in examples/*.cpp; do 115 | SRC="${TMPDIR}/$(basename ${DST})" 116 | cat ${SRC}.header > ${DST}.tmp 117 | cat ${SRC} >> ${DST}.tmp 118 | 119 | cmp --silent ${DST} ${DST}.tmp 120 | if [[ "${?}" != "0" ]]; then 121 | cat ${DST}.tmp > ${DST} 122 | fi 123 | rm ${DST}.tmp 124 | done 125 | 126 | rm -rf ${TMPDIR} 127 | fi 128 | fi 129 | 130 | # build 131 | if [[ "${BUILD}" == "1" ]]; then 132 | OS="$(uname)" 133 | MAKEARGS="" 134 | if [ "${OS}" == "Linux" ]; then 135 | MAKEARGS="-j$(nproc)" 136 | elif [ "${OS}" == "Darwin" ]; then 137 | MAKEARGS="-j$(sysctl -n hw.ncpu)" 138 | fi 139 | mkdir -p build-debug && cd build-debug && cmake -DRAPIDCSV_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug .. && make -s ${MAKEARGS} && cd .. && \ 140 | mkdir -p build-release && cd build-release && cmake -DRAPIDCSV_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Release .. && make -s ${MAKEARGS} && cd .. || \ 141 | exiterr "build failed, exiting." 142 | fi 143 | 144 | # tests 145 | if [[ "${TESTS}" == "1" ]]; then 146 | OS="$(uname)" 147 | CTESTARGS="" 148 | if [ "${OS}" == "Linux" ]; then 149 | CTESTARGS="-j$(nproc)" 150 | elif [ "${OS}" == "Darwin" ]; then 151 | CTESTARGS="-j$(sysctl -n hw.ncpu)" 152 | fi 153 | cd build-debug && ctest --output-on-failure ${CTESTARGS} && cd .. && \ 154 | cd build-release && ctest --verbose && cd .. || \ 155 | exiterr "tests failed, exiting." 156 | fi 157 | 158 | # doc 159 | if [[ "${DOC}" == "1" ]]; then 160 | if [[ -x "$(command -v doxygenmd)" ]]; then 161 | doxygenmd src doc || exiterr "doc failed, exiting." 162 | fi 163 | fi 164 | 165 | # install 166 | if [[ "${INSTALL}" == "1" ]]; then 167 | OS="$(uname)" 168 | if [ "${OS}" == "Linux" ]; then 169 | cd build-release && sudo make install && cd .. || exiterr "install failed (linux), exiting." 170 | elif [ "${OS}" == "Darwin" ]; then 171 | GHSUDO="" 172 | if [[ "${GITHUB_ACTIONS}" == "true" ]]; then 173 | GHSUDO="sudo" 174 | fi 175 | cd build-release && ${GHSUDO} make install && cd .. || exiterr "install failed (mac), exiting." 176 | else 177 | exiterr "install failed (unsupported os ${OS}), exiting." 178 | fi 179 | fi 180 | 181 | # exit 182 | exit 0 183 | -------------------------------------------------------------------------------- /tests/chi-utf16.csv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/d99kris/rapidcsv/d76cf1c08e79be1eb04c9d4d8eb7893221127991/tests/chi-utf16.csv -------------------------------------------------------------------------------- /tests/perftest.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace perftest 6 | { 7 | class Timer 8 | { 9 | public: 10 | Timer() 11 | : start() 12 | , stop() 13 | , poststop() 14 | , lastspan() 15 | , spans() 16 | { 17 | } 18 | 19 | void Start() 20 | { 21 | // Timestamp 22 | start = std::chrono::high_resolution_clock::now(); 23 | } 24 | 25 | void Stop() 26 | { 27 | // Timestamps 28 | stop = std::chrono::high_resolution_clock::now(); 29 | poststop = std::chrono::high_resolution_clock::now(); 30 | 31 | // Calculate duration 32 | std::chrono::duration span = 33 | std::chrono::duration_cast>(stop - start - (poststop - stop)); 34 | 35 | // Store 36 | lastspan = span.count(); 37 | spans.push_back(lastspan); 38 | } 39 | 40 | double GetLastDurationSec() 41 | { 42 | return lastspan; 43 | } 44 | 45 | double GetLastDurationUs() 46 | { 47 | return GetLastDurationSec() * 1000000.0; 48 | } 49 | 50 | double GetMedianDurationSec() 51 | { 52 | double median = 0; 53 | if (spans.size() > 0) 54 | { 55 | sort(spans.begin(), spans.end()); 56 | median = spans.at(spans.size() / 2); 57 | } 58 | 59 | return median; 60 | } 61 | 62 | double GetMedianDurationUs() 63 | { 64 | return GetMedianDurationSec() * 1000000.0; 65 | } 66 | 67 | void ReportMedian() 68 | { 69 | std::cout << "Test median duration Elapsed "; 70 | std::cout << static_cast(round(GetMedianDurationUs())) << " us\n"; 71 | } 72 | 73 | private: 74 | std::chrono::high_resolution_clock::time_point start; 75 | std::chrono::high_resolution_clock::time_point stop; 76 | std::chrono::high_resolution_clock::time_point poststop; 77 | double lastspan; 78 | std::vector spans; 79 | }; 80 | } 81 | -------------------------------------------------------------------------------- /tests/ptest001.cpp: -------------------------------------------------------------------------------- 1 | // ptest001.cpp - file load and get data by column, row and cell 2 | 3 | #include 4 | #include "perftest.h" 5 | #include "unittest.h" 6 | 7 | int main() 8 | { 9 | int rv = 0; 10 | 11 | try 12 | { 13 | perftest::Timer timer; 14 | 15 | for (int i = 0; i < 10; ++i) 16 | { 17 | timer.Start(); 18 | 19 | rapidcsv::Document doc("../tests/msft.csv", rapidcsv::LabelParams(0, 0)); 20 | const std::vector& column = doc.GetColumn("Close"); 21 | const std::vector& row = doc.GetRow("2016-05-23"); 22 | const double cell = doc.GetCell("Close", "2016-05-23"); 23 | 24 | timer.Stop(); 25 | 26 | // dummy usage of variables 27 | (void)column; 28 | (void)row; 29 | (void)cell; 30 | } 31 | 32 | timer.ReportMedian(); 33 | } 34 | catch (const std::exception& ex) 35 | { 36 | std::cout << ex.what() << std::endl; 37 | rv = 1; 38 | } 39 | 40 | return rv; 41 | } 42 | -------------------------------------------------------------------------------- /tests/ptest002.cpp: -------------------------------------------------------------------------------- 1 | // ptest002.cpp - file load 2 | 3 | #include 4 | #include "perftest.h" 5 | #include "unittest.h" 6 | 7 | int main() 8 | { 9 | int rv = 0; 10 | 11 | try 12 | { 13 | perftest::Timer timer; 14 | 15 | for (int i = 0; i < 10; ++i) 16 | { 17 | timer.Start(); 18 | 19 | rapidcsv::Document doc("../tests/msft.csv"); 20 | 21 | timer.Stop(); 22 | } 23 | 24 | timer.ReportMedian(); 25 | } 26 | catch (const std::exception& ex) 27 | { 28 | std::cout << ex.what() << std::endl; 29 | rv = 1; 30 | } 31 | 32 | return rv; 33 | } 34 | -------------------------------------------------------------------------------- /tests/test001.cpp: -------------------------------------------------------------------------------- 1 | // test001.cpp - read cell value 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 23 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 24 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 25 | 26 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 27 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 28 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 29 | } 30 | catch (const std::exception& ex) 31 | { 32 | std::cout << ex.what() << std::endl; 33 | rv = 1; 34 | } 35 | 36 | unittest::DeleteFile(path); 37 | 38 | return rv; 39 | } 40 | -------------------------------------------------------------------------------- /tests/test002.cpp: -------------------------------------------------------------------------------- 1 | // test002.cpp - set cell value 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string csv = 17 | "-,A,B,C\n" 18 | "1,0,0,0\n" 19 | "2,0,0,0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 28 | 29 | doc.SetCell(0, 0, 3); 30 | doc.SetCell(1, 0, 9); 31 | doc.SetCell(2, 0, 81); 32 | 33 | doc.SetCell("A", "2", "4"); 34 | doc.SetCell("B", "2", "16"); 35 | doc.SetCell("C", "2", "256"); 36 | 37 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 38 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 39 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 40 | 41 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 42 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 43 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 44 | 45 | doc.Save(); 46 | 47 | std::string csvread = unittest::ReadFile(path); 48 | 49 | unittest::ExpectEqual(std::string, csvref, csvread); 50 | } 51 | catch (const std::exception& ex) 52 | { 53 | std::cout << ex.what() << std::endl; 54 | rv = 1; 55 | } 56 | 57 | unittest::DeleteFile(path); 58 | 59 | return rv; 60 | } 61 | -------------------------------------------------------------------------------- /tests/test003.cpp: -------------------------------------------------------------------------------- 1 | // test003.cpp - read column values 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | 23 | std::vector ints; 24 | std::vector strs; 25 | 26 | ints = doc.GetColumn(0); 27 | unittest::ExpectEqual(size_t, ints.size(), 2); 28 | unittest::ExpectEqual(int, ints.at(0), 3); 29 | unittest::ExpectEqual(int, ints.at(1), 4); 30 | 31 | ints = doc.GetColumn("B"); 32 | unittest::ExpectEqual(size_t, ints.size(), 2); 33 | unittest::ExpectEqual(int, ints.at(0), 9); 34 | unittest::ExpectEqual(int, ints.at(1), 16); 35 | 36 | strs = doc.GetColumn(2); 37 | unittest::ExpectEqual(size_t, strs.size(), 2); 38 | unittest::ExpectEqual(std::string, strs.at(0), "81"); 39 | unittest::ExpectEqual(std::string, strs.at(1), "256"); 40 | } 41 | catch (const std::exception& ex) 42 | { 43 | std::cout << ex.what() << std::endl; 44 | rv = 1; 45 | } 46 | 47 | unittest::DeleteFile(path); 48 | 49 | return rv; 50 | } 51 | -------------------------------------------------------------------------------- /tests/test004.cpp: -------------------------------------------------------------------------------- 1 | // test004.cpp - set column values 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string csv = 17 | "-,A,B,C\n" 18 | "1,0,0,0\n" 19 | "2,0,0,0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 28 | 29 | doc.SetColumn(0, std::vector({ 3, 4 })); 30 | doc.SetColumn("B", std::vector({ 9, 16 })); 31 | doc.SetColumn(2, std::vector({ "81", "256" })); 32 | 33 | std::vector ints; 34 | std::vector strs; 35 | 36 | ints = doc.GetColumn(0); 37 | unittest::ExpectEqual(size_t, ints.size(), 2); 38 | unittest::ExpectEqual(int, ints.at(0), 3); 39 | unittest::ExpectEqual(int, ints.at(1), 4); 40 | 41 | strs = doc.GetColumn(1); 42 | unittest::ExpectEqual(size_t, strs.size(), 2); 43 | unittest::ExpectEqual(std::string, strs.at(0), "9"); 44 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 45 | 46 | ints = doc.GetColumn("C"); 47 | unittest::ExpectEqual(size_t, ints.size(), 2); 48 | unittest::ExpectEqual(int, ints.at(0), 81); 49 | unittest::ExpectEqual(int, ints.at(1), 256); 50 | 51 | doc.Save(); 52 | 53 | std::string csvread = unittest::ReadFile(path); 54 | 55 | unittest::ExpectEqual(std::string, csvref, csvread); 56 | } 57 | catch (const std::exception& ex) 58 | { 59 | std::cout << ex.what() << std::endl; 60 | rv = 1; 61 | } 62 | 63 | unittest::DeleteFile(path); 64 | 65 | return rv; 66 | } 67 | -------------------------------------------------------------------------------- /tests/test005.cpp: -------------------------------------------------------------------------------- 1 | // test005.cpp - read row values 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | 23 | std::vector ints; 24 | std::vector strs; 25 | 26 | ints = doc.GetRow(0); 27 | unittest::ExpectEqual(size_t, ints.size(), 3); 28 | unittest::ExpectEqual(int, ints.at(0), 3); 29 | unittest::ExpectEqual(int, ints.at(1), 9); 30 | unittest::ExpectEqual(int, ints.at(2), 81); 31 | 32 | strs = doc.GetRow("2"); 33 | unittest::ExpectEqual(size_t, strs.size(), 3); 34 | unittest::ExpectEqual(std::string, strs.at(0), "4"); 35 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 36 | unittest::ExpectEqual(std::string, strs.at(2), "256"); 37 | } 38 | catch (const std::exception& ex) 39 | { 40 | std::cout << ex.what() << std::endl; 41 | rv = 1; 42 | } 43 | 44 | unittest::DeleteFile(path); 45 | 46 | return rv; 47 | } 48 | -------------------------------------------------------------------------------- /tests/test006.cpp: -------------------------------------------------------------------------------- 1 | // test006.cpp - set row values 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string csv = 17 | "-,A,B,C\n" 18 | "1,0,0,0\n" 19 | "2,0,0,0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 28 | 29 | doc.SetRow(0, std::vector({ 3, 9, 81 })); 30 | doc.SetRow("2", std::vector({ "4", "16", "256" })); 31 | 32 | std::vector ints; 33 | std::vector strs; 34 | 35 | ints = doc.GetRow("1"); 36 | unittest::ExpectEqual(size_t, ints.size(), 3); 37 | unittest::ExpectEqual(int, ints.at(0), 3); 38 | unittest::ExpectEqual(int, ints.at(1), 9); 39 | unittest::ExpectEqual(int, ints.at(2), 81); 40 | 41 | strs = doc.GetRow(1); 42 | unittest::ExpectEqual(size_t, strs.size(), 3); 43 | unittest::ExpectEqual(std::string, strs.at(0), "4"); 44 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 45 | unittest::ExpectEqual(std::string, strs.at(2), "256"); 46 | 47 | doc.Save(); 48 | 49 | std::string csvread = unittest::ReadFile(path); 50 | 51 | unittest::ExpectEqual(std::string, csvref, csvread); 52 | } 53 | catch (const std::exception& ex) 54 | { 55 | std::cout << ex.what() << std::endl; 56 | rv = 1; 57 | } 58 | 59 | unittest::DeleteFile(path); 60 | 61 | return rv; 62 | } 63 | -------------------------------------------------------------------------------- /tests/test007.cpp: -------------------------------------------------------------------------------- 1 | // test007.cpp - delete columns 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,B,D\n" 12 | "0,4,256\n" 13 | "1,9,6561\n" 14 | "2,16,65536\n" 15 | "3,25,390625\n" 16 | ; 17 | 18 | std::string csv = 19 | "-,A,B,C,D\n" 20 | "0,2,4,16,256\n" 21 | "1,3,9,81,6561\n" 22 | "2,4,16,256,65536\n" 23 | "3,5,25,625,390625\n" 24 | ; 25 | 26 | std::string path = unittest::TempPath(); 27 | unittest::WriteFile(path, csv); 28 | 29 | try 30 | { 31 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 32 | 33 | doc.RemoveColumn("C"); 34 | doc.RemoveColumn(0); 35 | 36 | doc.Save(); 37 | 38 | std::string csvread = unittest::ReadFile(path); 39 | 40 | unittest::ExpectEqual(std::string, csvref, csvread); 41 | } 42 | catch (const std::exception& ex) 43 | { 44 | std::cout << ex.what() << std::endl; 45 | rv = 1; 46 | } 47 | 48 | unittest::DeleteFile(path); 49 | 50 | return rv; 51 | } 52 | -------------------------------------------------------------------------------- /tests/test008.cpp: -------------------------------------------------------------------------------- 1 | // test008.cpp - delete rows 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,A,B,C,D\n" 12 | "1,3,9,81,6561\n" 13 | "2,4,16,256,65536\n" 14 | ; 15 | 16 | std::string csv = 17 | "-,A,B,C,D\n" 18 | "0,2,4,16,256\n" 19 | "1,3,9,81,6561\n" 20 | "2,4,16,256,65536\n" 21 | "3,5,25,625,390625\n" 22 | ; 23 | 24 | std::string path = unittest::TempPath(); 25 | unittest::WriteFile(path, csv); 26 | 27 | try 28 | { 29 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 30 | 31 | doc.RemoveRow("3"); 32 | doc.RemoveRow(0); 33 | 34 | doc.Save(); 35 | 36 | std::string csvread = unittest::ReadFile(path); 37 | 38 | unittest::ExpectEqual(std::string, csvref, csvread); 39 | } 40 | catch (const std::exception& ex) 41 | { 42 | std::cout << ex.what() << std::endl; 43 | rv = 1; 44 | } 45 | 46 | unittest::DeleteFile(path); 47 | 48 | return rv; 49 | } 50 | -------------------------------------------------------------------------------- /tests/test009.cpp: -------------------------------------------------------------------------------- 1 | // test009.cpp - generate new document by row 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | ",A,B,C,D\n" 12 | "0,2,4,16,256\n" 13 | "1,3,9,81,6561\n" 14 | "2,4,16,256,65536\n" 15 | "3,5,25,625,390625\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false)); 23 | 24 | doc.SetRow(0, std::vector({ 2, 4 })); 25 | doc.SetRow(1, std::vector({ 3, 9, 81, 6561 })); 26 | doc.SetRow(2, std::vector({ 4, 16, 256, 65536 })); 27 | doc.SetRow(3, std::vector({ 5, 25, 625, 390625 })); 28 | 29 | doc.SetCell(2, 0, 16); 30 | doc.SetCell(3, 0, 256); 31 | 32 | doc.SetColumnName(0, "A"); 33 | doc.SetColumnName(1, "B"); 34 | doc.SetColumnName(2, "C"); 35 | doc.SetColumnName(3, "D"); 36 | 37 | doc.SetRowName(0, "0"); 38 | doc.SetRowName(1, "1"); 39 | doc.SetRowName(2, "2"); 40 | doc.SetRowName(3, "3"); 41 | 42 | doc.Save(path); 43 | 44 | std::string csvread = unittest::ReadFile(path); 45 | 46 | unittest::ExpectEqual(std::string, csvref, csvread); 47 | } 48 | catch (const std::exception& ex) 49 | { 50 | std::cout << ex.what() << std::endl; 51 | rv = 1; 52 | } 53 | 54 | unittest::DeleteFile(path); 55 | 56 | return rv; 57 | } 58 | -------------------------------------------------------------------------------- /tests/test010.cpp: -------------------------------------------------------------------------------- 1 | // test010.cpp - generate new document by column 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | ",A,B,C,D\n" 12 | "0,2,4,16,256\n" 13 | "1,3,9,81,6561\n" 14 | "2,4,16,256,65536\n" 15 | "3,5,25,625,390625\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false)); 23 | 24 | doc.SetColumn(0, std::vector({ 2, 3 })); 25 | doc.SetColumn(1, std::vector({ 4, 9, 16, 25 })); 26 | doc.SetColumn(2, std::vector({ 16, 81, 256, 625 })); 27 | doc.SetColumn(3, std::vector({ 256, 6561, 65536, 390625 })); 28 | 29 | doc.SetCell(0, 2, 4); 30 | doc.SetCell(0, 3, 5); 31 | 32 | doc.SetColumnName(0, "A"); 33 | doc.SetColumnName(1, "B"); 34 | doc.SetColumnName(2, "C"); 35 | doc.SetColumnName(3, "D"); 36 | 37 | doc.SetRowName(0, "0"); 38 | doc.SetRowName(1, "1"); 39 | doc.SetRowName(2, "2"); 40 | doc.SetRowName(3, "3"); 41 | 42 | doc.Save(path); 43 | 44 | std::string csvread = unittest::ReadFile(path); 45 | 46 | unittest::ExpectEqual(std::string, csvref, csvread); 47 | } 48 | catch (const std::exception& ex) 49 | { 50 | std::cout << ex.what() << std::endl; 51 | rv = 1; 52 | } 53 | 54 | unittest::DeleteFile(path); 55 | 56 | return rv; 57 | } 58 | -------------------------------------------------------------------------------- /tests/test011.cpp: -------------------------------------------------------------------------------- 1 | // test011.cpp - generate new document by cell 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | ",A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | 18 | try 19 | { 20 | rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false)); 21 | 22 | doc.SetCell(0, 0, 3); 23 | doc.SetCell(1, 0, 9); 24 | doc.SetCell(2, 0, 81); 25 | 26 | doc.SetCell(0, 1, 4); 27 | doc.SetCell(1, 1, 16); 28 | doc.SetCell(2, 1, 256); 29 | 30 | doc.SetColumnName(0, "A"); 31 | doc.SetColumnName(1, "B"); 32 | doc.SetColumnName(2, "C"); 33 | 34 | doc.SetRowName(0, "1"); 35 | doc.SetRowName(1, "2"); 36 | 37 | doc.Save(path); 38 | 39 | std::string csvread = unittest::ReadFile(path); 40 | 41 | unittest::ExpectEqual(std::string, csvref, csvread); 42 | } 43 | catch (const std::exception& ex) 44 | { 45 | std::cout << ex.what() << std::endl; 46 | rv = 1; 47 | } 48 | 49 | unittest::DeleteFile(path); 50 | 51 | return rv; 52 | } 53 | -------------------------------------------------------------------------------- /tests/test012.cpp: -------------------------------------------------------------------------------- 1 | // test012.cpp - read cell value, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "A,B,C\n" 12 | "3,9,81\n" 13 | "4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path); 22 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 23 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 24 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 25 | 26 | unittest::ExpectEqual(std::string, doc.GetCell(0, 1), "4"); 27 | unittest::ExpectEqual(std::string, doc.GetCell(1, 1), "16"); 28 | unittest::ExpectEqual(std::string, doc.GetCell(2, 1), "256"); 29 | } 30 | catch (const std::exception& ex) 31 | { 32 | std::cout << ex.what() << std::endl; 33 | rv = 1; 34 | } 35 | 36 | unittest::DeleteFile(path); 37 | 38 | return rv; 39 | } 40 | -------------------------------------------------------------------------------- /tests/test013.cpp: -------------------------------------------------------------------------------- 1 | // test013.cpp - set cell value, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "A,B,C\n" 12 | "3,9,81\n" 13 | "4,16,256\n" 14 | ; 15 | 16 | std::string csv = 17 | "A,B,C\n" 18 | "0,0,0\n" 19 | "0,0,0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path); 28 | 29 | doc.SetCell(0, 0, 3); 30 | doc.SetCell(1, 0, 9); 31 | doc.SetCell(2, 0, 81); 32 | 33 | doc.SetCell(0, 1, "4"); 34 | doc.SetCell(1, 1, "16"); 35 | doc.SetCell(2, 1, "256"); 36 | 37 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 38 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 39 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 40 | 41 | unittest::ExpectEqual(std::string, doc.GetCell(0, 1), "4"); 42 | unittest::ExpectEqual(std::string, doc.GetCell(1, 1), "16"); 43 | unittest::ExpectEqual(std::string, doc.GetCell(2, 1), "256"); 44 | 45 | doc.Save(); 46 | 47 | std::string csvread = unittest::ReadFile(path); 48 | 49 | unittest::ExpectEqual(std::string, csvref, csvread); 50 | } 51 | catch (const std::exception& ex) 52 | { 53 | std::cout << ex.what() << std::endl; 54 | rv = 1; 55 | } 56 | 57 | unittest::DeleteFile(path); 58 | 59 | return rv; 60 | } 61 | -------------------------------------------------------------------------------- /tests/test014.cpp: -------------------------------------------------------------------------------- 1 | // test014.cpp - read column values, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "A,B,C\n" 12 | "3,9,81\n" 13 | "4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path); 22 | 23 | std::vector ints; 24 | std::vector strs; 25 | 26 | ints = doc.GetColumn(0); 27 | unittest::ExpectEqual(size_t, ints.size(), 2); 28 | unittest::ExpectEqual(int, ints.at(0), 3); 29 | unittest::ExpectEqual(int, ints.at(1), 4); 30 | 31 | ints = doc.GetColumn("B"); 32 | unittest::ExpectEqual(size_t, ints.size(), 2); 33 | unittest::ExpectEqual(int, ints.at(0), 9); 34 | unittest::ExpectEqual(int, ints.at(1), 16); 35 | 36 | strs = doc.GetColumn(2); 37 | unittest::ExpectEqual(size_t, strs.size(), 2); 38 | unittest::ExpectEqual(std::string, strs.at(0), "81"); 39 | unittest::ExpectEqual(std::string, strs.at(1), "256"); 40 | } 41 | catch (const std::exception& ex) 42 | { 43 | std::cout << ex.what() << std::endl; 44 | rv = 1; 45 | } 46 | 47 | unittest::DeleteFile(path); 48 | 49 | return rv; 50 | } 51 | -------------------------------------------------------------------------------- /tests/test015.cpp: -------------------------------------------------------------------------------- 1 | // test015.cpp - set column values, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "A,B,C\n" 12 | "3,9,81\n" 13 | "4,16,256\n" 14 | ; 15 | 16 | std::string csv = 17 | "A,B,C\n" 18 | "0,0,0\n" 19 | "0,0,0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path); 28 | 29 | doc.SetColumn(0, std::vector({ 3, 4 })); 30 | doc.SetColumn("B", std::vector({ 9, 16 })); 31 | doc.SetColumn(2, std::vector({ "81", "256" })); 32 | 33 | std::vector ints; 34 | std::vector strs; 35 | 36 | ints = doc.GetColumn(0); 37 | unittest::ExpectEqual(size_t, ints.size(), 2); 38 | unittest::ExpectEqual(int, ints.at(0), 3); 39 | unittest::ExpectEqual(int, ints.at(1), 4); 40 | 41 | strs = doc.GetColumn(1); 42 | unittest::ExpectEqual(size_t, strs.size(), 2); 43 | unittest::ExpectEqual(std::string, strs.at(0), "9"); 44 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 45 | 46 | ints = doc.GetColumn("C"); 47 | unittest::ExpectEqual(size_t, ints.size(), 2); 48 | unittest::ExpectEqual(int, ints.at(0), 81); 49 | unittest::ExpectEqual(int, ints.at(1), 256); 50 | 51 | doc.Save(); 52 | 53 | std::string csvread = unittest::ReadFile(path); 54 | 55 | unittest::ExpectEqual(std::string, csvref, csvread); 56 | } 57 | catch (const std::exception& ex) 58 | { 59 | std::cout << ex.what() << std::endl; 60 | rv = 1; 61 | } 62 | 63 | unittest::DeleteFile(path); 64 | 65 | return rv; 66 | } 67 | -------------------------------------------------------------------------------- /tests/test016.cpp: -------------------------------------------------------------------------------- 1 | // test016.cpp - read row values, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "A,B,C\n" 12 | "3,9,81\n" 13 | "4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path); 22 | 23 | std::vector ints; 24 | std::vector strs; 25 | 26 | ints = doc.GetRow(0); 27 | unittest::ExpectEqual(size_t, ints.size(), 3); 28 | unittest::ExpectEqual(int, ints.at(0), 3); 29 | unittest::ExpectEqual(int, ints.at(1), 9); 30 | unittest::ExpectEqual(int, ints.at(2), 81); 31 | 32 | strs = doc.GetRow(1); 33 | unittest::ExpectEqual(size_t, strs.size(), 3); 34 | unittest::ExpectEqual(std::string, strs.at(0), "4"); 35 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 36 | unittest::ExpectEqual(std::string, strs.at(2), "256"); 37 | } 38 | catch (const std::exception& ex) 39 | { 40 | std::cout << ex.what() << std::endl; 41 | rv = 1; 42 | } 43 | 44 | unittest::DeleteFile(path); 45 | 46 | return rv; 47 | } 48 | -------------------------------------------------------------------------------- /tests/test017.cpp: -------------------------------------------------------------------------------- 1 | // test017.cpp - set row values, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "A,B,C\n" 12 | "3,9,81\n" 13 | "4,16,256\n" 14 | ; 15 | 16 | std::string csv = 17 | "A,B,C\n" 18 | "0,0,0\n" 19 | "0,0,0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path); 28 | 29 | doc.SetRow(0, std::vector({ 3, 9, 81 })); 30 | doc.SetRow(1, std::vector({ "4", "16", "256" })); 31 | 32 | std::vector ints; 33 | std::vector strs; 34 | 35 | ints = doc.GetRow(0); 36 | unittest::ExpectEqual(size_t, ints.size(), 3); 37 | unittest::ExpectEqual(int, ints.at(0), 3); 38 | unittest::ExpectEqual(int, ints.at(1), 9); 39 | unittest::ExpectEqual(int, ints.at(2), 81); 40 | 41 | strs = doc.GetRow(1); 42 | unittest::ExpectEqual(size_t, strs.size(), 3); 43 | unittest::ExpectEqual(std::string, strs.at(0), "4"); 44 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 45 | unittest::ExpectEqual(std::string, strs.at(2), "256"); 46 | 47 | doc.Save(); 48 | 49 | std::string csvread = unittest::ReadFile(path); 50 | 51 | unittest::ExpectEqual(std::string, csvref, csvread); 52 | } 53 | catch (const std::exception& ex) 54 | { 55 | std::cout << ex.what() << std::endl; 56 | rv = 1; 57 | } 58 | 59 | unittest::DeleteFile(path); 60 | 61 | return rv; 62 | } 63 | -------------------------------------------------------------------------------- /tests/test018.cpp: -------------------------------------------------------------------------------- 1 | // test018.cpp - delete columns, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "B,C\n" 12 | "4,16\n" 13 | "9,81\n" 14 | "16,256\n" 15 | "25,625\n" 16 | ; 17 | 18 | std::string csv = 19 | "A,B,C,D\n" 20 | "2,4,16,256\n" 21 | "3,9,81,6561\n" 22 | "4,16,256,65536\n" 23 | "5,25,625,390625\n" 24 | ; 25 | 26 | std::string path = unittest::TempPath(); 27 | unittest::WriteFile(path, csv); 28 | 29 | try 30 | { 31 | rapidcsv::Document doc(path); 32 | 33 | doc.RemoveColumn("D"); 34 | doc.RemoveColumn(0); 35 | 36 | doc.Save(); 37 | 38 | std::string csvread = unittest::ReadFile(path); 39 | 40 | unittest::ExpectEqual(std::string, csvref, csvread); 41 | } 42 | catch (const std::exception& ex) 43 | { 44 | std::cout << ex.what() << std::endl; 45 | rv = 1; 46 | } 47 | 48 | unittest::DeleteFile(path); 49 | 50 | return rv; 51 | } 52 | -------------------------------------------------------------------------------- /tests/test019.cpp: -------------------------------------------------------------------------------- 1 | // test019.cpp - delete rows, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "A,B,C,D\n" 12 | "3,9,81,6561\n" 13 | "4,16,256,65536\n" 14 | ; 15 | 16 | std::string csv = 17 | "A,B,C,D\n" 18 | "2,4,16,256\n" 19 | "3,9,81,6561\n" 20 | "4,16,256,65536\n" 21 | "5,25,625,390625\n" 22 | ; 23 | 24 | std::string path = unittest::TempPath(); 25 | unittest::WriteFile(path, csv); 26 | 27 | try 28 | { 29 | rapidcsv::Document doc(path); 30 | 31 | doc.RemoveRow(3); 32 | doc.RemoveRow(0); 33 | 34 | doc.Save(); 35 | 36 | std::string csvread = unittest::ReadFile(path); 37 | 38 | unittest::ExpectEqual(std::string, csvref, csvread); 39 | } 40 | catch (const std::exception& ex) 41 | { 42 | std::cout << ex.what() << std::endl; 43 | rv = 1; 44 | } 45 | 46 | unittest::DeleteFile(path); 47 | 48 | return rv; 49 | } 50 | -------------------------------------------------------------------------------- /tests/test020.cpp: -------------------------------------------------------------------------------- 1 | // test020.cpp - generate new document by row, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "A,B,C,D\n" 12 | "2,4,16,256\n" 13 | "3,9,81,6561\n" 14 | "4,16,256,65536\n" 15 | "5,25,625,390625\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc("", rapidcsv::LabelParams(), rapidcsv::SeparatorParams(',', false, false)); 23 | 24 | doc.SetRow(0, std::vector({ 2, 4 })); 25 | doc.SetRow(1, std::vector({ 3, 9, 81, 6561 })); 26 | doc.SetRow(2, std::vector({ 4, 16, 256, 65536 })); 27 | doc.SetRow(3, std::vector({ 5, 25, 625, 390625 })); 28 | 29 | doc.SetCell(2, 0, 16); 30 | doc.SetCell(3, 0, 256); 31 | 32 | doc.SetColumnName(0, "A"); 33 | doc.SetColumnName(1, "B"); 34 | doc.SetColumnName(2, "C"); 35 | doc.SetColumnName(3, "D"); 36 | 37 | doc.Save(path); 38 | 39 | std::string csvread = unittest::ReadFile(path); 40 | 41 | unittest::ExpectEqual(std::string, csvref, csvread); 42 | } 43 | catch (const std::exception& ex) 44 | { 45 | std::cout << ex.what() << std::endl; 46 | rv = 1; 47 | } 48 | 49 | unittest::DeleteFile(path); 50 | 51 | return rv; 52 | } 53 | -------------------------------------------------------------------------------- /tests/test021.cpp: -------------------------------------------------------------------------------- 1 | // test021.cpp - generate new document by column, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "A,B,C,D\n" 12 | "2,4,16,256\n" 13 | "3,9,81,6561\n" 14 | "4,16,256,65536\n" 15 | "5,25,625,390625\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc("", rapidcsv::LabelParams(), rapidcsv::SeparatorParams(',', false, false)); 23 | 24 | doc.SetColumn(0, std::vector({ 2, 3 })); 25 | doc.SetColumn(1, std::vector({ 4, 9, 16, 25 })); 26 | doc.SetColumn(2, std::vector({ 16, 81, 256, 625 })); 27 | doc.SetColumn(3, std::vector({ 256, 6561, 65536, 390625 })); 28 | 29 | doc.SetCell(0, 2, 4); 30 | doc.SetCell(0, 3, 5); 31 | 32 | doc.SetColumnName(0, "A"); 33 | doc.SetColumnName(1, "B"); 34 | doc.SetColumnName(2, "C"); 35 | doc.SetColumnName(3, "D"); 36 | 37 | doc.Save(path); 38 | 39 | std::string csvread = unittest::ReadFile(path); 40 | 41 | unittest::ExpectEqual(std::string, csvref, csvread); 42 | } 43 | catch (const std::exception& ex) 44 | { 45 | std::cout << ex.what() << std::endl; 46 | rv = 1; 47 | } 48 | 49 | unittest::DeleteFile(path); 50 | 51 | return rv; 52 | } 53 | -------------------------------------------------------------------------------- /tests/test022.cpp: -------------------------------------------------------------------------------- 1 | // test022.cpp - generate new document by cell, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "A,B,C\n" 12 | "3,9,81\n" 13 | "4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | 18 | try 19 | { 20 | rapidcsv::Document doc("", rapidcsv::LabelParams(), rapidcsv::SeparatorParams(',', false, false)); 21 | 22 | doc.SetCell(0, 0, 3); 23 | doc.SetCell(1, 0, 9); 24 | doc.SetCell(2, 0, 81); 25 | 26 | doc.SetCell(0, 1, 4); 27 | doc.SetCell(1, 1, 16); 28 | doc.SetCell(2, 1, 256); 29 | 30 | doc.SetColumnName(0, "A"); 31 | doc.SetColumnName(1, "B"); 32 | doc.SetColumnName(2, "C"); 33 | 34 | doc.Save(path); 35 | 36 | std::string csvread = unittest::ReadFile(path); 37 | 38 | unittest::ExpectEqual(std::string, csvref, csvread); 39 | } 40 | catch (const std::exception& ex) 41 | { 42 | std::cout << ex.what() << std::endl; 43 | rv = 1; 44 | } 45 | 46 | unittest::DeleteFile(path); 47 | 48 | return rv; 49 | } 50 | -------------------------------------------------------------------------------- /tests/test023.cpp: -------------------------------------------------------------------------------- 1 | // test023.cpp - read cell value, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "3,9,81\n" 12 | "4,16,256\n" 13 | ; 14 | 15 | std::string path = unittest::TempPath(); 16 | unittest::WriteFile(path, csv); 17 | 18 | try 19 | { 20 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 21 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 22 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 23 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 24 | 25 | unittest::ExpectEqual(std::string, doc.GetCell(0, 1), "4"); 26 | unittest::ExpectEqual(std::string, doc.GetCell(1, 1), "16"); 27 | unittest::ExpectEqual(std::string, doc.GetCell(2, 1), "256"); 28 | } 29 | catch (const std::exception& ex) 30 | { 31 | std::cout << ex.what() << std::endl; 32 | rv = 1; 33 | } 34 | 35 | unittest::DeleteFile(path); 36 | 37 | return rv; 38 | } 39 | -------------------------------------------------------------------------------- /tests/test024.cpp: -------------------------------------------------------------------------------- 1 | // test024.cpp - set cell value, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "3,9,81\n" 12 | "4,16,256\n" 13 | ; 14 | 15 | std::string csv = 16 | "0,0,0\n" 17 | "0,0,0\n" 18 | ; 19 | 20 | std::string path = unittest::TempPath(); 21 | unittest::WriteFile(path, csv); 22 | 23 | try 24 | { 25 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 26 | 27 | doc.SetCell(0, 0, 3); 28 | doc.SetCell(1, 0, 9); 29 | doc.SetCell(2, 0, 81); 30 | 31 | doc.SetCell(0, 1, "4"); 32 | doc.SetCell(1, 1, "16"); 33 | doc.SetCell(2, 1, "256"); 34 | 35 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 36 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 37 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 38 | 39 | unittest::ExpectEqual(std::string, doc.GetCell(0, 1), "4"); 40 | unittest::ExpectEqual(std::string, doc.GetCell(1, 1), "16"); 41 | unittest::ExpectEqual(std::string, doc.GetCell(2, 1), "256"); 42 | 43 | doc.Save(); 44 | 45 | std::string csvread = unittest::ReadFile(path); 46 | 47 | unittest::ExpectEqual(std::string, csvref, csvread); 48 | } 49 | catch (const std::exception& ex) 50 | { 51 | std::cout << ex.what() << std::endl; 52 | rv = 1; 53 | } 54 | 55 | unittest::DeleteFile(path); 56 | 57 | return rv; 58 | } 59 | -------------------------------------------------------------------------------- /tests/test025.cpp: -------------------------------------------------------------------------------- 1 | // test025.cpp - read column values, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "3,9,81\n" 12 | "4,16,256\n" 13 | ; 14 | 15 | std::string path = unittest::TempPath(); 16 | unittest::WriteFile(path, csv); 17 | 18 | try 19 | { 20 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 21 | 22 | std::vector ints; 23 | std::vector strs; 24 | 25 | ints = doc.GetColumn(0); 26 | unittest::ExpectEqual(size_t, ints.size(), 2); 27 | unittest::ExpectEqual(int, ints.at(0), 3); 28 | unittest::ExpectEqual(int, ints.at(1), 4); 29 | 30 | ints = doc.GetColumn(1); 31 | unittest::ExpectEqual(size_t, ints.size(), 2); 32 | unittest::ExpectEqual(int, ints.at(0), 9); 33 | unittest::ExpectEqual(int, ints.at(1), 16); 34 | 35 | strs = doc.GetColumn(2); 36 | unittest::ExpectEqual(size_t, strs.size(), 2); 37 | unittest::ExpectEqual(std::string, strs.at(0), "81"); 38 | unittest::ExpectEqual(std::string, strs.at(1), "256"); 39 | } 40 | catch (const std::exception& ex) 41 | { 42 | std::cout << ex.what() << std::endl; 43 | rv = 1; 44 | } 45 | 46 | unittest::DeleteFile(path); 47 | 48 | return rv; 49 | } 50 | -------------------------------------------------------------------------------- /tests/test026.cpp: -------------------------------------------------------------------------------- 1 | // test026.cpp - set column values, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "3,9,81\n" 12 | "4,16,256\n" 13 | ; 14 | 15 | std::string csv = 16 | "0,0,0\n" 17 | "0,0,0\n" 18 | ; 19 | 20 | std::string path = unittest::TempPath(); 21 | unittest::WriteFile(path, csv); 22 | 23 | try 24 | { 25 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 26 | 27 | doc.SetColumn(0, std::vector({ 3, 4 })); 28 | doc.SetColumn(1, std::vector({ 9, 16 })); 29 | doc.SetColumn(2, std::vector({ "81", "256" })); 30 | 31 | std::vector ints; 32 | std::vector strs; 33 | 34 | ints = doc.GetColumn(0); 35 | unittest::ExpectEqual(size_t, ints.size(), 2); 36 | unittest::ExpectEqual(int, ints.at(0), 3); 37 | unittest::ExpectEqual(int, ints.at(1), 4); 38 | 39 | strs = doc.GetColumn(1); 40 | unittest::ExpectEqual(size_t, strs.size(), 2); 41 | unittest::ExpectEqual(std::string, strs.at(0), "9"); 42 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 43 | 44 | ints = doc.GetColumn(2); 45 | unittest::ExpectEqual(size_t, ints.size(), 2); 46 | unittest::ExpectEqual(int, ints.at(0), 81); 47 | unittest::ExpectEqual(int, ints.at(1), 256); 48 | 49 | doc.Save(); 50 | 51 | std::string csvread = unittest::ReadFile(path); 52 | 53 | unittest::ExpectEqual(std::string, csvref, csvread); 54 | } 55 | catch (const std::exception& ex) 56 | { 57 | std::cout << ex.what() << std::endl; 58 | rv = 1; 59 | } 60 | 61 | unittest::DeleteFile(path); 62 | 63 | return rv; 64 | } 65 | -------------------------------------------------------------------------------- /tests/test027.cpp: -------------------------------------------------------------------------------- 1 | // test027.cpp - read row values, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "3,9,81\n" 12 | "4,16,256\n" 13 | ; 14 | 15 | std::string path = unittest::TempPath(); 16 | unittest::WriteFile(path, csv); 17 | 18 | try 19 | { 20 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 21 | 22 | std::vector ints; 23 | std::vector strs; 24 | 25 | ints = doc.GetRow(0); 26 | unittest::ExpectEqual(size_t, ints.size(), 3); 27 | unittest::ExpectEqual(int, ints.at(0), 3); 28 | unittest::ExpectEqual(int, ints.at(1), 9); 29 | unittest::ExpectEqual(int, ints.at(2), 81); 30 | 31 | strs = doc.GetRow(1); 32 | unittest::ExpectEqual(size_t, strs.size(), 3); 33 | unittest::ExpectEqual(std::string, strs.at(0), "4"); 34 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 35 | unittest::ExpectEqual(std::string, strs.at(2), "256"); 36 | } 37 | catch (const std::exception& ex) 38 | { 39 | std::cout << ex.what() << std::endl; 40 | rv = 1; 41 | } 42 | 43 | unittest::DeleteFile(path); 44 | 45 | return rv; 46 | } 47 | -------------------------------------------------------------------------------- /tests/test028.cpp: -------------------------------------------------------------------------------- 1 | // test028.cpp - set row values, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "3,9,81\n" 12 | "4,16,256\n" 13 | ; 14 | 15 | std::string csv = 16 | "0,0,0\n" 17 | "0,0,0\n" 18 | ; 19 | 20 | std::string path = unittest::TempPath(); 21 | unittest::WriteFile(path, csv); 22 | 23 | try 24 | { 25 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 26 | 27 | doc.SetRow(0, std::vector({ 3, 9, 81 })); 28 | doc.SetRow(1, std::vector({ "4", "16", "256" })); 29 | 30 | std::vector ints; 31 | std::vector strs; 32 | 33 | ints = doc.GetRow(0); 34 | unittest::ExpectEqual(size_t, ints.size(), 3); 35 | unittest::ExpectEqual(int, ints.at(0), 3); 36 | unittest::ExpectEqual(int, ints.at(1), 9); 37 | unittest::ExpectEqual(int, ints.at(2), 81); 38 | 39 | strs = doc.GetRow(1); 40 | unittest::ExpectEqual(size_t, strs.size(), 3); 41 | unittest::ExpectEqual(std::string, strs.at(0), "4"); 42 | unittest::ExpectEqual(std::string, strs.at(1), "16"); 43 | unittest::ExpectEqual(std::string, strs.at(2), "256"); 44 | 45 | doc.Save(); 46 | 47 | std::string csvread = unittest::ReadFile(path); 48 | 49 | unittest::ExpectEqual(std::string, csvref, csvread); 50 | } 51 | catch (const std::exception& ex) 52 | { 53 | std::cout << ex.what() << std::endl; 54 | rv = 1; 55 | } 56 | 57 | unittest::DeleteFile(path); 58 | 59 | return rv; 60 | } 61 | -------------------------------------------------------------------------------- /tests/test029.cpp: -------------------------------------------------------------------------------- 1 | // test029.cpp - delete columns, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "4,256\n" 12 | "9,6561\n" 13 | "16,65536\n" 14 | "25,390625\n" 15 | ; 16 | 17 | std::string csv = 18 | "2,4,16,256\n" 19 | "3,9,81,6561\n" 20 | "4,16,256,65536\n" 21 | "5,25,625,390625\n" 22 | ; 23 | 24 | std::string path = unittest::TempPath(); 25 | unittest::WriteFile(path, csv); 26 | 27 | try 28 | { 29 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 30 | 31 | doc.RemoveColumn(2); 32 | doc.RemoveColumn(0); 33 | 34 | doc.Save(); 35 | 36 | std::string csvread = unittest::ReadFile(path); 37 | 38 | unittest::ExpectEqual(std::string, csvref, csvread); 39 | } 40 | catch (const std::exception& ex) 41 | { 42 | std::cout << ex.what() << std::endl; 43 | rv = 1; 44 | } 45 | 46 | unittest::DeleteFile(path); 47 | 48 | return rv; 49 | } 50 | -------------------------------------------------------------------------------- /tests/test030.cpp: -------------------------------------------------------------------------------- 1 | // test030.cpp - delete rows, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "3,9,81,6561\n" 12 | "4,16,256,65536\n" 13 | ; 14 | 15 | std::string csv = 16 | "2,4,16,256\n" 17 | "3,9,81,6561\n" 18 | "4,16,256,65536\n" 19 | "5,25,625,390625\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 28 | 29 | doc.RemoveRow(3); 30 | doc.RemoveRow(0); 31 | 32 | doc.Save(); 33 | 34 | std::string csvread = unittest::ReadFile(path); 35 | 36 | unittest::ExpectEqual(std::string, csvref, csvread); 37 | } 38 | catch (const std::exception& ex) 39 | { 40 | std::cout << ex.what() << std::endl; 41 | rv = 1; 42 | } 43 | 44 | unittest::DeleteFile(path); 45 | 46 | return rv; 47 | } 48 | -------------------------------------------------------------------------------- /tests/test031.cpp: -------------------------------------------------------------------------------- 1 | // test031.cpp - generate new document by row, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "2,4,16,256\n" 12 | "3,9,81,6561\n" 13 | "4,16,256,65536\n" 14 | "5,25,625,390625\n" 15 | ; 16 | 17 | std::string path = unittest::TempPath(); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc("", rapidcsv::LabelParams(-1, -1), rapidcsv::SeparatorParams(',', false, false)); 22 | 23 | doc.SetRow(0, std::vector({ 2, 4 })); 24 | doc.SetRow(1, std::vector({ 3, 9, 81, 6561 })); 25 | doc.SetRow(2, std::vector({ 4, 16, 256, 65536 })); 26 | doc.SetRow(3, std::vector({ 5, 25, 625, 390625 })); 27 | 28 | doc.SetCell(2, 0, 16); 29 | doc.SetCell(3, 0, 256); 30 | 31 | doc.Save(path); 32 | 33 | std::string csvread = unittest::ReadFile(path); 34 | 35 | unittest::ExpectEqual(std::string, csvref, csvread); 36 | } 37 | catch (const std::exception& ex) 38 | { 39 | std::cout << ex.what() << std::endl; 40 | rv = 1; 41 | } 42 | 43 | unittest::DeleteFile(path); 44 | 45 | return rv; 46 | } 47 | -------------------------------------------------------------------------------- /tests/test032.cpp: -------------------------------------------------------------------------------- 1 | // test032.cpp - generate new document by column, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "2,4,16,256\n" 12 | "3,9,81,6561\n" 13 | "4,16,256,65536\n" 14 | "5,25,625,390625\n" 15 | ; 16 | 17 | std::string path = unittest::TempPath(); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc("", rapidcsv::LabelParams(-1, -1), rapidcsv::SeparatorParams(',', false, false)); 22 | 23 | doc.SetColumn(0, std::vector({ 2, 3 })); 24 | doc.SetColumn(1, std::vector({ 4, 9, 16, 25 })); 25 | doc.SetColumn(2, std::vector({ 16, 81, 256, 625 })); 26 | doc.SetColumn(3, std::vector({ 256, 6561, 65536, 390625 })); 27 | 28 | doc.SetCell(0, 2, 4); 29 | doc.SetCell(0, 3, 5); 30 | 31 | doc.Save(path); 32 | 33 | std::string csvread = unittest::ReadFile(path); 34 | 35 | unittest::ExpectEqual(std::string, csvref, csvread); 36 | } 37 | catch (const std::exception& ex) 38 | { 39 | std::cout << ex.what() << std::endl; 40 | rv = 1; 41 | } 42 | 43 | unittest::DeleteFile(path); 44 | 45 | return rv; 46 | } 47 | -------------------------------------------------------------------------------- /tests/test033.cpp: -------------------------------------------------------------------------------- 1 | // test033.cpp - generate new document by cell, no row/column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "3,9,81\n" 12 | "4,16,256\n" 13 | ; 14 | 15 | std::string path = unittest::TempPath(); 16 | 17 | try 18 | { 19 | rapidcsv::Document doc("", rapidcsv::LabelParams(-1, -1), rapidcsv::SeparatorParams(',', false, false)); 20 | 21 | doc.SetCell(0, 0, 3); 22 | doc.SetCell(1, 0, 9); 23 | doc.SetCell(2, 0, 81); 24 | 25 | doc.SetCell(0, 1, 4); 26 | doc.SetCell(1, 1, 16); 27 | doc.SetCell(2, 1, 256); 28 | 29 | doc.Save(path); 30 | 31 | std::string csvread = unittest::ReadFile(path); 32 | 33 | unittest::ExpectEqual(std::string, csvref, csvread); 34 | } 35 | catch (const std::exception& ex) 36 | { 37 | std::cout << ex.what() << std::endl; 38 | rv = 1; 39 | } 40 | 41 | unittest::DeleteFile(path); 42 | 43 | return rv; 44 | } 45 | -------------------------------------------------------------------------------- /tests/test034.cpp: -------------------------------------------------------------------------------- 1 | // test034.cpp - copy document 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | std::string pathcopy = unittest::TempPath(); 20 | 21 | try 22 | { 23 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 24 | 25 | rapidcsv::Document doccopy(doc); 26 | 27 | doccopy.Save(pathcopy); 28 | 29 | std::string csvread = unittest::ReadFile(pathcopy); 30 | 31 | unittest::ExpectEqual(std::string, csv, csvread); 32 | } 33 | catch (const std::exception& ex) 34 | { 35 | std::cout << ex.what() << std::endl; 36 | rv = 1; 37 | } 38 | 39 | unittest::DeleteFile(path); 40 | unittest::DeleteFile(pathcopy); 41 | 42 | return rv; 43 | } 44 | -------------------------------------------------------------------------------- /tests/test035.cpp: -------------------------------------------------------------------------------- 1 | // test035.cpp - custom conversion 2 | 3 | #include 4 | #include 5 | #include 6 | #include "unittest.h" 7 | 8 | // Data requested as ints to be converted to fixed-point two decimal numbers 9 | namespace rapidcsv 10 | { 11 | template<> 12 | void Converter::ToVal(const std::string& pStr, int& pVal) const 13 | { 14 | pVal = static_cast(roundf(100.0f * std::stof(pStr))); 15 | } 16 | 17 | template<> 18 | void Converter::ToStr(const int& pVal, std::string& pStr) const 19 | { 20 | std::ostringstream out; 21 | out << std::fixed << std::setprecision(2) << static_cast(pVal) / 100.0f; 22 | pStr = out.str(); 23 | } 24 | } 25 | 26 | int main() 27 | { 28 | int rv = 0; 29 | 30 | std::string csv = 31 | "1,10,100,1000\n" 32 | "0.1,0.01,0.001,0.006\n" 33 | ; 34 | 35 | std::string path = unittest::TempPath(); 36 | unittest::WriteFile(path, csv); 37 | 38 | try 39 | { 40 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 41 | 42 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 100); 43 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 1000); 44 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 10000); 45 | unittest::ExpectEqual(int, doc.GetCell(3, 0), 100000); 46 | 47 | unittest::ExpectEqual(int, doc.GetCell(0, 1), 10); 48 | unittest::ExpectEqual(int, doc.GetCell(1, 1), 1); 49 | unittest::ExpectEqual(int, doc.GetCell(2, 1), 0); 50 | unittest::ExpectEqual(int, doc.GetCell(3, 1), 1); 51 | 52 | doc.SetCell(0, 0, 12345); 53 | unittest::ExpectEqual(std::string, doc.GetCell(0, 0), "123.45"); 54 | } 55 | catch (const std::exception& ex) 56 | { 57 | std::cout << ex.what() << std::endl; 58 | rv = 1; 59 | } 60 | 61 | unittest::DeleteFile(path); 62 | 63 | return rv; 64 | } 65 | -------------------------------------------------------------------------------- /tests/test036.cpp: -------------------------------------------------------------------------------- 1 | // test036.cpp - supported datatypes 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "int,32767\n" 12 | "long,2147483647\n" 13 | "long long,9223372036854775807\n" 14 | "unsigned,65535\n" 15 | "unsigned long,4294967295\n" 16 | "unsigned long long,18446744073709551615\n" 17 | "float,3.3E38\n" 18 | "double,1.6E308\n" 19 | "long double,1.6E308\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 28 | 29 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 32767); 30 | unittest::ExpectEqual(long, doc.GetCell(1, 1), 2147483647); 31 | unittest::ExpectEqual(long long, doc.GetCell(1, 2), 9223372036854775807); 32 | 33 | unittest::ExpectEqual(unsigned, doc.GetCell(1, 3), 65535); 34 | unittest::ExpectEqual(unsigned long, doc.GetCell(1, 4), 4294967295); 35 | unittest::ExpectEqual(unsigned long long, doc.GetCell(1, 5), 18446744073709551615llu); 36 | 37 | float floatval = doc.GetCell(1, 6); 38 | unittest::ExpectTrue((floatval > 3.2E38) && (floatval < 3.4E38)); 39 | 40 | double doubleval = doc.GetCell(1, 7); 41 | unittest::ExpectTrue((doubleval > 1.5E308) && (doubleval < 1.7E308)); 42 | 43 | long double longdoubleval = doc.GetCell(1, 8); 44 | unittest::ExpectTrue((longdoubleval > 1.5E308) && (longdoubleval < 1.7E308)); 45 | } 46 | catch (const std::exception& ex) 47 | { 48 | std::cout << ex.what() << std::endl; 49 | rv = 1; 50 | } 51 | 52 | unittest::DeleteFile(path); 53 | 54 | return rv; 55 | } 56 | -------------------------------------------------------------------------------- /tests/test037.cpp: -------------------------------------------------------------------------------- 1 | // test037.cpp - double quote handling 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "1997,Ford,,Truck\n" 12 | " 1997, Ford, E350, Truck\n" 13 | " 1997 , Ford , E350 , Truck \n" 14 | "\"1997\",\"Ford\",\"E350\",\"Truck\"\n" 15 | "1997,Ford,E350,\"Super, luxurious truck\"\n" 16 | "1997,Ford,E350,\"Super, \"\"luxurious, fast\"\" truck\"\n" 17 | 18 | "Los Angeles,34°03'N,118°15'W,US\n" 19 | "New York City,40°42'46\"N,74°00'21\"W,US\n" 20 | "Paris,48°51'24\"N,2°21'03\"E,France\n" 21 | ; 22 | 23 | std::string path = unittest::TempPath(); 24 | unittest::WriteFile(path, csv); 25 | 26 | try 27 | { 28 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1)); 29 | 30 | unittest::ExpectEqual(std::string, doc.GetCell(0, 0), "1997"); 31 | unittest::ExpectEqual(std::string, doc.GetCell(1, 0), "Ford"); 32 | unittest::ExpectEqual(std::string, doc.GetCell(2, 0), ""); 33 | unittest::ExpectEqual(std::string, doc.GetCell(3, 0), "Truck"); 34 | 35 | unittest::ExpectEqual(std::string, doc.GetCell(0, 1), " 1997"); 36 | unittest::ExpectEqual(std::string, doc.GetCell(1, 1), " Ford"); 37 | unittest::ExpectEqual(std::string, doc.GetCell(2, 1), " E350"); 38 | unittest::ExpectEqual(std::string, doc.GetCell(3, 1), " Truck"); 39 | 40 | unittest::ExpectEqual(std::string, doc.GetCell(0, 2), " 1997 "); 41 | unittest::ExpectEqual(std::string, doc.GetCell(1, 2), " Ford "); 42 | unittest::ExpectEqual(std::string, doc.GetCell(2, 2), " E350 "); 43 | unittest::ExpectEqual(std::string, doc.GetCell(3, 2), " Truck "); 44 | 45 | unittest::ExpectEqual(std::string, doc.GetCell(0, 3), "1997"); 46 | unittest::ExpectEqual(std::string, doc.GetCell(1, 3), "Ford"); 47 | unittest::ExpectEqual(std::string, doc.GetCell(2, 3), "E350"); 48 | unittest::ExpectEqual(std::string, doc.GetCell(3, 3), "Truck"); 49 | 50 | unittest::ExpectEqual(std::string, doc.GetCell(0, 4), "1997"); 51 | unittest::ExpectEqual(std::string, doc.GetCell(1, 4), "Ford"); 52 | unittest::ExpectEqual(std::string, doc.GetCell(2, 4), "E350"); 53 | unittest::ExpectEqual(std::string, doc.GetCell(3, 4), "Super, luxurious truck"); 54 | 55 | unittest::ExpectEqual(std::string, doc.GetCell(0, 5), "1997"); 56 | unittest::ExpectEqual(std::string, doc.GetCell(1, 5), "Ford"); 57 | unittest::ExpectEqual(std::string, doc.GetCell(2, 5), "E350"); 58 | unittest::ExpectEqual(std::string, doc.GetCell(3, 5), "Super, \"luxurious, fast\" truck"); 59 | 60 | unittest::ExpectEqual(std::string, doc.GetCell(0, 6), "Los Angeles"); 61 | unittest::ExpectEqual(std::string, doc.GetCell(1, 6), "34°03'N"); 62 | unittest::ExpectEqual(std::string, doc.GetCell(2, 6), "118°15'W"); 63 | unittest::ExpectEqual(std::string, doc.GetCell(3, 6), "US"); 64 | 65 | unittest::ExpectEqual(std::string, doc.GetCell(0, 7), "New York City"); 66 | unittest::ExpectEqual(std::string, doc.GetCell(1, 7), "40°42'46\"N"); 67 | unittest::ExpectEqual(std::string, doc.GetCell(2, 7), "74°00'21\"W"); 68 | unittest::ExpectEqual(std::string, doc.GetCell(3, 7), "US"); 69 | 70 | unittest::ExpectEqual(std::string, doc.GetCell(0, 8), "Paris"); 71 | unittest::ExpectEqual(std::string, doc.GetCell(1, 8), "48°51'24\"N"); 72 | unittest::ExpectEqual(std::string, doc.GetCell(2, 8), "2°21'03\"E"); 73 | unittest::ExpectEqual(std::string, doc.GetCell(3, 8), "France"); 74 | } 75 | catch (const std::exception& ex) 76 | { 77 | std::cout << ex.what() << std::endl; 78 | rv = 1; 79 | } 80 | 81 | unittest::DeleteFile(path); 82 | 83 | return rv; 84 | } 85 | -------------------------------------------------------------------------------- /tests/test038.cpp: -------------------------------------------------------------------------------- 1 | // test038.cpp - read windows CR/LF linebreaks 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\r\n" 13 | "2,4,16,256\r\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | 23 | unittest::ExpectEqual(std::string, doc.GetCell(0, 0), "3"); 24 | unittest::ExpectEqual(std::string, doc.GetCell(1, 0), "9"); 25 | unittest::ExpectEqual(std::string, doc.GetCell(2, 0), "81"); 26 | 27 | unittest::ExpectEqual(std::string, doc.GetCell(0, 1), "4"); 28 | unittest::ExpectEqual(std::string, doc.GetCell(1, 1), "16"); 29 | unittest::ExpectEqual(std::string, doc.GetCell(2, 1), "256"); 30 | } 31 | catch (const std::exception& ex) 32 | { 33 | std::cout << ex.what() << std::endl; 34 | rv = 1; 35 | } 36 | 37 | unittest::DeleteFile(path); 38 | 39 | return rv; 40 | } 41 | -------------------------------------------------------------------------------- /tests/test039.cpp: -------------------------------------------------------------------------------- 1 | // test039.cpp - write windows CR/LF linebreaks 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\r\n" 12 | "1,3,9,81\r\n" 13 | "2,4,16,256\r\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | 23 | unittest::ExpectEqual(std::string, doc.GetCell(0, 0), "3"); 24 | unittest::ExpectEqual(std::string, doc.GetCell(1, 0), "9"); 25 | unittest::ExpectEqual(std::string, doc.GetCell(2, 0), "81"); 26 | 27 | unittest::ExpectEqual(std::string, doc.GetCell(0, 1), "4"); 28 | unittest::ExpectEqual(std::string, doc.GetCell(1, 1), "16"); 29 | unittest::ExpectEqual(std::string, doc.GetCell(2, 1), "256"); 30 | 31 | doc.Save(); 32 | 33 | std::string csvread = unittest::ReadFile(path); 34 | 35 | unittest::ExpectEqual(std::string, csv, csvread); 36 | } 37 | catch (const std::exception& ex) 38 | { 39 | std::cout << ex.what() << std::endl; 40 | rv = 1; 41 | } 42 | 43 | unittest::DeleteFile(path); 44 | 45 | return rv; 46 | } 47 | -------------------------------------------------------------------------------- /tests/test040.cpp: -------------------------------------------------------------------------------- 1 | // test040.cpp - multiple translation units, part 1 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int help_func(); 7 | 8 | int main() 9 | { 10 | int rv = 0; 11 | 12 | std::string csv = 13 | "-,A,B,C\n" 14 | "1,3,9,81\n" 15 | "2,4,16,256\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | unittest::WriteFile(path, csv); 20 | 21 | try 22 | { 23 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 24 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 25 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 26 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 27 | 28 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 29 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 30 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 31 | 32 | rv += help_func(); 33 | } 34 | catch (const std::exception& ex) 35 | { 36 | std::cout << ex.what() << std::endl; 37 | rv = 1; 38 | } 39 | 40 | unittest::DeleteFile(path); 41 | 42 | return rv; 43 | } 44 | -------------------------------------------------------------------------------- /tests/test040b.cpp: -------------------------------------------------------------------------------- 1 | // test040b.cpp - multiple translation units, part 2 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int help_func() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 23 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 24 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 25 | 26 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 27 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 28 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 29 | } 30 | catch (const std::exception& ex) 31 | { 32 | std::cout << ex.what() << std::endl; 33 | rv = 1; 34 | } 35 | 36 | unittest::DeleteFile(path); 37 | 38 | return rv; 39 | } 40 | -------------------------------------------------------------------------------- /tests/test041.cpp: -------------------------------------------------------------------------------- 1 | // test041.cpp - handling no linebreak at end of last line 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 23 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 24 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 25 | 26 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 27 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 28 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 29 | } 30 | catch (const std::exception& ex) 31 | { 32 | std::cout << ex.what() << std::endl; 33 | rv = 1; 34 | } 35 | 36 | unittest::DeleteFile(path); 37 | 38 | return rv; 39 | } 40 | -------------------------------------------------------------------------------- /tests/test042.cpp: -------------------------------------------------------------------------------- 1 | // test042.cpp - test GetColumnCount() and GetRowCount() 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv1 = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv1); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc1(path, rapidcsv::LabelParams(0, 0)); 22 | unittest::ExpectEqual(size_t, doc1.GetColumnCount(), 3); 23 | unittest::ExpectEqual(size_t, doc1.GetRowCount(), 2); 24 | 25 | rapidcsv::Document doc2(path, rapidcsv::LabelParams(-1, -1)); 26 | unittest::ExpectEqual(size_t, doc2.GetColumnCount(), 4); 27 | unittest::ExpectEqual(size_t, doc2.GetRowCount(), 3); 28 | 29 | // test column count when column labels after first row 30 | std::string csv2 = 31 | "Sep=,\n" 32 | "-,A,B,C\n" 33 | "1,3,9,81\n" 34 | "2,4,16,256\n" 35 | ; 36 | std::istringstream sstream2(csv2); 37 | rapidcsv::Document doc3(sstream2, rapidcsv::LabelParams(1, -1)); 38 | unittest::ExpectEqual(size_t, doc3.GetColumnCount(), 4); 39 | unittest::ExpectEqual(size_t, doc3.GetRowCount(), 2); 40 | } 41 | catch (const std::exception& ex) 42 | { 43 | std::cout << ex.what() << std::endl; 44 | rv = 1; 45 | } 46 | 47 | unittest::DeleteFile(path); 48 | 49 | return rv; 50 | } 51 | -------------------------------------------------------------------------------- /tests/test043.cpp: -------------------------------------------------------------------------------- 1 | // test043.cpp - read column and row values as char 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,a,b,c\n" 13 | "2,x,y,z\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | 23 | std::vector chars; 24 | 25 | chars = doc.GetColumn(0); 26 | unittest::ExpectEqual(size_t, chars.size(), 2); 27 | unittest::ExpectEqual(char, chars.at(0), 'a'); 28 | unittest::ExpectEqual(char, chars.at(1), 'x'); 29 | 30 | chars = doc.GetColumn("B"); 31 | unittest::ExpectEqual(size_t, chars.size(), 2); 32 | unittest::ExpectEqual(char, chars.at(0), 'b'); 33 | unittest::ExpectEqual(char, chars.at(1), 'y'); 34 | 35 | chars = doc.GetRow("2"); 36 | unittest::ExpectEqual(size_t, chars.size(), 3); 37 | unittest::ExpectEqual(char, chars.at(0), 'x'); 38 | unittest::ExpectEqual(char, chars.at(1), 'y'); 39 | unittest::ExpectEqual(char, chars.at(2), 'z'); 40 | } 41 | catch (const std::exception& ex) 42 | { 43 | std::cout << ex.what() << std::endl; 44 | rv = 1; 45 | } 46 | 47 | unittest::DeleteFile(path); 48 | 49 | return rv; 50 | } 51 | -------------------------------------------------------------------------------- /tests/test044.cpp: -------------------------------------------------------------------------------- 1 | // test044.cpp - set column values as char 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,A,B,C\n" 12 | "1,a,b,c\n" 13 | "2,x,y,z\n" 14 | ; 15 | 16 | std::string csv = 17 | "-,A,B,C\n" 18 | "1,0,0,0\n" 19 | "2,0,0,0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 28 | 29 | doc.SetColumn(0, std::vector({ 'a', 'x' })); 30 | doc.SetColumn(1, std::vector({ 'b', 'y' })); 31 | doc.SetColumn("C", std::vector({ 'c', 'z' })); 32 | 33 | doc.Save(); 34 | 35 | std::string csvread = unittest::ReadFile(path); 36 | 37 | unittest::ExpectEqual(std::string, csvref, csvread); 38 | } 39 | catch (const std::exception& ex) 40 | { 41 | std::cout << ex.what() << std::endl; 42 | rv = 1; 43 | } 44 | 45 | unittest::DeleteFile(path); 46 | 47 | return rv; 48 | } 49 | -------------------------------------------------------------------------------- /tests/test045.cpp: -------------------------------------------------------------------------------- 1 | // test045.cpp - read data with custom separator 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-;A;B;C\n" 12 | "1;3;9;81\n" 13 | "2;4;16;256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(';')); 22 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 23 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 24 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 25 | 26 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 27 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 28 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 29 | } 30 | catch (const std::exception& ex) 31 | { 32 | std::cout << ex.what() << std::endl; 33 | rv = 1; 34 | } 35 | 36 | unittest::DeleteFile(path); 37 | 38 | return rv; 39 | } 40 | -------------------------------------------------------------------------------- /tests/test046.cpp: -------------------------------------------------------------------------------- 1 | // test046.cpp - write data with custom separator 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-;A;B;C\n" 12 | "1;3;9;81\n" 13 | "2;4;16;256\n" 14 | ; 15 | 16 | std::string csv = 17 | "-;A;B;C\n" 18 | "1;0;0;0\n" 19 | "2;0;0;0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(';')); 28 | 29 | doc.SetCell(0, 0, 3); 30 | doc.SetCell(1, 0, 9); 31 | doc.SetCell(2, 0, 81); 32 | 33 | doc.SetCell("A", "2", "4"); 34 | doc.SetCell("B", "2", "16"); 35 | doc.SetCell("C", "2", "256"); 36 | 37 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 38 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 39 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 40 | 41 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 42 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 43 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 44 | 45 | doc.Save(); 46 | 47 | std::string csvread = unittest::ReadFile(path); 48 | 49 | unittest::ExpectEqual(std::string, csvref, csvread); 50 | } 51 | catch (const std::exception& ex) 52 | { 53 | std::cout << ex.what() << std::endl; 54 | rv = 1; 55 | } 56 | 57 | unittest::DeleteFile(path); 58 | 59 | return rv; 60 | } 61 | -------------------------------------------------------------------------------- /tests/test047.cpp: -------------------------------------------------------------------------------- 1 | // test047.cpp - exception on invalid conversion 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,,x,#\n" 13 | "2,,y,$\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | 23 | ExpectException(doc.GetCell(0, 0), std::invalid_argument); 24 | ExpectException(doc.GetCell(1, 0), std::invalid_argument); 25 | ExpectException(doc.GetCell(2, 0), std::invalid_argument); 26 | 27 | ExpectException(doc.GetCell(0, 1), std::invalid_argument); 28 | ExpectException(doc.GetCell(1, 1), std::invalid_argument); 29 | ExpectException(doc.GetCell(2, 1), std::invalid_argument); 30 | } 31 | catch (const std::exception& ex) 32 | { 33 | std::cout << ex.what() << std::endl; 34 | rv = 1; 35 | } 36 | 37 | unittest::DeleteFile(path); 38 | 39 | return rv; 40 | } 41 | -------------------------------------------------------------------------------- /tests/test048.cpp: -------------------------------------------------------------------------------- 1 | // test048.cpp - default conversion to default values 2 | 3 | #include 4 | #include 5 | #include "unittest.h" 6 | 7 | int main() 8 | { 9 | int rv = 0; 10 | 11 | std::string csv = 12 | "-,A,B,C\n" 13 | "1,,x,#\n" 14 | "2,,y,$\n" 15 | ; 16 | 17 | std::string path = unittest::TempPath(); 18 | unittest::WriteFile(path, csv); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(), 23 | rapidcsv::ConverterParams(true /* pHasDefaultConverter */)); 24 | 25 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 0); 26 | unittest::ExpectEqual(long long, doc.GetCell(1, 0), 0); 27 | unittest::ExpectEqual(unsigned int, doc.GetCell(2, 0), 0); 28 | 29 | unittest::ExpectTrue(std::isnan(doc.GetCell(0, 1))); 30 | unittest::ExpectTrue(std::isnan(doc.GetCell(1, 1))); 31 | unittest::ExpectTrue(std::isnan(doc.GetCell(2, 1))); 32 | } 33 | catch (const std::exception& ex) 34 | { 35 | std::cout << ex.what() << std::endl; 36 | rv = 1; 37 | } 38 | 39 | unittest::DeleteFile(path); 40 | 41 | return rv; 42 | } 43 | -------------------------------------------------------------------------------- /tests/test049.cpp: -------------------------------------------------------------------------------- 1 | // test049.cpp - default conversion to custom values 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,,x,#\n" 13 | "2,,y,$\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(), 22 | rapidcsv::ConverterParams(true /* pHasDefaultConverter */, 23 | 0.0 /* pDefaultFloat */, 24 | 1 /* pDefaultInteger */)); 25 | 26 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 1); 27 | unittest::ExpectEqual(long long, doc.GetCell(1, 0), 1); 28 | unittest::ExpectEqual(unsigned int, doc.GetCell(2, 0), 1); 29 | 30 | unittest::ExpectEqual(double, doc.GetCell(0, 1), 0.0); 31 | unittest::ExpectEqual(long double, doc.GetCell(1, 1), 0.0); 32 | unittest::ExpectEqual(float, doc.GetCell(2, 1), 0.0); 33 | } 34 | catch (const std::exception& ex) 35 | { 36 | std::cout << ex.what() << std::endl; 37 | rv = 1; 38 | } 39 | 40 | unittest::DeleteFile(path); 41 | 42 | return rv; 43 | } 44 | -------------------------------------------------------------------------------- /tests/test050.cpp: -------------------------------------------------------------------------------- 1 | // test050.cpp - read column header / label by index 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | unittest::ExpectEqual(std::string, doc.GetColumnName(0), "A"); 23 | unittest::ExpectEqual(std::string, doc.GetColumnName(1), "B"); 24 | unittest::ExpectEqual(std::string, doc.GetColumnName(2), "C"); 25 | ExpectException(doc.GetColumnName(3), std::out_of_range); 26 | 27 | rapidcsv::Document doc2(path, rapidcsv::LabelParams(-1, -1)); 28 | ExpectException(doc2.GetColumnName(0), std::out_of_range); 29 | 30 | rapidcsv::Document doc3(path, rapidcsv::LabelParams(0, -1)); 31 | unittest::ExpectEqual(std::string, doc3.GetColumnName(0), "-"); 32 | unittest::ExpectEqual(std::string, doc3.GetColumnName(1), "A"); 33 | unittest::ExpectEqual(std::string, doc3.GetColumnName(2), "B"); 34 | unittest::ExpectEqual(std::string, doc3.GetColumnName(3), "C"); 35 | ExpectException(doc3.GetColumnName(4), std::out_of_range); 36 | } 37 | catch (const std::exception& ex) 38 | { 39 | std::cout << ex.what() << std::endl; 40 | rv = 1; 41 | } 42 | 43 | unittest::DeleteFile(path); 44 | 45 | return rv; 46 | } 47 | -------------------------------------------------------------------------------- /tests/test051.cpp: -------------------------------------------------------------------------------- 1 | // test051.cpp - get column and row names 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | std::vector columnNames = doc.GetColumnNames(); 23 | unittest::ExpectEqual(size_t, columnNames.size(), 3); 24 | unittest::ExpectEqual(std::string, columnNames[0], "A"); 25 | unittest::ExpectEqual(std::string, columnNames[1], "B"); 26 | unittest::ExpectEqual(std::string, columnNames[2], "C"); 27 | 28 | std::vector rowNames = doc.GetRowNames(); 29 | unittest::ExpectEqual(size_t, rowNames.size(), 2); 30 | unittest::ExpectEqual(std::string, rowNames[0], "1"); 31 | unittest::ExpectEqual(std::string, rowNames[1], "2"); 32 | 33 | rapidcsv::Document doc2(path, rapidcsv::LabelParams(0, -1)); 34 | std::vector columnNames2 = doc2.GetColumnNames(); 35 | unittest::ExpectEqual(size_t, columnNames2.size(), 4); 36 | unittest::ExpectEqual(std::string, columnNames2[0], "-"); 37 | unittest::ExpectEqual(std::string, columnNames2[1], "A"); 38 | unittest::ExpectEqual(std::string, columnNames2[2], "B"); 39 | unittest::ExpectEqual(std::string, columnNames2[3], "C"); 40 | 41 | rapidcsv::Document doc3(path, rapidcsv::LabelParams(-1, 0)); 42 | std::vector rowNames2 = doc3.GetRowNames(); 43 | unittest::ExpectEqual(size_t, rowNames2.size(), 3); 44 | unittest::ExpectEqual(std::string, rowNames2[0], "-"); 45 | unittest::ExpectEqual(std::string, rowNames2[1], "1"); 46 | unittest::ExpectEqual(std::string, rowNames2[2], "2"); 47 | } 48 | catch (const std::exception& ex) 49 | { 50 | std::cout << ex.what() << std::endl; 51 | rv = 1; 52 | } 53 | 54 | unittest::DeleteFile(path); 55 | 56 | return rv; 57 | } 58 | -------------------------------------------------------------------------------- /tests/test052.cpp: -------------------------------------------------------------------------------- 1 | // test052.cpp - read numbers with scientific notation 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,1.2e10,2.00E-07,1e100\n" 13 | ; 14 | 15 | std::string path = unittest::TempPath(); 16 | unittest::WriteFile(path, csv); 17 | 18 | try 19 | { 20 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 21 | 22 | double eps1 = 1.0e7; 23 | double exp1 = 1.2e10; 24 | double val1 = doc.GetCell("A", "1"); 25 | unittest::ExpectTrue(fabs(val1 - exp1) < eps1); 26 | 27 | double eps2 = 1.0e-10; 28 | double exp2 = 2.00e-07; 29 | double val2 = doc.GetCell("B", "1"); 30 | unittest::ExpectTrue(fabs(val2 - exp2) < eps2); 31 | 32 | double eps3 = 1e97; 33 | double exp3 = 1e100; 34 | double val3 = doc.GetCell("C", "1"); 35 | unittest::ExpectTrue(fabs(val3 - exp3) < eps3); 36 | } 37 | catch (const std::exception& ex) 38 | { 39 | std::cout << ex.what() << std::endl; 40 | rv = 1; 41 | } 42 | 43 | unittest::DeleteFile(path); 44 | 45 | return rv; 46 | } 47 | -------------------------------------------------------------------------------- /tests/test053.cpp: -------------------------------------------------------------------------------- 1 | // test053.cpp - write numbers with scientific notation 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,A,B,C\n" 12 | "1,1.2e10,2.00E-07,1e100\n" 13 | ; 14 | 15 | std::string csv = 16 | "-,A,B,C\n" 17 | "1,0,0,0\n" 18 | ; 19 | 20 | std::string path = unittest::TempPath(); 21 | unittest::WriteFile(path, csv); 22 | 23 | try 24 | { 25 | rapidcsv::Document doc1(path, rapidcsv::LabelParams(0, 0)); 26 | 27 | doc1.SetCell("A", "1", 1.2e10); 28 | doc1.SetCell("B", "1", 2.00E-07); 29 | doc1.SetCell("C", "1", 1e100); 30 | 31 | doc1.Save(); 32 | 33 | rapidcsv::Document doc2(path, rapidcsv::LabelParams(0, 0)); 34 | 35 | double eps1 = 1.0e7; 36 | double exp1 = 1.2e10; 37 | double val1 = doc2.GetCell("A", "1"); 38 | unittest::ExpectTrue(fabs(val1 - exp1) < eps1); 39 | 40 | double eps2 = 1.0e-10; 41 | double exp2 = 2.00e-07; 42 | double val2 = doc2.GetCell("B", "1"); 43 | unittest::ExpectTrue(fabs(val2 - exp2) < eps2); 44 | 45 | double eps3 = 1e97; 46 | double exp3 = 1e100; 47 | double val3 = doc2.GetCell("C", "1"); 48 | unittest::ExpectTrue(fabs(val3 - exp3) < eps3); 49 | } 50 | catch (const std::exception& ex) 51 | { 52 | std::cout << ex.what() << std::endl; 53 | rv = 1; 54 | } 55 | 56 | unittest::DeleteFile(path); 57 | 58 | return rv; 59 | } 60 | -------------------------------------------------------------------------------- /tests/test054.cpp: -------------------------------------------------------------------------------- 1 | // test054.cpp - read from stream 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | // stream from file 22 | std::ifstream fstream; 23 | fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit); 24 | fstream.open(path, std::ios::binary | std::ios::ate); 25 | rapidcsv::Document doc1(fstream, rapidcsv::LabelParams(0, 0)); 26 | fstream.close(); 27 | 28 | unittest::ExpectEqual(int, doc1.GetCell(0, 0), 3); 29 | unittest::ExpectEqual(int, doc1.GetCell(1, 0), 9); 30 | unittest::ExpectEqual(int, doc1.GetCell(2, 0), 81); 31 | 32 | unittest::ExpectEqual(std::string, doc1.GetCell("A", "2"), "4"); 33 | unittest::ExpectEqual(std::string, doc1.GetCell("B", "2"), "16"); 34 | unittest::ExpectEqual(std::string, doc1.GetCell("C", "2"), "256"); 35 | 36 | // stream from string 37 | std::istringstream sstream(csv); 38 | rapidcsv::Document doc2(sstream, rapidcsv::LabelParams(0, 0)); 39 | 40 | unittest::ExpectEqual(int, doc2.GetCell(0, 0), 3); 41 | unittest::ExpectEqual(int, doc2.GetCell(1, 0), 9); 42 | unittest::ExpectEqual(int, doc2.GetCell(2, 0), 81); 43 | 44 | unittest::ExpectEqual(std::string, doc2.GetCell("A", "2"), "4"); 45 | unittest::ExpectEqual(std::string, doc2.GetCell("B", "2"), "16"); 46 | unittest::ExpectEqual(std::string, doc2.GetCell("C", "2"), "256"); 47 | } 48 | catch (const std::exception& ex) 49 | { 50 | std::cout << ex.what() << std::endl; 51 | rv = 1; 52 | } 53 | 54 | unittest::DeleteFile(path); 55 | 56 | return rv; 57 | } 58 | -------------------------------------------------------------------------------- /tests/test055.cpp: -------------------------------------------------------------------------------- 1 | // test055.cpp - write to stream 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | std::string outpath = unittest::TempPath(); 20 | 21 | try 22 | { 23 | // to file stream 24 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 25 | std::ofstream ostream; 26 | ostream.exceptions(std::ifstream::failbit | std::ifstream::badbit); 27 | ostream.open(outpath, std::ios::binary | std::ios::ate); 28 | doc.Save(ostream); 29 | ostream.close(); 30 | 31 | std::string csvread = unittest::ReadFile(outpath); 32 | unittest::ExpectEqual(std::string, csv, csvread); 33 | 34 | // to string stream 35 | std::ostringstream sstream; 36 | doc.Save(sstream); 37 | unittest::ExpectEqual(std::string, csv, sstream.str()); 38 | } 39 | catch (const std::exception& ex) 40 | { 41 | std::cout << ex.what() << std::endl; 42 | rv = 1; 43 | } 44 | 45 | unittest::DeleteFile(path); 46 | 47 | return rv; 48 | } 49 | -------------------------------------------------------------------------------- /tests/test056.cpp: -------------------------------------------------------------------------------- 1 | // test056.cpp - write cells containing separator character 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,\"3,8\",9,81\n" 13 | "2,4,16,\"256,8\"\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | std::string outpath = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 23 | doc.SetCell("C", "2", "256,8"); 24 | doc.Save(outpath); 25 | std::string csvread = unittest::ReadFile(outpath); 26 | unittest::ExpectEqual(std::string, csv, csvread); 27 | } 28 | catch (const std::exception& ex) 29 | { 30 | std::cout << ex.what() << std::endl; 31 | rv = 1; 32 | } 33 | 34 | unittest::DeleteFile(path); 35 | unittest::DeleteFile(outpath); 36 | 37 | return rv; 38 | } 39 | -------------------------------------------------------------------------------- /tests/test057.cpp: -------------------------------------------------------------------------------- 1 | // test057.cpp - read UTF-16 LE 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | const unsigned char u16le[] = 11 | { 12 | 0xff, 0xfe, 13 | 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 0x00, 14 | 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x33, 0x00, 0x2c, 0x00, 15 | 0x39, 0x00, 0x2c, 0x00, 0x38, 0x00, 0x31, 0x00, 0x0a, 0x00, 0x32, 0x00, 16 | 0x2c, 0x00, 0x34, 0x00, 0x2c, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2c, 0x00, 17 | 0x32, 0x00, 0x35, 0x00, 0x36, 0x00, 0x0a, 0x00 18 | }; 19 | const unsigned int u16le_len = 58; 20 | 21 | std::string csv(reinterpret_cast(u16le), u16le_len); 22 | // "-,A,B,C\n" 23 | // "1,3,9,81\n" 24 | // "2,4,16,256\n" 25 | 26 | std::string path = unittest::TempPath(); 27 | unittest::WriteFile(path, csv); 28 | 29 | try 30 | { 31 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 32 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 33 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 34 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 35 | 36 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 37 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 38 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 39 | } 40 | catch (const std::exception& ex) 41 | { 42 | std::cout << ex.what() << std::endl; 43 | rv = 1; 44 | } 45 | 46 | unittest::DeleteFile(path); 47 | 48 | return rv; 49 | } 50 | -------------------------------------------------------------------------------- /tests/test058.cpp: -------------------------------------------------------------------------------- 1 | // test058.cpp - read UTF-16 BE 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | const unsigned char u16be[] = 11 | { 12 | 0xfe, 0xff, 13 | 0x00, 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 14 | 0x00, 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x33, 0x00, 0x2c, 15 | 0x00, 0x39, 0x00, 0x2c, 0x00, 0x38, 0x00, 0x31, 0x00, 0x0a, 0x00, 0x32, 16 | 0x00, 0x2c, 0x00, 0x34, 0x00, 0x2c, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2c, 17 | 0x00, 0x32, 0x00, 0x35, 0x00, 0x36, 0x00, 0x0a 18 | }; 19 | const unsigned int u16be_len = 58; 20 | 21 | std::string csv(reinterpret_cast(u16be), u16be_len); 22 | // "-,A,B,C\n" 23 | // "1,3,9,81\n" 24 | // "2,4,16,256\n" 25 | 26 | std::string path = unittest::TempPath(); 27 | unittest::WriteFile(path, csv); 28 | 29 | try 30 | { 31 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 32 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 33 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 34 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 35 | 36 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 37 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 38 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 39 | } 40 | catch (const std::exception& ex) 41 | { 42 | std::cout << ex.what() << std::endl; 43 | rv = 1; 44 | } 45 | 46 | unittest::DeleteFile(path); 47 | 48 | return rv; 49 | } 50 | -------------------------------------------------------------------------------- /tests/test059.cpp: -------------------------------------------------------------------------------- 1 | // test059.cpp - write UTF-16 LE 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | const unsigned char refu16le[] = 11 | { 12 | 0xff, 0xfe, 13 | 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 0x00, 14 | 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x33, 0x00, 0x2c, 0x00, 15 | 0x39, 0x00, 0x2c, 0x00, 0x38, 0x00, 0x31, 0x00, 0x0a, 0x00, 0x32, 0x00, 16 | 0x2c, 0x00, 0x34, 0x00, 0x2c, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2c, 0x00, 17 | 0x32, 0x00, 0x35, 0x00, 0x36, 0x00, 0x0a, 0x00 18 | }; 19 | const unsigned int refu16le_len = 58; 20 | 21 | std::string csvref(reinterpret_cast(refu16le), refu16le_len); 22 | // "-,A,B,C\n" 23 | // "1,3,9,81\n" 24 | // "2,4,16,256\n" 25 | 26 | const unsigned char u16le[] = 27 | { 28 | 0xff, 0xfe, 29 | 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 0x00, 30 | 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x2c, 0x00, 31 | 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x0a, 0x00, 0x32, 0x00, 0x2c, 0x00, 32 | 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x0a, 0x00 33 | }; 34 | const unsigned int u16le_len = 50; 35 | 36 | std::string csv(reinterpret_cast(u16le), u16le_len); 37 | // "-,A,B,C\n" 38 | // "1,0,0,0\n" 39 | // "2,0,0,0\n" 40 | 41 | std::string path = unittest::TempPath(); 42 | unittest::WriteFile(path, csv); 43 | 44 | try 45 | { 46 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 47 | 48 | doc.SetCell(0, 0, 3); 49 | doc.SetCell(1, 0, 9); 50 | doc.SetCell(2, 0, 81); 51 | 52 | doc.SetCell("A", "2", "4"); 53 | doc.SetCell("B", "2", "16"); 54 | doc.SetCell("C", "2", "256"); 55 | 56 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 57 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 58 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 59 | 60 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 61 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 62 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 63 | 64 | doc.Save(); 65 | 66 | std::string csvread = unittest::ReadFile(path); 67 | 68 | unittest::ExpectEqual(std::string, csvref, csvread); 69 | } 70 | catch (const std::exception& ex) 71 | { 72 | std::cout << ex.what() << std::endl; 73 | rv = 1; 74 | } 75 | 76 | unittest::DeleteFile(path); 77 | 78 | return rv; 79 | } 80 | -------------------------------------------------------------------------------- /tests/test060.cpp: -------------------------------------------------------------------------------- 1 | // test060.cpp - write UTF-16 BE 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | const unsigned char refu16be[] = 11 | { 12 | 0xfe, 0xff, 13 | 0x00, 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 14 | 0x00, 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x33, 0x00, 0x2c, 15 | 0x00, 0x39, 0x00, 0x2c, 0x00, 0x38, 0x00, 0x31, 0x00, 0x0a, 0x00, 0x32, 16 | 0x00, 0x2c, 0x00, 0x34, 0x00, 0x2c, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2c, 17 | 0x00, 0x32, 0x00, 0x35, 0x00, 0x36, 0x00, 0x0a 18 | }; 19 | const unsigned int refu16be_len = 58; 20 | 21 | std::string csvref(reinterpret_cast(refu16be), refu16be_len); 22 | // "-,A,B,C\n" 23 | // "1,3,9,81\n" 24 | // "2,4,16,256\n" 25 | 26 | const unsigned char u16be[] = 27 | { 28 | 0xfe, 0xff, 29 | 0x00, 0x2d, 0x00, 0x2c, 0x00, 0x41, 0x00, 0x2c, 0x00, 0x42, 0x00, 0x2c, 30 | 0x00, 0x43, 0x00, 0x0a, 0x00, 0x31, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x2c, 31 | 0x00, 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x0a, 0x00, 0x32, 0x00, 0x2c, 32 | 0x00, 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x2c, 0x00, 0x30, 0x00, 0x0a 33 | }; 34 | const unsigned int u16be_len = 50; 35 | 36 | std::string csv(reinterpret_cast(u16be), u16be_len); 37 | // "-,A,B,C\n" 38 | // "1,0,0,0\n" 39 | // "2,0,0,0\n" 40 | 41 | std::string path = unittest::TempPath(); 42 | unittest::WriteFile(path, csv); 43 | 44 | try 45 | { 46 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 47 | 48 | doc.SetCell(0, 0, 3); 49 | doc.SetCell(1, 0, 9); 50 | doc.SetCell(2, 0, 81); 51 | 52 | doc.SetCell("A", "2", "4"); 53 | doc.SetCell("B", "2", "16"); 54 | doc.SetCell("C", "2", "256"); 55 | 56 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 57 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 58 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 59 | 60 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 61 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 62 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 63 | 64 | doc.Save(); 65 | 66 | std::string csvread = unittest::ReadFile(path); 67 | 68 | unittest::ExpectEqual(std::string, csvref, csvread); 69 | } 70 | catch (const std::exception& ex) 71 | { 72 | std::cout << ex.what() << std::endl; 73 | rv = 1; 74 | } 75 | 76 | unittest::DeleteFile(path); 77 | 78 | return rv; 79 | } 80 | -------------------------------------------------------------------------------- /tests/test061.cpp: -------------------------------------------------------------------------------- 1 | // test061.cpp - read trimmed cell values 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-, A,B , C \n" 12 | " 1,3 , 9 , 81\n" 13 | "2 ,4 , 16, 256 \n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', true)); 22 | unittest::ExpectEqual(std::string, doc.GetCell("A", "1"), "3"); 23 | unittest::ExpectEqual(std::string, doc.GetCell("B", "1"), "9"); 24 | unittest::ExpectEqual(std::string, doc.GetCell("C", "1"), "81"); 25 | 26 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 27 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 28 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 29 | } 30 | catch (const std::exception& ex) 31 | { 32 | std::cout << ex.what() << std::endl; 33 | rv = 1; 34 | } 35 | 36 | unittest::DeleteFile(path); 37 | 38 | return rv; 39 | } 40 | -------------------------------------------------------------------------------- /tests/test062.cpp: -------------------------------------------------------------------------------- 1 | // test062.cpp - read cell value by mixed name / index 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | unittest::ExpectEqual(int, doc.GetCell("A", 0), 3); 23 | unittest::ExpectEqual(int, doc.GetCell("B", 0), 9); 24 | unittest::ExpectEqual(int, doc.GetCell("C", 0), 81); 25 | 26 | unittest::ExpectEqual(std::string, doc.GetCell(0, "2"), "4"); 27 | unittest::ExpectEqual(std::string, doc.GetCell(1, "2"), "16"); 28 | unittest::ExpectEqual(std::string, doc.GetCell(2, "2"), "256"); 29 | } 30 | catch (const std::exception& ex) 31 | { 32 | std::cout << ex.what() << std::endl; 33 | rv = 1; 34 | } 35 | 36 | unittest::DeleteFile(path); 37 | 38 | return rv; 39 | } 40 | -------------------------------------------------------------------------------- /tests/test063.cpp: -------------------------------------------------------------------------------- 1 | // test063.cpp - custom conversion per call 2 | 3 | #include 4 | #include 5 | #include 6 | #include "unittest.h" 7 | 8 | // Conversion function for int data to be converted to fixed-point two decimal numbers 9 | void ToVal(const std::string& pStr, int& pVal) 10 | { 11 | pVal = static_cast(roundf(100.0f * std::stof(pStr))); 12 | } 13 | 14 | struct Struct 15 | { 16 | int val = 0; 17 | }; 18 | 19 | void ToStruct(const std::string& pStr, Struct& pVal) 20 | { 21 | pVal.val = static_cast(roundf(100.0f * std::stof(pStr))); 22 | } 23 | 24 | int main() 25 | { 26 | int rv = 0; 27 | 28 | std::string csv = 29 | "-,A,B,C\n" 30 | "1,1,10,100,1000\n" 31 | "2,0.1,0.01,0.001,0.006\n" 32 | ; 33 | 34 | std::string path = unittest::TempPath(); 35 | unittest::WriteFile(path, csv); 36 | 37 | try 38 | { 39 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 40 | 41 | // ToVal 42 | unittest::ExpectEqual(int, doc.GetCell(0, 0, ToVal), 100); 43 | unittest::ExpectEqual(int, doc.GetCell(1, "1", ToVal), 1000); 44 | unittest::ExpectEqual(int, doc.GetCell("A", 0, ToVal), 100); 45 | unittest::ExpectEqual(int, doc.GetCell("B", "1", ToVal), 1000); 46 | 47 | unittest::ExpectEqual(int, doc.GetRow(0, ToVal).at(0), 100); 48 | unittest::ExpectEqual(int, doc.GetRow("2", ToVal).at(0), 10); 49 | 50 | unittest::ExpectEqual(int, doc.GetColumn(0, ToVal).at(0), 100); 51 | unittest::ExpectEqual(int, doc.GetColumn("B", ToVal).at(0), 1000); 52 | 53 | // ToStruct 54 | unittest::ExpectEqual(int, doc.GetCell(0, 0, ToStruct).val, 100); 55 | unittest::ExpectEqual(int, doc.GetCell(1, "1", ToStruct).val, 1000); 56 | unittest::ExpectEqual(int, doc.GetCell("A", 0, ToStruct).val, 100); 57 | unittest::ExpectEqual(int, doc.GetCell("B", "1", ToStruct).val, 1000); 58 | 59 | unittest::ExpectEqual(int, doc.GetRow(0, ToStruct).at(0).val, 100); 60 | unittest::ExpectEqual(int, doc.GetRow("2", ToStruct).at(0).val, 10); 61 | 62 | unittest::ExpectEqual(int, doc.GetColumn(0, ToStruct).at(0).val, 100); 63 | unittest::ExpectEqual(int, doc.GetColumn("B", ToStruct).at(0).val, 1000); 64 | 65 | // Missing custom conversion function 66 | ExpectException(doc.GetColumn(0), rapidcsv::no_converter); 67 | ExpectExceptionMsg(doc.GetColumn(0), rapidcsv::no_converter, 68 | "unsupported conversion datatype"); 69 | } 70 | catch (const std::exception& ex) 71 | { 72 | std::cout << ex.what() << std::endl; 73 | rv = 1; 74 | } 75 | 76 | unittest::DeleteFile(path); 77 | 78 | return rv; 79 | } 80 | -------------------------------------------------------------------------------- /tests/test064.cpp: -------------------------------------------------------------------------------- 1 | // test064.cpp - linebreaks in quoted text 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | "text,\"quoted text\",\"quoted\ntext\nwith\nlinebreaks\",\"\"" 15 | ; 16 | 17 | std::string path = unittest::TempPath(); 18 | unittest::WriteFile(path, csv); 19 | 20 | try 21 | { 22 | rapidcsv::SeparatorParams seppar; 23 | seppar.mQuotedLinebreaks = true; 24 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1), seppar, rapidcsv::ConverterParams()); 25 | 26 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 4); 27 | unittest::ExpectEqual(size_t, doc.GetColumnCount(), 4); 28 | 29 | unittest::ExpectEqual(char, doc.GetCell(0, 0), '-'); 30 | unittest::ExpectEqual(char, doc.GetCell(1, 0), 'A'); 31 | unittest::ExpectEqual(char, doc.GetCell(2, 0), 'B'); 32 | unittest::ExpectEqual(char, doc.GetCell(3, 0), 'C'); 33 | 34 | unittest::ExpectEqual(int, doc.GetCell(0, 1), 1); 35 | unittest::ExpectEqual(int, doc.GetCell(1, 1), 3); 36 | unittest::ExpectEqual(int, doc.GetCell(2, 1), 9); 37 | unittest::ExpectEqual(int, doc.GetCell(3, 1), 81); 38 | 39 | unittest::ExpectEqual(unsigned int, doc.GetCell(0, 2), 2); 40 | unittest::ExpectEqual(unsigned int, doc.GetCell(1, 2), 4); 41 | unittest::ExpectEqual(unsigned int, doc.GetCell(2, 2), 16); 42 | unittest::ExpectEqual(unsigned int, doc.GetCell(3, 2), 256); 43 | 44 | unittest::ExpectEqual(std::string, doc.GetCell(0, 3), "text"); 45 | unittest::ExpectEqual(std::string, doc.GetCell(1, 3), "quoted text"); 46 | unittest::ExpectEqual(std::string, doc.GetCell(2, 3), "quoted\ntext\nwith\nlinebreaks"); 47 | unittest::ExpectEqual(std::string, doc.GetCell(3, 3), ""); 48 | } 49 | catch (const std::exception& ex) 50 | { 51 | std::cout << ex.what() << std::endl; 52 | rv = 1; 53 | } 54 | 55 | unittest::DeleteFile(path); 56 | 57 | return rv; 58 | } 59 | -------------------------------------------------------------------------------- /tests/test065.cpp: -------------------------------------------------------------------------------- 1 | // test065.cpp - row/column count with header index out of data size 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvEmpty = ""; 11 | 12 | std::string path = unittest::TempPath(); 13 | unittest::WriteFile(path, csvEmpty); 14 | 15 | try 16 | { 17 | // empty doc, column header index 0, no row header 18 | rapidcsv::Document doc1(path, rapidcsv::LabelParams(0, -1)); 19 | unittest::ExpectEqual(size_t, doc1.GetRowCount(), 0); 20 | unittest::ExpectEqual(size_t, doc1.GetColumnCount(), 0); 21 | 22 | // empty doc, row header index 0, no row header 23 | rapidcsv::Document doc2(path, rapidcsv::LabelParams(-1, 0)); 24 | unittest::ExpectEqual(size_t, doc2.GetRowCount(), 0); 25 | unittest::ExpectEqual(size_t, doc2.GetColumnCount(), 0); 26 | 27 | std::string csv = 28 | "-,A,B,C\n" 29 | "1,3,9,81\n" 30 | "2,4,16,256\n" 31 | ; 32 | 33 | // doc with three rows, column header index 10, no row header 34 | std::istringstream sstream3(csv); 35 | rapidcsv::Document doc3(sstream3, rapidcsv::LabelParams(10, -1)); 36 | unittest::ExpectEqual(size_t, doc3.GetRowCount(), 0); 37 | unittest::ExpectEqual(size_t, doc3.GetColumnCount(), 0); 38 | 39 | // doc with three rows, row header index 10, no column header 40 | std::istringstream sstream4(csv); 41 | rapidcsv::Document doc4(sstream4, rapidcsv::LabelParams(-1, 10)); 42 | unittest::ExpectEqual(size_t, doc4.GetRowCount(), 3); 43 | unittest::ExpectEqual(size_t, doc4.GetColumnCount(), 0); 44 | } 45 | catch (const std::exception& ex) 46 | { 47 | std::cout << ex.what() << std::endl; 48 | rv = 1; 49 | } 50 | 51 | unittest::DeleteFile(path); 52 | 53 | return rv; 54 | } 55 | -------------------------------------------------------------------------------- /tests/test066.cpp: -------------------------------------------------------------------------------- 1 | // test066.cpp - read UTF-8 BOM 2 | 3 | #include "rapidcsv.h" 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvWithBom = 11 | "\xef\xbb\xbfID\n" 12 | "1\n" 13 | ; 14 | 15 | std::string path = unittest::TempPath(); 16 | unittest::WriteFile(path, csvWithBom); 17 | 18 | try 19 | { 20 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, -1)); 21 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 1); 22 | unittest::ExpectEqual(std::string, doc.GetColumn("ID")[0], "1"); 23 | } 24 | catch (const std::exception& ex) 25 | { 26 | std::cout << ex.what() << std::endl; 27 | rv = 1; 28 | } 29 | 30 | unittest::DeleteFile(path); 31 | 32 | return rv; 33 | } 34 | -------------------------------------------------------------------------------- /tests/test067.cpp: -------------------------------------------------------------------------------- 1 | // test067.cpp - test automatic dequote enabled 2 | 3 | #include "rapidcsv.h" 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "\"col 1\"\n" 12 | "\"\"\n" 13 | "\" \"\n" 14 | "\"a b\"\n" 15 | "\"\"\"a b\"\"\"\n" 16 | "\" \"\"a\"\" \"\n" 17 | "\"a\nb\"\n" 18 | ; 19 | 20 | std::string csvreadref = 21 | "\"col 1\"\n" 22 | "\" \"\n" 23 | "\"a b\"\n" 24 | "\"\"\"a b\"\"\"\n" 25 | "\" \"\"a\"\" \"\n" 26 | "\"a\nb\"\n" 27 | ; 28 | 29 | std::string path = unittest::TempPath(); 30 | unittest::WriteFile(path, csv); 31 | 32 | try 33 | { 34 | // read 35 | { 36 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0 /* pColumnNameIdx */, -1 /* pRowNameIdx */), 37 | rapidcsv::SeparatorParams(',', false /* pTrim */, rapidcsv::sPlatformHasCR /* pHasCR */, 38 | true /* pQuotedLinebreaks */, true /* pAutoQuote */)); 39 | unittest::ExpectEqual(std::string, doc.GetCell("col 1", 0), ""); 40 | unittest::ExpectEqual(std::string, doc.GetCell("col 1", 1), " "); 41 | unittest::ExpectEqual(std::string, doc.GetCell("col 1", 2), "a b"); 42 | unittest::ExpectEqual(std::string, doc.GetCell("col 1", 3), "\"a b\""); 43 | unittest::ExpectEqual(std::string, doc.GetCell("col 1", 4), " \"a\" "); 44 | unittest::ExpectEqual(std::string, doc.GetCell("col 1", 5), "a\nb"); 45 | } 46 | 47 | // write 48 | { 49 | unittest::WriteFile(path, csvreadref); 50 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0 /* pColumnNameIdx */, -1 /* pRowNameIdx */), 51 | rapidcsv::SeparatorParams(',', false /* pTrim */, rapidcsv::sPlatformHasCR /* pHasCR */, 52 | true /* pQuotedLinebreaks */, true /* pAutoQuote */)); 53 | 54 | doc.Save(); 55 | const std::string& csvread = unittest::ReadFile(path); 56 | unittest::ExpectEqual(std::string, csvreadref, csvread); 57 | } 58 | } 59 | catch (const std::exception& ex) 60 | { 61 | std::cout << ex.what() << std::endl; 62 | rv = 1; 63 | } 64 | 65 | unittest::DeleteFile(path); 66 | 67 | return rv; 68 | } 69 | -------------------------------------------------------------------------------- /tests/test068.cpp: -------------------------------------------------------------------------------- 1 | // test068.cpp - test automatic dequote disabled 2 | 3 | #include "rapidcsv.h" 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "\"col 1\"\n" 12 | "\"\"\n" 13 | "\" \"\n" 14 | "\"a b\"\n" 15 | "\"\"\"a b\"\"\"\n" 16 | "\" \"\"a\"\" \"\n" 17 | ; 18 | 19 | std::string csvreadref = 20 | "\"col 1\"\n" 21 | "\" \"\n" 22 | "\"a b\"\n" 23 | "\"\"\"a b\"\"\"\n" 24 | "\" \"\"a\"\" \"\n" 25 | ; 26 | 27 | std::string path = unittest::TempPath(); 28 | unittest::WriteFile(path, csv); 29 | 30 | try 31 | { 32 | // read 33 | { 34 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0 /* pColumnNameIdx */, -1 /* pRowNameIdx */), 35 | rapidcsv::SeparatorParams(',', false /* pTrim */, rapidcsv::sPlatformHasCR /* pHasCR */, 36 | false /* pQuotedLinebreaks */, false /* pAutoQuote */)); 37 | unittest::ExpectEqual(std::string, doc.GetCell("\"col 1\"", 0), "\"\""); 38 | unittest::ExpectEqual(std::string, doc.GetCell("\"col 1\"", 1), "\" \""); 39 | unittest::ExpectEqual(std::string, doc.GetCell("\"col 1\"", 2), "\"a b\""); 40 | unittest::ExpectEqual(std::string, doc.GetCell("\"col 1\"", 3), "\"\"\"a b\"\"\""); 41 | unittest::ExpectEqual(std::string, doc.GetCell("\"col 1\"", 4), "\" \"\"a\"\" \""); 42 | } 43 | 44 | // write 45 | { 46 | unittest::WriteFile(path, csvreadref); 47 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0 /* pColumnNameIdx */, -1 /* pRowNameIdx */), 48 | rapidcsv::SeparatorParams(',', false /* pTrim */, rapidcsv::sPlatformHasCR /* pHasCR */, 49 | false /* pQuotedLinebreaks */, false /* pAutoQuote */)); 50 | 51 | doc.Save(); 52 | const std::string& csvread = unittest::ReadFile(path); 53 | unittest::ExpectEqual(std::string, csvreadref, csvread); 54 | } 55 | } 56 | catch (const std::exception& ex) 57 | { 58 | std::cout << ex.what() << std::endl; 59 | rv = 1; 60 | } 61 | 62 | unittest::DeleteFile(path); 63 | 64 | return rv; 65 | } 66 | -------------------------------------------------------------------------------- /tests/test069.cpp: -------------------------------------------------------------------------------- 1 | // test069.cpp - get row index, no row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path); 22 | 23 | unittest::ExpectEqual(int, doc.GetRowIdx("-"), -1); 24 | unittest::ExpectEqual(int, doc.GetRowIdx("1"), -1); 25 | unittest::ExpectEqual(int, doc.GetRowIdx("2"), -1); 26 | unittest::ExpectEqual(int, doc.GetRowIdx("3"), -1); 27 | } 28 | catch (const std::exception& ex) 29 | { 30 | std::cout << ex.what() << std::endl; 31 | rv = 1; 32 | } 33 | 34 | unittest::DeleteFile(path); 35 | 36 | return rv; 37 | } 38 | -------------------------------------------------------------------------------- /tests/test070.cpp: -------------------------------------------------------------------------------- 1 | // test070.cpp - get row index with column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | // Row Label 22 | // ↓ 23 | // -, A, B, C ← Column Label 24 | // 1, 3, 9, 81 25 | // 2, 4, 16, 256 26 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 27 | 28 | unittest::ExpectEqual(int, doc.GetRowIdx("-"), -1); 29 | unittest::ExpectEqual(int, doc.GetRowIdx("1"), 0); 30 | unittest::ExpectEqual(int, doc.GetRowIdx("2"), 1); 31 | unittest::ExpectEqual(int, doc.GetRowIdx("3"), -1); 32 | } 33 | catch (const std::exception& ex) 34 | { 35 | std::cout << ex.what() << std::endl; 36 | rv = 1; 37 | } 38 | 39 | unittest::DeleteFile(path); 40 | 41 | return rv; 42 | } 43 | -------------------------------------------------------------------------------- /tests/test071.cpp: -------------------------------------------------------------------------------- 1 | // test071.cpp - get row index, no column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | // No Column Label 22 | // Row Label 23 | // ↓ 24 | // -, A, B, C 25 | // 1, 3, 9, 81 26 | // 2, 4, 16, 256 27 | rapidcsv::Document doc2(path, rapidcsv::LabelParams(-1, 0)); 28 | 29 | unittest::ExpectEqual(int, doc2.GetRowIdx("-"), 0); 30 | unittest::ExpectEqual(int, doc2.GetRowIdx("1"), 1); 31 | unittest::ExpectEqual(int, doc2.GetRowIdx("2"), 2); 32 | unittest::ExpectEqual(int, doc2.GetRowIdx("3"), -1); 33 | } 34 | catch (const std::exception& ex) 35 | { 36 | std::cout << ex.what() << std::endl; 37 | rv = 1; 38 | } 39 | 40 | unittest::DeleteFile(path); 41 | 42 | return rv; 43 | } 44 | -------------------------------------------------------------------------------- /tests/test072.cpp: -------------------------------------------------------------------------------- 1 | // test072.cpp - get column index 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path); 22 | 23 | unittest::ExpectEqual(int, doc.GetColumnIdx("-"), 0); 24 | unittest::ExpectEqual(int, doc.GetColumnIdx("A"), 1); 25 | unittest::ExpectEqual(int, doc.GetColumnIdx("B"), 2); 26 | unittest::ExpectEqual(int, doc.GetColumnIdx("C"), 3); 27 | unittest::ExpectEqual(int, doc.GetColumnIdx("D"), -1); 28 | } 29 | catch (const std::exception& ex) 30 | { 31 | std::cout << ex.what() << std::endl; 32 | rv = 1; 33 | } 34 | 35 | unittest::DeleteFile(path); 36 | 37 | return rv; 38 | } 39 | -------------------------------------------------------------------------------- /tests/test073.cpp: -------------------------------------------------------------------------------- 1 | // test073.cpp - get column index, shift column name index 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(1)); 22 | 23 | unittest::ExpectEqual(int, doc.GetColumnIdx("-"), -1); 24 | unittest::ExpectEqual(int, doc.GetColumnIdx("A"), -1); 25 | unittest::ExpectEqual(int, doc.GetColumnIdx("B"), -1); 26 | unittest::ExpectEqual(int, doc.GetColumnIdx("C"), -1); 27 | unittest::ExpectEqual(int, doc.GetColumnIdx("D"), -1); 28 | 29 | unittest::ExpectEqual(int, doc.GetColumnIdx("1"), 0); 30 | unittest::ExpectEqual(int, doc.GetColumnIdx("3"), 1); 31 | unittest::ExpectEqual(int, doc.GetColumnIdx("9"), 2); 32 | unittest::ExpectEqual(int, doc.GetColumnIdx("81"), 3); 33 | unittest::ExpectEqual(int, doc.GetColumnIdx("91"), -1); 34 | } 35 | catch (const std::exception& ex) 36 | { 37 | std::cout << ex.what() << std::endl; 38 | rv = 1; 39 | } 40 | 41 | unittest::DeleteFile(path); 42 | 43 | return rv; 44 | } 45 | -------------------------------------------------------------------------------- /tests/test074.cpp: -------------------------------------------------------------------------------- 1 | // test074.cpp - generate new document by row labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | ",A,B,C,D\n" 12 | "0,2,4,16,256\n" 13 | "1,3,9,81,6561\n" 14 | "2,4,16,256,65536\n" 15 | "3,5,25,625,390625\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false)); 23 | 24 | doc.SetRowName(0, "0"); 25 | doc.SetRowName(1, "1"); 26 | doc.SetRowName(2, "2"); 27 | doc.SetRowName(3, "3"); 28 | 29 | doc.SetRow(0, std::vector({ 2, 4 })); 30 | doc.SetRow(1, std::vector({ 3, 9, 81, 6561 })); 31 | doc.SetRow(2, std::vector({ 4, 16, 256, 65536 })); 32 | doc.SetRow(3, std::vector({ 5, 25, 625, 390625 })); 33 | 34 | doc.SetCell(2, 0, 16); 35 | doc.SetCell(3, 0, 256); 36 | 37 | doc.SetColumnName(0, "A"); 38 | doc.SetColumnName(1, "B"); 39 | doc.SetColumnName(2, "C"); 40 | doc.SetColumnName(3, "D"); 41 | 42 | doc.Save(path); 43 | 44 | std::string csvread = unittest::ReadFile(path); 45 | 46 | unittest::ExpectEqual(std::string, csvref, csvread); 47 | } 48 | catch (const std::exception& ex) 49 | { 50 | std::cout << ex.what() << std::endl; 51 | rv = 1; 52 | } 53 | 54 | unittest::DeleteFile(path); 55 | 56 | return rv; 57 | } 58 | -------------------------------------------------------------------------------- /tests/test075.cpp: -------------------------------------------------------------------------------- 1 | // test075.cpp - generate new document by column labels 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | ",A,B,C,D\n" 12 | "0,2,4,16,256\n" 13 | "1,3,9,81,6561\n" 14 | "2,4,16,256,65536\n" 15 | "3,5,25,625,390625\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false)); 23 | 24 | doc.SetColumnName(0, "A"); 25 | doc.SetColumnName(1, "B"); 26 | doc.SetColumnName(2, "C"); 27 | doc.SetColumnName(3, "D"); 28 | 29 | doc.SetColumn(0, std::vector({ 2, 3 })); 30 | doc.SetColumn(1, std::vector({ 4, 9, 16, 25 })); 31 | doc.SetColumn(2, std::vector({ 16, 81, 256, 625 })); 32 | doc.SetColumn(3, std::vector({ 256, 6561, 65536, 390625 })); 33 | 34 | doc.SetCell(0, 2, 4); 35 | doc.SetCell(0, 3, 5); 36 | 37 | doc.SetRowName(0, "0"); 38 | doc.SetRowName(1, "1"); 39 | doc.SetRowName(2, "2"); 40 | doc.SetRowName(3, "3"); 41 | 42 | doc.Save(path); 43 | 44 | std::string csvread = unittest::ReadFile(path); 45 | 46 | unittest::ExpectEqual(std::string, csvref, csvread); 47 | } 48 | catch (const std::exception& ex) 49 | { 50 | std::cout << ex.what() << std::endl; 51 | rv = 1; 52 | } 53 | 54 | unittest::DeleteFile(path); 55 | 56 | return rv; 57 | } 58 | -------------------------------------------------------------------------------- /tests/test076.cpp: -------------------------------------------------------------------------------- 1 | // test076.cpp - Load from stream 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | // stream from file 22 | std::ifstream fstream; 23 | fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit); 24 | fstream.open(path, std::ios::binary | std::ios::ate); 25 | rapidcsv::Document doc1; 26 | doc1.Load(fstream, rapidcsv::LabelParams(0, 0)); 27 | fstream.close(); 28 | 29 | unittest::ExpectEqual(int, doc1.GetCell(0, 0), 3); 30 | unittest::ExpectEqual(int, doc1.GetCell(1, 0), 9); 31 | unittest::ExpectEqual(int, doc1.GetCell(2, 0), 81); 32 | 33 | unittest::ExpectEqual(std::string, doc1.GetCell("A", "2"), "4"); 34 | unittest::ExpectEqual(std::string, doc1.GetCell("B", "2"), "16"); 35 | unittest::ExpectEqual(std::string, doc1.GetCell("C", "2"), "256"); 36 | 37 | // stream from string 38 | std::istringstream sstream(csv); 39 | rapidcsv::Document doc2(""); 40 | doc2.Load(sstream, rapidcsv::LabelParams(0, 0)); 41 | 42 | unittest::ExpectEqual(int, doc2.GetCell(0, 0), 3); 43 | unittest::ExpectEqual(int, doc2.GetCell(1, 0), 9); 44 | unittest::ExpectEqual(int, doc2.GetCell(2, 0), 81); 45 | 46 | unittest::ExpectEqual(std::string, doc2.GetCell("A", "2"), "4"); 47 | unittest::ExpectEqual(std::string, doc2.GetCell("B", "2"), "16"); 48 | unittest::ExpectEqual(std::string, doc2.GetCell("C", "2"), "256"); 49 | } 50 | catch (const std::exception& ex) 51 | { 52 | std::cout << ex.what() << std::endl; 53 | rv = 1; 54 | } 55 | 56 | unittest::DeleteFile(path); 57 | 58 | return rv; 59 | } 60 | -------------------------------------------------------------------------------- /tests/test077.cpp: -------------------------------------------------------------------------------- 1 | // test077.cpp - copy constructor 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | rapidcsv::Document LoadDoc(const std::string& p_Path) 7 | { 8 | rapidcsv::Document doc = rapidcsv::Document(p_Path, rapidcsv::LabelParams(0, 0)); 9 | return doc; 10 | } 11 | 12 | int main() 13 | { 14 | int rv = 0; 15 | 16 | std::string csv = 17 | "-,A,B,C\n" 18 | "1,3,9,81\n" 19 | "2,4,16,256\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc1 = LoadDoc(path); 28 | unittest::ExpectEqual(int, doc1.GetCell(0, 0), 3); 29 | unittest::ExpectEqual(int, doc1.GetCell(1, 0), 9); 30 | unittest::ExpectEqual(int, doc1.GetCell(2, 0), 81); 31 | 32 | const rapidcsv::Document& doc2 = LoadDoc(path); 33 | unittest::ExpectEqual(std::string, doc2.GetCell("A", "2"), "4"); 34 | unittest::ExpectEqual(std::string, doc2.GetCell("B", "2"), "16"); 35 | unittest::ExpectEqual(std::string, doc2.GetCell("C", "2"), "256"); 36 | 37 | rapidcsv::Document doc3 = doc2; 38 | unittest::ExpectEqual(int, doc1.GetCell(0, 0), 3); 39 | unittest::ExpectEqual(int, doc1.GetCell(1, 0), 9); 40 | unittest::ExpectEqual(int, doc1.GetCell(2, 0), 81); 41 | } 42 | catch (const std::exception& ex) 43 | { 44 | std::cout << ex.what() << std::endl; 45 | rv = 1; 46 | } 47 | 48 | unittest::DeleteFile(path); 49 | 50 | return rv; 51 | } 52 | -------------------------------------------------------------------------------- /tests/test078.cpp: -------------------------------------------------------------------------------- 1 | // test078.cpp - include Windows.h before rapidcsv.h 2 | 3 | #if defined(_MSC_VER) 4 | #include 5 | #endif 6 | 7 | #include 8 | #include "unittest.h" 9 | 10 | int main() 11 | { 12 | int rv = 0; 13 | 14 | std::string csv = 15 | "-,A,B,C\n" 16 | "1,3,9,81\n" 17 | "2,4,16,256\n" 18 | ; 19 | 20 | std::string path = unittest::TempPath(); 21 | unittest::WriteFile(path, csv); 22 | 23 | try 24 | { 25 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 26 | 27 | // below functions should use all template functions 28 | unittest::ExpectEqual(int, doc.GetColumn(0).at(0), 3); 29 | unittest::ExpectEqual(int, doc.GetColumn("A").at(0), 3); 30 | 31 | doc.SetColumn(0, std::vector({ 4, 5 })); 32 | unittest::ExpectEqual(int, doc.GetColumn(0).at(0), 4); 33 | doc.SetColumn("A", std::vector({ 5, 6 })); 34 | unittest::ExpectEqual(int, doc.GetColumn("A").at(0), 5); 35 | 36 | doc.InsertColumn(0, std::vector({ 7, 8 }), "A2"); 37 | unittest::ExpectEqual(int, doc.GetColumn("A2").at(0), 7); 38 | 39 | unittest::ExpectEqual(int, doc.GetRow(0).at(0), 7); 40 | unittest::ExpectEqual(int, doc.GetRow("1").at(0), 7); 41 | 42 | doc.SetRow(0, std::vector({ 9, 3, 9, 81 })); 43 | unittest::ExpectEqual(int, doc.GetRow(0).at(0), 9); 44 | 45 | doc.SetRow("1", std::vector({ 9, 3, 9, 81 })); 46 | unittest::ExpectEqual(int, doc.GetRow("1").at(0), 9); 47 | 48 | doc.InsertRow(0, std::vector({ 1, 2, 3, 4 }), "1B"); 49 | unittest::ExpectEqual(int, doc.GetRow("1B").at(0), 1); 50 | 51 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 1); 52 | unittest::ExpectEqual(int, doc.GetCell("A2", "1B"), 1); 53 | unittest::ExpectEqual(int, doc.GetCell(0, "1B"), 1); 54 | unittest::ExpectEqual(int, doc.GetCell("A2", 0), 1); 55 | 56 | doc.SetCell(1, 1, 111); 57 | unittest::ExpectEqual(int, doc.GetCell(1, 1), 111); 58 | doc.SetCell("A", "2", 222); 59 | unittest::ExpectEqual(int, doc.GetCell("A", "2"), 222); 60 | } 61 | catch (const std::exception& ex) 62 | { 63 | std::cout << ex.what() << std::endl; 64 | rv = 1; 65 | } 66 | 67 | unittest::DeleteFile(path); 68 | 69 | return rv; 70 | } 71 | -------------------------------------------------------------------------------- /tests/test079.cpp: -------------------------------------------------------------------------------- 1 | // test079.cpp - perform multiple Load calls on single Document instance 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv1 = 11 | "A,B,C,D\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string csv2 = 17 | "A,B,C,D\n" 18 | "1,3,9,81\n" 19 | ; 20 | 21 | std::string csv3 = 22 | "A,B,C,D\n" 23 | "1,3,9,81\n" 24 | "2,4,16,256\n" 25 | "4,16,256,67840\n" 26 | ; 27 | 28 | std::string path = unittest::TempPath(); 29 | unittest::WriteFile(path, csv3); 30 | 31 | try 32 | { 33 | std::istringstream sstream1(csv1); 34 | rapidcsv::Document doc(sstream1); 35 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 2); 36 | 37 | std::istringstream sstream2(csv2); 38 | doc.Load(sstream2); 39 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 1); 40 | 41 | doc.Load(path); 42 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 3); 43 | } 44 | catch (const std::exception& ex) 45 | { 46 | std::cout << ex.what() << std::endl; 47 | rv = 1; 48 | } 49 | 50 | unittest::DeleteFile(path); 51 | 52 | return rv; 53 | } 54 | -------------------------------------------------------------------------------- /tests/test080.cpp: -------------------------------------------------------------------------------- 1 | // test080.cpp - test Clear 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "A,B,C,D\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path); 22 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 2); 23 | 24 | doc.Clear(); 25 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 0); 26 | } 27 | catch (const std::exception& ex) 28 | { 29 | std::cout << ex.what() << std::endl; 30 | rv = 1; 31 | } 32 | 33 | unittest::DeleteFile(path); 34 | 35 | return rv; 36 | } 37 | -------------------------------------------------------------------------------- /tests/test081.cpp: -------------------------------------------------------------------------------- 1 | // test081.cpp - generate new document with insert column 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | ",A,B,C,D\n" 12 | "0,2,4,16,256\n" 13 | "1,3,9,81,6561\n" 14 | "2,4,16,256,65536\n" 15 | "3,5,25,625,390625\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false)); 23 | 24 | doc.InsertColumn(0, std::vector({ 4, 9, 16, 25 }), "B"); 25 | doc.InsertColumn(0, std::vector({ 2, 3, 4, 5 }), "A"); 26 | 27 | doc.InsertColumn(2); 28 | doc.SetColumn(2, std::vector({ 16, 81, 256, 625 })); 29 | doc.SetColumnName(2, "C"); 30 | 31 | doc.InsertColumn(3, std::vector({ 256, 6561, 65536, 390625 }), "D"); 32 | 33 | std::vector ints = doc.GetColumn("B"); 34 | unittest::ExpectEqual(size_t, ints.size(), 4); 35 | unittest::ExpectEqual(int, ints.at(0), 4); 36 | unittest::ExpectEqual(int, ints.at(1), 9); 37 | 38 | doc.SetRowName(0, "0"); 39 | doc.SetRowName(1, "1"); 40 | doc.SetRowName(2, "2"); 41 | doc.SetRowName(3, "3"); 42 | 43 | doc.Save(path); 44 | 45 | std::string csvread = unittest::ReadFile(path); 46 | 47 | unittest::ExpectEqual(std::string, csvref, csvread); 48 | } 49 | catch (const std::exception& ex) 50 | { 51 | std::cout << ex.what() << std::endl; 52 | rv = 1; 53 | } 54 | 55 | unittest::DeleteFile(path); 56 | 57 | return rv; 58 | } 59 | -------------------------------------------------------------------------------- /tests/test082.cpp: -------------------------------------------------------------------------------- 1 | // test082.cpp - generate new document with insert row 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | ",A,B,C,D\n" 12 | "0,2,4,16,256\n" 13 | "1,3,9,81,6561\n" 14 | "2,4,16,256,65536\n" 15 | "3,5,25,625,390625\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | 20 | try 21 | { 22 | rapidcsv::Document doc("", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', false, false)); 23 | 24 | doc.InsertRow(0, std::vector({ 3, 9, 81, 6561 }), "1"); 25 | doc.InsertRow(0, std::vector({ 2, 4, 16, 256 }), "0"); 26 | 27 | doc.InsertRow(2); 28 | doc.SetRow(2, std::vector({ 4, 16, 256, 65536 })); 29 | doc.SetRowName(2, "2"); 30 | 31 | doc.InsertRow(3, std::vector({ 5, 25, 625, 390625 }), "3"); 32 | 33 | std::vector ints = doc.GetRow("1"); 34 | unittest::ExpectEqual(size_t, ints.size(), 4); 35 | unittest::ExpectEqual(int, ints.at(0), 3); 36 | unittest::ExpectEqual(int, ints.at(1), 9); 37 | 38 | doc.SetColumnName(0, "A"); 39 | doc.SetColumnName(1, "B"); 40 | doc.SetColumnName(2, "C"); 41 | doc.SetColumnName(3, "D"); 42 | 43 | doc.Save(path); 44 | 45 | std::string csvread = unittest::ReadFile(path); 46 | 47 | unittest::ExpectEqual(std::string, csvref, csvread); 48 | } 49 | catch (const std::exception& ex) 50 | { 51 | std::cout << ex.what() << std::endl; 52 | rv = 1; 53 | } 54 | 55 | unittest::DeleteFile(path); 56 | 57 | return rv; 58 | } 59 | -------------------------------------------------------------------------------- /tests/test083.cpp: -------------------------------------------------------------------------------- 1 | // test083.cpp - empty lines 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvEmptyLines = 11 | "\n" 12 | "-,A,B,C\n" 13 | "\n" 14 | "1,3,9,81\n" 15 | "2,4,16,256\n" 16 | "\n" 17 | ; 18 | 19 | std::string path = unittest::TempPath(); 20 | unittest::WriteFile(path, csvEmptyLines); 21 | try 22 | { 23 | rapidcsv::Document doc(path, rapidcsv::LabelParams(), rapidcsv::SeparatorParams(), 24 | rapidcsv::ConverterParams(), 25 | rapidcsv::LineReaderParams(false, '#', true)); 26 | unittest::ExpectEqual(size_t, doc.GetColumn("A").size(), 2); 27 | unittest::ExpectEqual(size_t, doc.GetColumn("B").size(), 2); 28 | unittest::ExpectEqual(size_t, doc.GetColumn("C").size(), 2); 29 | 30 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 1); 31 | unittest::ExpectEqual(int, doc.GetCell(1, 1), 4); 32 | } 33 | catch (const std::exception& ex) 34 | { 35 | std::cout << ex.what() << std::endl; 36 | rv = 1; 37 | } 38 | 39 | unittest::DeleteFile(path); 40 | 41 | return rv; 42 | } 43 | -------------------------------------------------------------------------------- /tests/test084.cpp: -------------------------------------------------------------------------------- 1 | // test084.cpp - comment lines 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvCommentLines = 11 | "/ comment line 1\n" 12 | "/ comment line 2\n" 13 | "-,A,B,C\n" 14 | "1,3,9,81\n" 15 | "2,4,16,256\n" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | unittest::WriteFile(path, csvCommentLines); 20 | try 21 | { 22 | rapidcsv::Document doc(path, rapidcsv::LabelParams(), rapidcsv::SeparatorParams(), 23 | rapidcsv::ConverterParams(), 24 | rapidcsv::LineReaderParams(true, '/')); 25 | unittest::ExpectEqual(size_t, doc.GetColumn("A").size(), 2); 26 | unittest::ExpectEqual(size_t, doc.GetColumn("B").size(), 2); 27 | unittest::ExpectEqual(size_t, doc.GetColumn("C").size(), 2); 28 | 29 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 1); 30 | unittest::ExpectEqual(int, doc.GetCell(1, 1), 4); 31 | } 32 | catch (const std::exception& ex) 33 | { 34 | std::cout << ex.what() << std::endl; 35 | rv = 1; 36 | } 37 | 38 | unittest::DeleteFile(path); 39 | 40 | return rv; 41 | } 42 | -------------------------------------------------------------------------------- /tests/test085.cpp: -------------------------------------------------------------------------------- 1 | // test085.cpp - read UTF-16 LE file 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | try 11 | { 12 | rapidcsv::Document doc("../tests/chi-utf16.csv", rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(';')); 13 | 14 | unittest::ExpectEqual(std::string, doc.GetCell("description", "0"), "等待同PLC的Profinet通讯"); 15 | unittest::ExpectEqual(std::string, doc.GetCell("description", "1"), "辅助关闭"); 16 | unittest::ExpectEqual(std::string, doc.GetCell("description", "2"), "Z1轴运行中转轮锁定"); 17 | 18 | unittest::ExpectEqual(std::string, doc.GetCell(0, 7), "设备不正常"); 19 | unittest::ExpectEqual(std::string, doc.GetCell(0, 8), "标准件校对：工装翻转补偿值不正确"); 20 | unittest::ExpectEqual(std::string, doc.GetCell(0, 39), "达到扭矩限制"); 21 | } 22 | catch (const std::exception& ex) 23 | { 24 | std::cout << ex.what() << std::endl; 25 | rv = 1; 26 | } 27 | 28 | return rv; 29 | } 30 | -------------------------------------------------------------------------------- /tests/test086.cpp: -------------------------------------------------------------------------------- 1 | // test086.cpp - exception message reading out-of-range column 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | 23 | unittest::ExpectEqual(std::string, doc.GetColumnName(0), "A"); 24 | unittest::ExpectEqual(std::string, doc.GetColumnName(1), "B"); 25 | unittest::ExpectEqual(std::string, doc.GetColumnName(2), "C"); 26 | 27 | ExpectExceptionMsg(doc.GetColumn(2), std::out_of_range, 28 | "requested column index 2 >= 2 (number of columns on row index 1)"); 29 | ExpectExceptionMsg(doc.GetColumn("C"), std::out_of_range, 30 | "requested column index 2 >= 2 (number of columns on row index 1)"); 31 | ExpectExceptionMsg(doc.GetColumn(3), std::out_of_range, 32 | "requested column index 3 >= 3 (number of columns on row index 0)"); 33 | } 34 | catch (const std::exception& ex) 35 | { 36 | std::cout << ex.what() << std::endl; 37 | rv = 1; 38 | } 39 | 40 | unittest::DeleteFile(path); 41 | 42 | return rv; 43 | } 44 | -------------------------------------------------------------------------------- /tests/test087.cpp: -------------------------------------------------------------------------------- 1 | // test087.cpp - numeric c locale 2 | 3 | #include 4 | #include 5 | #include "unittest.h" 6 | 7 | int main() 8 | { 9 | int rv = 0; 10 | 11 | std::string loc = "de_DE.UTF-8"; // uses comma (,) as decimal separator 12 | if (std::setlocale(LC_ALL, loc.c_str()) == nullptr) 13 | { 14 | std::cout << "locale " << loc << " not available, skipping test.\n"; 15 | // pass test for systems without locale present. for ci testing, make.sh 16 | // ensures that the necessary locale is installed. 17 | return 0; 18 | } 19 | 20 | std::string path = unittest::TempPath(); 21 | 22 | try 23 | { 24 | { 25 | std::string csv = 26 | "-;A;B;C\n" 27 | "1;1;10;100\n" 28 | "2;0,1;0,01;0,001\n" 29 | ; 30 | 31 | unittest::WriteFile(path, csv); 32 | 33 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), 34 | rapidcsv::SeparatorParams(';' /* pSeparator */)); 35 | unittest::ExpectEqual(float, doc.GetCell("A", "2"), 0.1f); 36 | unittest::ExpectEqual(float, doc.GetCell("B", "2"), 0.01f); 37 | unittest::ExpectEqual(float, doc.GetCell("C", "2"), 0.001f); 38 | } 39 | 40 | { 41 | std::string csv = 42 | "-,A,B,C\n" 43 | "1,1,10,100\n" 44 | "2,0.1,0.01,0.001\n" 45 | ; 46 | 47 | unittest::WriteFile(path, csv); 48 | 49 | rapidcsv::LabelParams labelParams(0, 0); 50 | rapidcsv::SeparatorParams separatorParams; 51 | rapidcsv::ConverterParams converterParams; 52 | converterParams.mNumericLocale = false; // do not honor numeric locale 53 | rapidcsv::Document doc(path, labelParams, separatorParams, converterParams); 54 | unittest::ExpectEqual(float, doc.GetCell("A", "2"), 0.1f); 55 | unittest::ExpectEqual(float, doc.GetCell("B", "2"), 0.01f); 56 | unittest::ExpectEqual(float, doc.GetCell("C", "2"), 0.001f); 57 | } 58 | } 59 | catch (const std::exception& ex) 60 | { 61 | std::cout << ex.what() << std::endl; 62 | rv = 1; 63 | } 64 | 65 | unittest::DeleteFile(path); 66 | 67 | return rv; 68 | } 69 | -------------------------------------------------------------------------------- /tests/test088.cpp: -------------------------------------------------------------------------------- 1 | // test088.cpp - test parsing of files larger than 64 KB 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | const std::string path = unittest::TempPath(); 11 | 12 | try 13 | { 14 | const int dataRows = 5000; 15 | 16 | // write test file 17 | { 18 | std::ofstream out(path); 19 | out << "Foo,Bar,Baz" << std::endl; 20 | for (int i = 0; i < dataRows; i++) 21 | { 22 | out << i << "," << i * 2 << "," << i * 3 << std::endl; 23 | } 24 | } 25 | 26 | // read using filename, check row count 27 | { 28 | rapidcsv::Document doc(path); 29 | unittest::ExpectEqual(size_t, doc.GetRowCount(), dataRows); 30 | } 31 | 32 | // read via non-binary ifstream, check row count 33 | { 34 | std::ifstream in(path); 35 | rapidcsv::Document doc(in); 36 | unittest::ExpectEqual(size_t, doc.GetRowCount(), dataRows); 37 | } 38 | 39 | // parse msft.csv using filename, sanity check certain values 40 | const size_t msftDataRows = 7804; 41 | const long long msftVolumeTopRow = 21705200; 42 | const long long msftVolumeBottomRow = 1031788800; 43 | const long long msftMinVolume = 2304000; 44 | const long long msftMaxVolume = 1031788800; 45 | 46 | { 47 | rapidcsv::Document doc("../tests/msft.csv"); 48 | std::vector close = doc.GetColumn("Close"); 49 | std::vector volume = doc.GetColumn("Volume"); 50 | unittest::ExpectEqual(size_t, doc.GetRowCount(), msftDataRows); 51 | unittest::ExpectEqual(size_t, close.size(), msftDataRows); 52 | unittest::ExpectEqual(size_t, volume.size(), msftDataRows); 53 | unittest::ExpectEqual(long long, volume.front(), msftVolumeTopRow); 54 | unittest::ExpectEqual(long long, volume.back(), msftVolumeBottomRow); 55 | const auto minMaxVolume = std::minmax_element(volume.begin(), volume.end()); 56 | unittest::ExpectEqual(long long, *minMaxVolume.first, msftMinVolume); 57 | unittest::ExpectEqual(long long, *minMaxVolume.second, msftMaxVolume); 58 | } 59 | 60 | // parse msft.csv via non-binary ifstream, sanity check certain values 61 | { 62 | std::ifstream in("../tests/msft.csv"); 63 | rapidcsv::Document doc(in); 64 | std::vector close = doc.GetColumn("Close"); 65 | std::vector volume = doc.GetColumn("Volume"); 66 | unittest::ExpectEqual(size_t, doc.GetRowCount(), msftDataRows); 67 | unittest::ExpectEqual(size_t, close.size(), msftDataRows); 68 | unittest::ExpectEqual(size_t, volume.size(), msftDataRows); 69 | unittest::ExpectEqual(long long, volume.front(), msftVolumeTopRow); 70 | unittest::ExpectEqual(long long, volume.back(), msftVolumeBottomRow); 71 | const auto minMaxVolume = std::minmax_element(volume.begin(), volume.end()); 72 | unittest::ExpectEqual(long long, *minMaxVolume.first, msftMinVolume); 73 | unittest::ExpectEqual(long long, *minMaxVolume.second, msftMaxVolume); 74 | } 75 | } 76 | catch (const std::exception& ex) 77 | { 78 | std::cout << ex.what() << std::endl; 79 | rv = 1; 80 | } 81 | 82 | unittest::DeleteFile(path); 83 | 84 | return rv; 85 | } 86 | -------------------------------------------------------------------------------- /tests/test089.cpp: -------------------------------------------------------------------------------- 1 | // test089.cpp - get data by label after delete column and row by label 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,B,D\n" 12 | "1,9,6561\n" 13 | "3,25,390625\n" 14 | ; 15 | 16 | std::string csv = 17 | "-,A,B,C,D\n" 18 | "0,2,4,16,256\n" 19 | "1,3,9,81,6561\n" 20 | "2,4,16,256,65536\n" 21 | "3,5,25,625,390625\n" 22 | ; 23 | 24 | std::string path = unittest::TempPath(); 25 | unittest::WriteFile(path, csv); 26 | 27 | try 28 | { 29 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 30 | 31 | doc.RemoveColumn("A"); 32 | doc.RemoveColumn("C"); 33 | 34 | std::vector ints; 35 | 36 | ints = doc.GetColumn("B"); 37 | unittest::ExpectEqual(size_t, ints.size(), 4); 38 | unittest::ExpectEqual(int, ints.at(0), 4); 39 | unittest::ExpectEqual(int, ints.at(1), 9); 40 | 41 | doc.RemoveRow("0"); 42 | doc.RemoveRow("2"); 43 | 44 | unittest::ExpectEqual(std::string, doc.GetCell("B", "1"), "9"); 45 | 46 | ints = doc.GetRow("1"); 47 | unittest::ExpectEqual(size_t, ints.size(), 2); 48 | unittest::ExpectEqual(int, ints.at(0), 9); 49 | unittest::ExpectEqual(int, ints.at(1), 6561); 50 | 51 | doc.Save(); 52 | 53 | std::string csvread = unittest::ReadFile(path); 54 | unittest::ExpectEqual(std::string, csvref, csvread); 55 | } 56 | catch (const std::exception& ex) 57 | { 58 | std::cout << ex.what() << std::endl; 59 | rv = 1; 60 | } 61 | 62 | unittest::DeleteFile(path); 63 | 64 | return rv; 65 | } 66 | -------------------------------------------------------------------------------- /tests/test090.cpp: -------------------------------------------------------------------------------- 1 | // test090.cpp - custom quote char handling 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "1997,Ford,,Truck\n" 12 | " 1997, Ford, E350, Truck\n" 13 | " 1997 , Ford , E350 , Truck \n" 14 | "'1997','Ford','E350','Truck'\n" 15 | "1997,Ford,E350,'Super, luxurious truck'\n" 16 | "1997,Ford,E350,'Super, ''luxurious, fast'' truck'\n" 17 | 18 | "Los Angeles,34°03'N,118°15'W,US\n" 19 | "New York City,40°42'46\"N,74°00'21\"W,US\n" 20 | "Paris,48°51'24\"N,2°21'03\"E,France\n" 21 | ; 22 | 23 | std::string path = unittest::TempPath(); 24 | unittest::WriteFile(path, csv); 25 | 26 | try 27 | { 28 | rapidcsv::SeparatorParams separatorParams; 29 | separatorParams.mQuoteChar = '\''; 30 | rapidcsv::Document doc(path, rapidcsv::LabelParams(-1, -1), separatorParams); 31 | 32 | unittest::ExpectEqual(std::string, doc.GetCell(0, 0), "1997"); 33 | unittest::ExpectEqual(std::string, doc.GetCell(1, 0), "Ford"); 34 | unittest::ExpectEqual(std::string, doc.GetCell(2, 0), ""); 35 | unittest::ExpectEqual(std::string, doc.GetCell(3, 0), "Truck"); 36 | 37 | unittest::ExpectEqual(std::string, doc.GetCell(0, 1), " 1997"); 38 | unittest::ExpectEqual(std::string, doc.GetCell(1, 1), " Ford"); 39 | unittest::ExpectEqual(std::string, doc.GetCell(2, 1), " E350"); 40 | unittest::ExpectEqual(std::string, doc.GetCell(3, 1), " Truck"); 41 | 42 | unittest::ExpectEqual(std::string, doc.GetCell(0, 2), " 1997 "); 43 | unittest::ExpectEqual(std::string, doc.GetCell(1, 2), " Ford "); 44 | unittest::ExpectEqual(std::string, doc.GetCell(2, 2), " E350 "); 45 | unittest::ExpectEqual(std::string, doc.GetCell(3, 2), " Truck "); 46 | 47 | unittest::ExpectEqual(std::string, doc.GetCell(0, 3), "1997"); 48 | unittest::ExpectEqual(std::string, doc.GetCell(1, 3), "Ford"); 49 | unittest::ExpectEqual(std::string, doc.GetCell(2, 3), "E350"); 50 | unittest::ExpectEqual(std::string, doc.GetCell(3, 3), "Truck"); 51 | 52 | unittest::ExpectEqual(std::string, doc.GetCell(0, 4), "1997"); 53 | unittest::ExpectEqual(std::string, doc.GetCell(1, 4), "Ford"); 54 | unittest::ExpectEqual(std::string, doc.GetCell(2, 4), "E350"); 55 | unittest::ExpectEqual(std::string, doc.GetCell(3, 4), "Super, luxurious truck"); 56 | 57 | unittest::ExpectEqual(std::string, doc.GetCell(0, 5), "1997"); 58 | unittest::ExpectEqual(std::string, doc.GetCell(1, 5), "Ford"); 59 | unittest::ExpectEqual(std::string, doc.GetCell(2, 5), "E350"); 60 | unittest::ExpectEqual(std::string, doc.GetCell(3, 5), "Super, 'luxurious, fast' truck"); 61 | 62 | unittest::ExpectEqual(std::string, doc.GetCell(0, 6), "Los Angeles"); 63 | unittest::ExpectEqual(std::string, doc.GetCell(1, 6), "34°03'N"); 64 | unittest::ExpectEqual(std::string, doc.GetCell(2, 6), "118°15'W"); 65 | unittest::ExpectEqual(std::string, doc.GetCell(3, 6), "US"); 66 | 67 | unittest::ExpectEqual(std::string, doc.GetCell(0, 7), "New York City"); 68 | unittest::ExpectEqual(std::string, doc.GetCell(1, 7), "40°42'46\"N"); 69 | unittest::ExpectEqual(std::string, doc.GetCell(2, 7), "74°00'21\"W"); 70 | unittest::ExpectEqual(std::string, doc.GetCell(3, 7), "US"); 71 | 72 | unittest::ExpectEqual(std::string, doc.GetCell(0, 8), "Paris"); 73 | unittest::ExpectEqual(std::string, doc.GetCell(1, 8), "48°51'24\"N"); 74 | unittest::ExpectEqual(std::string, doc.GetCell(2, 8), "2°21'03\"E"); 75 | unittest::ExpectEqual(std::string, doc.GetCell(3, 8), "France"); 76 | } 77 | catch (const std::exception& ex) 78 | { 79 | std::cout << ex.what() << std::endl; 80 | rv = 1; 81 | } 82 | 83 | unittest::DeleteFile(path); 84 | 85 | return rv; 86 | } 87 | -------------------------------------------------------------------------------- /tests/test091.cpp: -------------------------------------------------------------------------------- 1 | // test091.cpp - writing / reading high-precision floating point numbers 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C\n" 12 | "f,0,0,0\n" 13 | "d,0,0,0\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | const float f1 = 3.14159f; 22 | const float f2 = 3.1415926535f; 23 | const float f3 = 3.141592653589793f; 24 | const double d1 = 3.14159; 25 | const double d2 = 3.141592653589793; 26 | const double d3 = 3.14159265358979323846; 27 | 28 | { 29 | rapidcsv::Document doc1(path, rapidcsv::LabelParams(0, 0)); 30 | 31 | doc1.SetCell("A", "f", f1); 32 | doc1.SetCell("B", "f", f2); 33 | doc1.SetCell("C", "f", f3); 34 | 35 | doc1.SetCell("A", "d", d1); 36 | doc1.SetCell("B", "d", d2); 37 | doc1.SetCell("C", "d", d3); 38 | 39 | doc1.Save(); 40 | } 41 | 42 | { 43 | rapidcsv::Document doc2(path, rapidcsv::LabelParams(0, 0)); 44 | 45 | unittest::ExpectEqual(float, doc2.GetCell("A", "f"), f1); 46 | unittest::ExpectEqual(float, doc2.GetCell("B", "f"), f2); 47 | unittest::ExpectEqual(float, doc2.GetCell("C", "f"), f3); 48 | 49 | unittest::ExpectEqual(double, doc2.GetCell("A", "d"), d1); 50 | unittest::ExpectEqual(double, doc2.GetCell("B", "d"), d2); 51 | unittest::ExpectEqual(double, doc2.GetCell("C", "d"), d3); 52 | } 53 | } 54 | catch (const std::exception& ex) 55 | { 56 | std::cout << ex.what() << std::endl; 57 | rv = 1; 58 | } 59 | 60 | unittest::DeleteFile(path); 61 | 62 | return rv; 63 | } 64 | -------------------------------------------------------------------------------- /tests/test092.cpp: -------------------------------------------------------------------------------- 1 | // test092.cpp - numeric c++ locale 2 | 3 | #include 4 | #include 5 | #include "unittest.h" 6 | 7 | int main() 8 | { 9 | int rv = 0; 10 | 11 | std::string loc = "de_DE"; // uses comma (,) as decimal separator 12 | try 13 | { 14 | std::locale::global(std::locale(loc.c_str())); 15 | } 16 | catch (const std::exception& ex) 17 | { 18 | std::cout << "locale " << loc << " not available (" << ex.what() 19 | << "), skipping test.\n"; 20 | // pass test for systems without locale present. for ci testing, make.sh 21 | // ensures that the necessary locale is installed. 22 | return 0; 23 | } 24 | 25 | std::string path = unittest::TempPath(); 26 | 27 | try 28 | { 29 | { 30 | std::string csv = 31 | "-;A;B;C\n" 32 | "1;1;10;100\n" 33 | "2;0,1;0,01;0,001\n" 34 | ; 35 | 36 | unittest::WriteFile(path, csv); 37 | 38 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), 39 | rapidcsv::SeparatorParams(';' /* pSeparator */)); 40 | unittest::ExpectEqual(float, doc.GetCell("A", "2"), 0.1f); 41 | unittest::ExpectEqual(float, doc.GetCell("B", "2"), 0.01f); 42 | unittest::ExpectEqual(float, doc.GetCell("C", "2"), 0.001f); 43 | } 44 | 45 | { 46 | std::string csv = 47 | "-,A,B,C\n" 48 | "1,1,10,100\n" 49 | "2,0.1,0.01,0.001\n" 50 | ; 51 | 52 | unittest::WriteFile(path, csv); 53 | 54 | rapidcsv::LabelParams labelParams(0, 0); 55 | rapidcsv::SeparatorParams separatorParams; 56 | rapidcsv::ConverterParams converterParams; 57 | converterParams.mNumericLocale = false; // do not honor numeric locale 58 | rapidcsv::Document doc(path, labelParams, separatorParams, converterParams); 59 | unittest::ExpectEqual(float, doc.GetCell("A", "2"), 0.1f); 60 | unittest::ExpectEqual(float, doc.GetCell("B", "2"), 0.01f); 61 | unittest::ExpectEqual(float, doc.GetCell("C", "2"), 0.001f); 62 | } 63 | } 64 | catch (const std::exception& ex) 65 | { 66 | std::cout << ex.what() << std::endl; 67 | rv = 1; 68 | } 69 | 70 | unittest::DeleteFile(path); 71 | 72 | return rv; 73 | } 74 | -------------------------------------------------------------------------------- /tests/test093.cpp: -------------------------------------------------------------------------------- 1 | // test093.cpp - set cell values, no row labels, column labels offset, comments not ignored 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "# Comment line\n" 12 | "A,B,C\n" 13 | "3,9,81\n" 14 | "4,16,256\n" 15 | ; 16 | 17 | std::string csv = 18 | "# Comment line\n" 19 | "A,B,C\n" 20 | "3,9,81\n" 21 | "4,16,256\n" 22 | ; 23 | 24 | std::string path = unittest::TempPath(); 25 | unittest::WriteFile(path, csv); 26 | 27 | try 28 | { 29 | { 30 | rapidcsv::LabelParams labelParams; 31 | labelParams.mColumnNameIdx = 1; // line index 0 is comment 32 | labelParams.mRowNameIdx = -1; 33 | rapidcsv::SeparatorParams separatorParams; 34 | separatorParams.mAutoQuote = false; 35 | rapidcsv::Document doc(path, labelParams, separatorParams); 36 | 37 | doc.SetCell(0, 1, 4); 38 | 39 | doc.Save(); 40 | 41 | std::string csvread = unittest::ReadFile(path); 42 | 43 | unittest::ExpectEqual(std::string, csvref, csvread); 44 | } 45 | 46 | { 47 | rapidcsv::LabelParams labelParams; 48 | labelParams.mColumnNameIdx = 1; // line index 0 is comment 49 | labelParams.mRowNameIdx = -1; 50 | rapidcsv::SeparatorParams separatorParams; 51 | separatorParams.mAutoQuote = false; 52 | rapidcsv::Document doc(path, labelParams, separatorParams); 53 | 54 | doc.SetCell(1, 1, 16); 55 | 56 | doc.Save(); 57 | 58 | std::string csvread = unittest::ReadFile(path); 59 | 60 | unittest::ExpectEqual(std::string, csvref, csvread); 61 | } 62 | 63 | { 64 | rapidcsv::LabelParams labelParams; 65 | labelParams.mColumnNameIdx = 1; // line index 0 is comment 66 | labelParams.mRowNameIdx = -1; 67 | rapidcsv::SeparatorParams separatorParams; 68 | separatorParams.mAutoQuote = false; 69 | rapidcsv::Document doc(path, labelParams, separatorParams); 70 | 71 | doc.SetCell(2, 1, 256); 72 | 73 | doc.Save(); 74 | 75 | std::string csvread = unittest::ReadFile(path); 76 | 77 | unittest::ExpectEqual(std::string, csvref, csvread); 78 | } 79 | } 80 | catch (const std::exception& ex) 81 | { 82 | std::cout << ex.what() << std::endl; 83 | rv = 1; 84 | } 85 | 86 | unittest::DeleteFile(path); 87 | 88 | return rv; 89 | } 90 | -------------------------------------------------------------------------------- /tests/test094.cpp: -------------------------------------------------------------------------------- 1 | // test094.cpp - write UTF-8 BOM 2 | 3 | #include "rapidcsv.h" 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string origCsvWithBom = 11 | "\xef\xbb\xbfID\n" 12 | "1\n" 13 | ; 14 | 15 | std::string path = unittest::TempPath(); 16 | unittest::WriteFile(path, origCsvWithBom); 17 | 18 | try 19 | { 20 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, -1)); 21 | doc.Save(); 22 | 23 | std::string readCsvWithBom = unittest::ReadFile(path); 24 | unittest::ExpectEqual(std::string, origCsvWithBom, readCsvWithBom); 25 | } 26 | catch (const std::exception& ex) 27 | { 28 | std::cout << ex.what() << std::endl; 29 | rv = 1; 30 | } 31 | 32 | unittest::DeleteFile(path); 33 | 34 | return rv; 35 | } 36 | -------------------------------------------------------------------------------- /tests/test095.cpp: -------------------------------------------------------------------------------- 1 | // test095.cpp - set cell value by mixed name / index 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csvref = 11 | "-,A,B,C\n" 12 | "1,3,9,81\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string csv = 17 | "-,A,B,C\n" 18 | "1,0,0,0\n" 19 | "2,0,0,0\n" 20 | ; 21 | 22 | std::string path = unittest::TempPath(); 23 | unittest::WriteFile(path, csv); 24 | 25 | try 26 | { 27 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 28 | 29 | doc.SetCell("A", 0, 3); 30 | doc.SetCell("B", 0, 9); 31 | doc.SetCell("C", 0, 81); 32 | 33 | doc.SetCell(0, "2", "4"); 34 | doc.SetCell(1, "2", "16"); 35 | doc.SetCell(2, "2", "256"); 36 | 37 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 3); 38 | unittest::ExpectEqual(int, doc.GetCell(1, 0), 9); 39 | unittest::ExpectEqual(int, doc.GetCell(2, 0), 81); 40 | 41 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 42 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 43 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 44 | 45 | doc.Save(); 46 | 47 | std::string csvread = unittest::ReadFile(path); 48 | 49 | unittest::ExpectEqual(std::string, csvref, csvread); 50 | } 51 | catch (const std::exception& ex) 52 | { 53 | std::cout << ex.what() << std::endl; 54 | rv = 1; 55 | } 56 | 57 | unittest::DeleteFile(path); 58 | 59 | return rv; 60 | } 61 | -------------------------------------------------------------------------------- /tests/test096.cpp: -------------------------------------------------------------------------------- 1 | // test096.cpp - read trimmed quoted cell values 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-, A,B , C \n" 12 | " \"1\",\"3,\" , \"9,\" , \"81,\"\n" 13 | "\"2\" ,\"4\" , \"16\", \"256\" \n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0), rapidcsv::SeparatorParams(',', true)); 22 | unittest::ExpectEqual(std::string, doc.GetCell("A", "1"), "3,"); 23 | unittest::ExpectEqual(std::string, doc.GetCell("B", "1"), "9,"); 24 | unittest::ExpectEqual(std::string, doc.GetCell("C", "1"), "81,"); 25 | 26 | unittest::ExpectEqual(std::string, doc.GetCell("A", "2"), "4"); 27 | unittest::ExpectEqual(std::string, doc.GetCell("B", "2"), "16"); 28 | unittest::ExpectEqual(std::string, doc.GetCell("C", "2"), "256"); 29 | } 30 | catch (const std::exception& ex) 31 | { 32 | std::cout << ex.what() << std::endl; 33 | rv = 1; 34 | } 35 | 36 | unittest::DeleteFile(path); 37 | 38 | return rv; 39 | } 40 | -------------------------------------------------------------------------------- /tests/test097.cpp: -------------------------------------------------------------------------------- 1 | // test097.cpp - trailing comment line without linebreak 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "A,B,C\n" 12 | "1,3,9\n" 13 | "2,4,16\n" 14 | "# comment line 1\n" 15 | "# comment line 2" 16 | ; 17 | 18 | std::string path = unittest::TempPath(); 19 | unittest::WriteFile(path, csv); 20 | try 21 | { 22 | rapidcsv::Document doc(path, rapidcsv::LabelParams(), 23 | rapidcsv::SeparatorParams(), 24 | rapidcsv::ConverterParams(), 25 | rapidcsv::LineReaderParams(true /* pSkipCommentLines */)); 26 | 27 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 2); 28 | unittest::ExpectEqual(size_t, doc.GetColumn("A").size(), 2); 29 | unittest::ExpectEqual(int, doc.GetCell(0, 0), 1); 30 | unittest::ExpectEqual(int, doc.GetCell(0, 1), 2); 31 | } 32 | catch (const std::exception& ex) 33 | { 34 | std::cout << ex.what() << std::endl; 35 | rv = 1; 36 | } 37 | 38 | unittest::DeleteFile(path); 39 | 40 | return rv; 41 | } 42 | -------------------------------------------------------------------------------- /tests/test098.cpp: -------------------------------------------------------------------------------- 1 | // test098.cpp - empty cells 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | try 11 | { 12 | // empty cells without trailing linebreak on last line 13 | { 14 | std::string csv = 15 | ",\n" 16 | ",\n" 17 | "," 18 | ; 19 | 20 | std::istringstream sstream(csv); 21 | rapidcsv::Document doc(sstream, rapidcsv::LabelParams(-1, -1)); 22 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 3); 23 | unittest::ExpectEqual(size_t, doc.GetRow(0).size(), 2); 24 | unittest::ExpectEqual(size_t, doc.GetRow(1).size(), 2); 25 | unittest::ExpectEqual(size_t, doc.GetRow(2).size(), 2); 26 | unittest::ExpectEqual(std::string, doc.GetCell(1 /* col */, 0 /* row */), ""); 27 | unittest::ExpectEqual(std::string, doc.GetCell(1 /* col */, 1 /* row */), ""); 28 | unittest::ExpectEqual(std::string, doc.GetCell(1 /* col */, 2 /* row */), ""); 29 | } 30 | 31 | // empty cells with trailing linebreak on last line 32 | { 33 | std::string csv = 34 | ",\n" 35 | ",\n" 36 | ",\n" 37 | ; 38 | 39 | std::istringstream sstream(csv); 40 | rapidcsv::Document doc(sstream, rapidcsv::LabelParams(-1, -1)); 41 | unittest::ExpectEqual(size_t, doc.GetRowCount(), 3); 42 | unittest::ExpectEqual(size_t, doc.GetRow(0).size(), 2); 43 | unittest::ExpectEqual(size_t, doc.GetRow(1).size(), 2); 44 | unittest::ExpectEqual(size_t, doc.GetRow(2).size(), 2); 45 | unittest::ExpectEqual(std::string, doc.GetCell(0 /* col */, 0 /* row */), ""); 46 | unittest::ExpectEqual(std::string, doc.GetCell(0 /* col */, 1 /* row */), ""); 47 | unittest::ExpectEqual(std::string, doc.GetCell(0 /* col */, 2 /* row */), ""); 48 | } 49 | } 50 | catch (const std::exception& ex) 51 | { 52 | std::cout << ex.what() << std::endl; 53 | rv = 1; 54 | } 55 | 56 | return rv; 57 | } 58 | -------------------------------------------------------------------------------- /tests/test099.cpp: -------------------------------------------------------------------------------- 1 | // test099.cpp - exception message removing out-of-range column 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "-,A,B,C,D\n" 12 | "1,3,9,81,6561\n" 13 | "2,4,16,256\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path, rapidcsv::LabelParams(0, 0)); 22 | 23 | doc.RemoveColumn("A"); 24 | unittest::ExpectEqual(std::string, doc.GetColumnName(0), "B"); 25 | 26 | doc.RemoveColumn(0); 27 | unittest::ExpectEqual(std::string, doc.GetColumnName(0), "C"); 28 | 29 | // doc has columns C (0) and D (1) now, thus 2 is out of range. 30 | ExpectExceptionMsg(doc.RemoveColumn(2), std::out_of_range, 31 | "column out of range: 2 (on row 0)"); 32 | 33 | // column D, while existing, has not data on all rows, thus out of range. 34 | ExpectExceptionMsg(doc.RemoveColumn("D"), std::out_of_range, 35 | "column out of range: 1 (on row 2)"); 36 | } 37 | catch (const std::exception& ex) 38 | { 39 | std::cout << ex.what() << std::endl; 40 | rv = 1; 41 | } 42 | 43 | unittest::DeleteFile(path); 44 | 45 | return rv; 46 | } 47 | -------------------------------------------------------------------------------- /tests/test100.cpp: -------------------------------------------------------------------------------- 1 | // test100.cpp - exception message inserting column out-of-range 2 | 3 | #include 4 | #include "unittest.h" 5 | 6 | int main() 7 | { 8 | int rv = 0; 9 | 10 | std::string csv = 11 | "A,B,C\n" 12 | "1,3,9\n" 13 | "2,4,16\n" 14 | ; 15 | 16 | std::string path = unittest::TempPath(); 17 | unittest::WriteFile(path, csv); 18 | 19 | try 20 | { 21 | rapidcsv::Document doc(path); 22 | 23 | // insert at end (append) 24 | doc.InsertColumn(3, std::vector({ 1, 2 }), "D"); 25 | 26 | // insert at end (append) 27 | doc.InsertColumn(4, std::vector({ 3, 4 }), "E"); 28 | 29 | // insert out-of-range 30 | ExpectExceptionMsg(doc.InsertColumn(6, std::vector({ 5, 6 }), "F"), 31 | std::out_of_range, "column out of range: 6 (on row 0)"); 32 | } 33 | catch (const std::exception& ex) 34 | { 35 | std::cout << ex.what() << std::endl; 36 | rv = 1; 37 | } 38 | 39 | unittest::DeleteFile(path); 40 | 41 | return rv; 42 | } 43 | -------------------------------------------------------------------------------- /tests/unittest.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef _MSC_VER 4 | #include 5 | #else 6 | #include 7 | #endif 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | 15 | #define ExpectEqual(t, a, b) ExpectEqualFun(a, b, #a, #b, __FILE__, __LINE__) 16 | #define ExpectTrue(a) ExpectTrueFun(a, #a, __FILE__, __LINE__) 17 | 18 | // *INDENT-OFF* 19 | #define ExpectException(expr, excp) \ 20 | do \ 21 | { \ 22 | bool success = false; \ 23 | try \ 24 | { \ 25 | expr; \ 26 | } \ 27 | catch (const excp &) \ 28 | { \ 29 | success = true; \ 30 | } \ 31 | catch (const std::exception& ex) \ 32 | { \ 33 | std::stringstream ss; \ 34 | ss << unittest::detail::FileName(__FILE__) << ":" << std::to_string(__LINE__); \ 35 | ss << " ExpectException failed: unexpected exception '" << typeid(ex).name(); \ 36 | ss << "' thrown." << std::endl; \ 37 | throw std::runtime_error(ss.str()); \ 38 | } \ 39 | \ 40 | if (!success) \ 41 | { \ 42 | std::stringstream ss; \ 43 | ss << unittest::detail::FileName(__FILE__) << ":" << std::to_string(__LINE__); \ 44 | ss << " ExpectException failed: expected exception '" << #excp << "' not thrown."; \ 45 | ss << std::endl; \ 46 | throw std::runtime_error(ss.str()); \ 47 | } \ 48 | } \ 49 | while (0) 50 | 51 | 52 | #define ExpectExceptionMsg(expr, excp, msg) \ 53 | do \ 54 | { \ 55 | bool success = false; \ 56 | try \ 57 | { \ 58 | expr; \ 59 | } \ 60 | catch (const excp& ex) \ 61 | { \ 62 | if (std::string(ex.what()) == msg) \ 63 | { \ 64 | success = true; \ 65 | } \ 66 | else \ 67 | { \ 68 | std::stringstream ss; \ 69 | ss << unittest::detail::FileName(__FILE__) << ":" << std::to_string(__LINE__); \ 70 | ss << " ExpectExceptionMsg failed: unexpected exception message '" << ex.what(); \ 71 | ss << "'." << std::endl; \ 72 | throw std::runtime_error(ss.str()); \ 73 | } \ 74 | } \ 75 | catch (const std::exception& ex) \ 76 | { \ 77 | std::stringstream ss; \ 78 | ss << unittest::detail::FileName(__FILE__) << ":" << std::to_string(__LINE__); \ 79 | ss << " ExpectExceptionMsg failed: unexpected exception '" << typeid(ex).name(); \ 80 | ss << "' thrown." << std::endl; \ 81 | throw std::runtime_error(ss.str()); \ 82 | } \ 83 | \ 84 | if (!success) \ 85 | { \ 86 | std::stringstream ss; \ 87 | ss << unittest::detail::FileName(__FILE__) << ":" << std::to_string(__LINE__); \ 88 | ss << " ExpectException failed: expected exception '" << #excp << "' not thrown."; \ 89 | ss << std::endl; \ 90 | throw std::runtime_error(ss.str()); \ 91 | } \ 92 | } \ 93 | while (0) 94 | // *INDENT-ON* 95 | 96 | 97 | namespace unittest 98 | { 99 | namespace detail 100 | { 101 | inline std::string FileName(const std::string& pPath) 102 | { 103 | const std::size_t slash = pPath.rfind("/"); 104 | std::string name = (slash != std::string::npos) ? pPath.substr(slash + 1) : pPath; 105 | return name; 106 | } 107 | } 108 | 109 | inline std::string TempPath() 110 | { 111 | char name[] = "rapidcsvtest.XX" "XX" "XX"; 112 | #ifndef _MSC_VER 113 | int fd = mkstemp(name); 114 | close(fd); 115 | #else 116 | _mktemp_s(name, strlen(name) + 1); 117 | #endif 118 | return std::string(name); 119 | } 120 | 121 | inline void WriteFile(const std::string& pPath, const std::string& pData) 122 | { 123 | std::ofstream outfile; 124 | outfile.open(pPath, std::ifstream::out | std::ifstream::binary); 125 | outfile << pData; 126 | outfile.close(); 127 | } 128 | 129 | inline std::string ReadFile(const std::string& pPath) 130 | { 131 | std::ifstream infile; 132 | infile.open(pPath, std::ifstream::in | std::ifstream::binary); 133 | std::string data((std::istreambuf_iterator(infile)), std::istreambuf_iterator()); 134 | infile.close(); 135 | return data; 136 | } 137 | 138 | inline void DeleteFile(const std::string& pPath) 139 | { 140 | std::remove(pPath.c_str()); 141 | } 142 | 143 | template 144 | inline void ExpectEqualFun(T pTest, T pRef, const std::string& testName, 145 | const std::string& refName, const std::string& filePath, int lineNo) 146 | { 147 | if (pTest != pRef) 148 | { 149 | std::stringstream ss; 150 | ss << std::setprecision(std::numeric_limits::digits10 + 1); 151 | ss << detail::FileName(filePath) << ":" << std::to_string(lineNo); 152 | ss << " ExpectEqual failed: " << testName << " != " << refName << std::endl; 153 | ss << testName << " = '" << pTest << "'" << std::endl; 154 | ss << refName << " = '" << pRef << "'" << std::endl; 155 | 156 | throw std::runtime_error(ss.str()); 157 | } 158 | } 159 | 160 | inline void ExpectTrueFun(bool pTest, const std::string& testName, const std::string& filePath, 161 | int lineNo) 162 | { 163 | if (!pTest) 164 | { 165 | std::stringstream ss; 166 | ss << detail::FileName(filePath) << ":" << std::to_string(lineNo); 167 | ss << " ExpectTrue failed: " << testName << " == false" << std::endl; 168 | 169 | throw std::runtime_error(ss.str()); 170 | } 171 | } 172 | } 173 | -------------------------------------------------------------------------------- /winmake.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | 3 | mkdir build-debug 4 | cd build-debug || goto :error 5 | cmake -DRAPIDCSV_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug .. || goto :error 6 | cmake --build . --config Debug -- /m /nologo /verbosity:quiet || goto :error 7 | ctest -C Debug --output-on-failure || goto :error 8 | cd .. || goto :error 9 | 10 | mkdir build-release 11 | cd build-release || goto :error 12 | cmake -DRAPIDCSV_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Release .. || goto :error 13 | cmake --build . --config Release -- /m /nologo /verbosity:quiet || goto :error 14 | ctest -C Release --verbose || goto :error 15 | cd .. || goto :error 16 | 17 | goto :EOF 18 | 19 | :error 20 | echo Failed with error #%errorlevel%. 21 | exit /b %errorlevel% 22 | --------------------------------------------------------------------------------