From 9d4829ab1eb624c91c2e5d3f07697f25af19733c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Rombauts?= Date: Fri, 20 Mar 2015 13:05:35 +0100 Subject: [PATCH] Cleanup and improvement to build script - no googletest on appveyor as cloning this submodule does not wordk --- .travis.yml | 13 +- CMakeLists.txt | 19 +- README.md | 506 ++++++++++++++++++++++++------------------------- appveyor.yml | 10 +- build.bat | 12 +- build.sh | 9 +- 6 files changed, 290 insertions(+), 279 deletions(-) diff --git a/.travis.yml b/.travis.yml index f0b453f..05738dc 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,4 @@ -# Copyright (c) 2012-2015 Sébastien Rombauts (sebastien.rombauts@gmail.com) +# Copyright (c) 2012-2015 Sebastien Rombauts (sebastien.rombauts@gmail.com) language: cpp @@ -10,15 +10,16 @@ compiler: before_install: - sudo apt-get update -qq - sudo apt-get install -qq cppcheck - + # scripts to run before build # using a symbolic link to get the "make test" to work as if launched from the root directorys before_script: - mkdir build - cd build - - cmake -DSQLITECPP_RUN_CPPLINT=ON -DSQLITECPP_RUN_CPPCHECK=ON -DSQLITECPP_BUILD_EXAMPLES=ON -DSQLITECPP_BUILD_TESTS=ON .. + - cmake -DSQLITECPP_BUILD_EXAMPLES=ON -DSQLITECPP_BUILD_TESTS=ON -DSQLITECPP_RUN_DOXYGEN=OFF .. - ln -s ../examples examples -# build and run tests -script: make && ctest --output-on-failure - +# build examples, and run tests (ie make & make test) +script: + - cmake --build . + - ctest --output-on-failure diff --git a/CMakeLists.txt b/CMakeLists.txt index 33ab294..0a983be 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,5 @@ -IF(BIICODE) +if (BIICODE) + include(${CMAKE_HOME_DIRECTORY}/biicode.cmake) # Initializes block variables INIT_BIICODE_BLOCK() @@ -13,8 +14,9 @@ IF(BIICODE) ENDIF() ENDIF() -ELSE() - # Main CMake file for compiling the library itself, examples and tests. +else (BIICODE) + +# Main CMake file for compiling the library itself, examples and tests. # # Copyright (c) 2012-2015 Sebastien Rombauts (sebastien.rombauts@gmail.com) # @@ -121,6 +123,8 @@ source_group(doc FILES ${SQLITECPP_DOC}) # list of script files of the library set(SQLITECPP_SCRIPT .travis.yml + appveyor.yml + biicode.conf build.bat build.sh cpplint.py @@ -154,7 +158,7 @@ endif (WIN32) # Optional additional targets: -option(SQLITECPP_RUN_CPPLINT "Run cpplint.py tool for Google C++ StyleGuide." OFF) +option(SQLITECPP_RUN_CPPLINT "Run cpplint.py tool for Google C++ StyleGuide." ON) if (SQLITECPP_RUN_CPPLINT) # add a cpplint target to the "all" target add_custom_target(SQLiteCpp_cpplint @@ -165,7 +169,7 @@ else (SQLITECPP_RUN_CPPLINT) message(STATUS "SQLITECPP_RUN_CPPLINT OFF") endif (SQLITECPP_RUN_CPPLINT) -option(SQLITECPP_RUN_CPPCHECK "Run cppcheck C++ static analysis tool." OFF) +option(SQLITECPP_RUN_CPPCHECK "Run cppcheck C++ static analysis tool." ON) if (SQLITECPP_RUN_CPPCHECK) find_program(CPPCHECK_EXECUTABLE NAMES cppcheck) if (CPPCHECK_EXECUTABLE) @@ -181,7 +185,7 @@ else (SQLITECPP_RUN_CPPCHECK) message(STATUS "SQLITECPP_RUN_CPPCHECK OFF") endif (SQLITECPP_RUN_CPPCHECK) -option(SQLITECPP_RUN_DOXYGEN "Run Doxygen C++ documentation tool." OFF) +option(SQLITECPP_RUN_DOXYGEN "Run Doxygen C++ documentation tool." ON) if (SQLITECPP_RUN_DOXYGEN) find_package(Doxygen) if (DOXYGEN_FOUND) @@ -234,4 +238,5 @@ if (SQLITECPP_BUILD_TESTS) else (SQLITECPP_BUILD_TESTS) message(STATUS "SQLITECPP_BUILD_TESTS OFF") endif (SQLITECPP_BUILD_TESTS) -ENDIF() + +endif (BIICODE) diff --git a/README.md b/README.md index 9253f01..93f6050 100644 --- a/README.md +++ b/README.md @@ -1,253 +1,253 @@ -SQLiteC++ ---------- - -![SQLiteCpp build status](https://api.travis-ci.org/SRombauts/SQLiteCpp.png "SQLiteCpp build status") - -SQLiteC++ (SQLiteCpp) is a smart and easy to use C++ SQLite3 wrapper. - -See SQLiteC++ website http://srombauts.github.com/SQLiteCpp on GitHub. - -Keywords: sqlite, sqlite3, C, library, wrapper C++ - -### About SQLite: - -SQLite is a library that implements a serverless transactional SQL database engine. -It is the most widely deployed SQL database engine in the world. -The source code for SQLite is in the public domain. -http://www.sqlite.org/about.html - -### About SQLiteC++: - -SQLiteC++ offers an encapsulation arround the native C APIs of sqlite, -with a few intuitive and well documented C++ class. - -### The goals of SQLiteC++ are: - -- to offer the best of existing simple C++ SQLite wrappers -- to be elegantly written with good C++ design, STL, exceptions and RAII idiom -- to keep dependencies to a minimum (STL and SQLite3) -- to be portable -- to be light and fast -- to be thread-safe only as much as SQLite "Multi-thread" mode (see below) -- to have a good unit test coverage -- to use API names sticking with those of the SQLite library -- to be well documented with Doxygen tags, and with some good examples -- to be well maintained -- to use a permissive MIT license, similar to BSD or Boost, for proprietary/commercial usage - -It is designed using the Resource Acquisition Is Initialization (RAII) idom -(see http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization), -and throwing exceptions in case of SQLite errors (exept in destructors, -where assert() are used instead). -Each SQLiteC++ object must be constructed with a valid SQLite database connection, -and then is always valid until destroyed. - -### Supported platforms: - -Developements and tests are done under the following OSs: -- Debian 7 -- Ubuntu 12.10 -- Windows XP/7/8 -And following IDEs/Compilers -- GCC 4.7.2 with a provided Makefile -- Eclipse CDT under Linux, using the provided Makefile -- Visual Studio Express 2008/2010/2012/2013 for testing compatibility purpose - -### Dependencies - -- a STL implementation (even an old one, like the one provided with VC6 should work) -- exception support (the class Exception inherit from std::runtime_error) -- the SQLite library, either by linking to it dynamicaly or staticaly (install the libsqlite3-dev package under Debian/Ubuntu/Mint Linux), - or by adding its source file in your project code base (source code provided in src/sqlite3 for Windows), - with the SQLITE_ENABLE_COLUMN_METADATA macro defined (see http://www.sqlite.org/compile.html#enable_column_metadata). - -### Installation - -To use this wrappers, you need to add the 10 SQLiteC++ source files from the src/ directory -in your project code base, and compile/link against the sqlite library. - -The easiest way to do this is to add the wrapper as a library. -The proper "CMakeLists.txt" file defining the static library is provided in the src/ subdirectory, -so you simply have to add_directory(SQLiteCpp/src) to you main CMakeLists.txt -and link to the "SQLiteCpp" wrapper library. -Thus this SQLiteCpp repository can directly be used as a Git submoldule. - -Under Debian/Ubuntu/Mint Linux, install the libsqlite3-dev package. - -### Building the examples: - -#### CMake and test -A CMake configuration file is also provided for multiplatform support and testing. - -Typical generic build (see also "build.bat" or "./build.sh"): - -```bash -mkdir build -cd build -cmake .. # cmake .. -G "Visual Studio 10" # for Visual Studio 2010 -cmake --build . # make -ctest . # make test -``` - -Generating the Linux Makefile, building in Debug and executing the tests: - -```bash -mkdir Debug -cd Debug -cmake .. -DCMAKE_BUILD_TYPE=Debug -cmake --build . # make -ln -s ../examples examples -ctest . # make test -``` - -#### Troubleshooting - -Under Linux, if you get muliple linker errors like "undefined reference to sqlite3_xxx", -it's that you lack the "sqlite3" library: install the libsqlite3-dev package. - -If you get a single linker error "Column.cpp: undefined reference to sqlite3_column_origin_name", -it's that your "sqlite3" library was not compiled with -the SQLITE_ENABLE_COLUMN_METADATA macro defined (see http://www.sqlite.org/compile.html#enable_column_metadata). -You can either recompile it yourself (seek help online) or you can comment out the following line in src/Column.h: - -```C++ -#define SQLITE_ENABLE_COLUMN_METADATA -``` - -### Continuous Integration - -This project is continuously tested under Ubuntu Linux with the gcc and clang compilers -using the Travis CI community service with the above CMake building and testing procedure. - -Detailed results can be seen online: https://travis-ci.org/SRombauts/SQLiteCpp - -### Thread-safety - -SQLite supports three mode of thread safety, as describe in "SQLite And Multiple Threads" : -see http://www.sqlite.org/threadsafe.html - -This SQLiteC++ wrapper does no add any lock (no mutexes) nor any other thread-safety mecanism -above the SQLite library itself, by design, for lightness and speed. - -Thus, SQLiteC++ naturally supports the "Multi Thread" mode of SQLite ; -"In this mode, SQLite can be safely used by multiple threads -provided that no single database connection is used simultaneously in two or more threads." - -But SQLiteC++ does not support the fully thread-safe "Serialized" mode of SQLite, -because of the way it shares the underling SQLite precompiled statement -in a custom shared pointer (See the inner class "Statement::Ptr"). - -### License - -Copyright (c) 2012-2015 Sébastien Rombauts (sebastien.rombauts@gmail.com) - -Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt -or copy at http://opensource.org/licenses/MIT) - -## Getting started -### First sample demonstrates how to query a database and get results: - -```C++ -try -{ - // Open a database file - SQLite::Database db("example.db3"); - - // Compile a SQL query, containing one parameter (index 1) - SQLite::Statement query(db, "SELECT * FROM test WHERE size > ?"); - - // Bind the integer value 6 to the first parameter of the SQL query - query.bind(1, 6); - - // Loop to execute the query step by step, to get rows of result - while (query.executeStep()) - { - // Demonstrate how to get some typed column value - int id = query.getColumn(0); - const char* value = query.getColumn(1); - int size = query.getColumn(2); - - std::cout << "row: " << id << ", " << value << ", " << size << std::endl; - } -} -catch (std::exception& e) -{ - std::cout << "exception: " << e.what() << std::endl; -} -``` - -### Second sample shows how to manage a transaction: - -```C++ -try -{ - SQLite::Database db("transaction.db3", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); - - db.exec("DROP TABLE IF EXISTS test"); - - // Begin transaction - SQLite::Transaction transaction(db); - - db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)"); - - int nb = db.exec("INSERT INTO test VALUES (NULL, \"test\")"); - std::cout << "INSERT INTO test VALUES (NULL, \"test\")\", returned " << nb << std::endl; - - // Commit transaction - transaction.commit(); -} -catch (std::exception& e) -{ - std::cout << "exception: " << e.what() << std::endl; -} -``` - -### How to handle in assertion in SQLiteC++: -Exceptions shall not be used in destructors, so SQLiteC++ use SQLITECPP_ASSERT() to check for errors in destructors. -If you don't want assert() to be called, you have to enable and define an assert handler as shown below, -and by setting the flag SQLITECPP_ENABLE_ASSERT_HANDLER when compiling the lib. - -```C++ -#ifdef SQLITECPP_ENABLE_ASSERT_HANDLER -namespace SQLite -{ -/// definition of the assertion handler enabled when SQLITECPP_ENABLE_ASSERT_HANDLER is defined in the project (CMakeList.txt) -void assertion_failed(const char* apFile, const long apLine, const char* apFunc, const char* apExpr, const char* apMsg) -{ - // Print a message to the standard error output stream, and abort the program. - std::cerr << apFile << ":" << apLine << ":" << " error: assertion failed (" << apExpr << ") in " << apFunc << "() with message \"" << apMsg << "\"\n"; - std::abort(); -} -} -#endif -``` - -## How to contribute -### GitHub website -The most efficient way to help and contribute to this wrapper project is to -use the tools provided by GitHub: -- please fill bug reports and feature requests here: https://github.com/SRombauts/SQLiteCpp/issues -- fork the repository, make some small changes and submit them with pull-request - -### Contact -You can also email me directly, I will answer any questions and requests. - -### Coding Style Guidelines -The source code use the CamelCase naming style variant where : -- type names (class, struct, typedef, enums...) begins with a capital letter -- files (.cpp/.h) are named like the class they contains -- function and variable names begins with a lower case letter -- member variables begins with a 'm', function arguments begins with a 'a', boolean with a 'b', pointers with a 'p' -- each file, class, method and member variable is documented using Doxygen tags -See also http://www.appinf.com/download/CppCodingStyleGuide.pdf for good guidelines - -## See also - Some other simple C++ SQLite wrappers: - -See also the file WRAPPERS.md offering a more complete comparison of other wrappers. - - [sqdbcpp](http://code.google.com/p/sqdbcpp/): RAII design, simple, no dependencies, UTF-8/UTF-16, new BSD license - - [sqlite3cc](http://ed.am/dev/sqlite3cc): uses boost, modern design, LPGPL - - [sqlite3pp](http://code.google.com/p/sqlite3pp/): uses boost, but never updated since initial publication in may 2012, MIT License - - [SQLite++](http://sqlitepp.berlios.de/): uses boost build system, Boost License 1.0 - - [CppSQLite](http://www.codeproject.com/Articles/6343/CppSQLite-C-Wrapper-for-SQLite/): famous Code Project but old design, BSD License - - [easySQLite](http://code.google.com/p/easysqlite/): manages table as structured objects, complex - - [sqlite_modern_cpp](https://github.com/keramer/sqlite_modern_cpp): modern C++11, all in one file, MIT license +SQLiteC++ +--------- + +![SQLiteCpp build status](https://api.travis-ci.org/SRombauts/SQLiteCpp.png "SQLiteCpp build status") + +SQLiteC++ (SQLiteCpp) is a smart and easy to use C++ SQLite3 wrapper. + +See SQLiteC++ website http://srombauts.github.com/SQLiteCpp on GitHub. + +Keywords: sqlite, sqlite3, C, library, wrapper C++ + +### About SQLite: + +SQLite is a library that implements a serverless transactional SQL database engine. +It is the most widely deployed SQL database engine in the world. +The source code for SQLite is in the public domain. +http://www.sqlite.org/about.html + +### About SQLiteC++: + +SQLiteC++ offers an encapsulation arround the native C APIs of sqlite, +with a few intuitive and well documented C++ class. + +### The goals of SQLiteC++ are: + +- to offer the best of existing simple C++ SQLite wrappers +- to be elegantly written with good C++ design, STL, exceptions and RAII idiom +- to keep dependencies to a minimum (STL and SQLite3) +- to be portable +- to be light and fast +- to be thread-safe only as much as SQLite "Multi-thread" mode (see below) +- to have a good unit test coverage +- to use API names sticking with those of the SQLite library +- to be well documented with Doxygen tags, and with some good examples +- to be well maintained +- to use a permissive MIT license, similar to BSD or Boost, for proprietary/commercial usage + +It is designed using the Resource Acquisition Is Initialization (RAII) idom +(see http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization), +and throwing exceptions in case of SQLite errors (exept in destructors, +where assert() are used instead). +Each SQLiteC++ object must be constructed with a valid SQLite database connection, +and then is always valid until destroyed. + +### Supported platforms: + +Developements and tests are done under the following OSs: +- Debian 7 +- Ubuntu 12.10 +- Windows XP/7/8 +And following IDEs/Compilers +- GCC 4.7.2 with a provided Makefile +- Eclipse CDT under Linux, using the provided Makefile +- Visual Studio Express 2008/2010/2012/2013 for testing compatibility purpose + +### Dependencies + +- a STL implementation (even an old one, like the one provided with VC6 should work) +- exception support (the class Exception inherit from std::runtime_error) +- the SQLite library, either by linking to it dynamicaly or staticaly (install the libsqlite3-dev package under Debian/Ubuntu/Mint Linux), + or by adding its source file in your project code base (source code provided in src/sqlite3 for Windows), + with the SQLITE_ENABLE_COLUMN_METADATA macro defined (see http://www.sqlite.org/compile.html#enable_column_metadata). + +### Installation + +To use this wrappers, you need to add the 10 SQLiteC++ source files from the src/ directory +in your project code base, and compile/link against the sqlite library. + +The easiest way to do this is to add the wrapper as a library. +The proper "CMakeLists.txt" file defining the static library is provided in the src/ subdirectory, +so you simply have to add_directory(SQLiteCpp/src) to you main CMakeLists.txt +and link to the "SQLiteCpp" wrapper library. +Thus this SQLiteCpp repository can directly be used as a Git submoldule. + +Under Debian/Ubuntu/Mint Linux, install the libsqlite3-dev package. + +### Building the examples: + +#### CMake and test +A CMake configuration file is also provided for multiplatform support and testing. + +Typical generic build (see also "build.bat" or "./build.sh"): + +```bash +mkdir build +cd build +cmake .. # cmake .. -G "Visual Studio 10" # for Visual Studio 2010 +cmake --build . # make +ctest . # make test +``` + +Generating the Linux Makefile, building in Debug and executing the tests: + +```bash +mkdir Debug +cd Debug +cmake .. -DCMAKE_BUILD_TYPE=Debug +cmake --build . # make +ln -s ../examples examples +ctest . # make test +``` + +#### Troubleshooting + +Under Linux, if you get muliple linker errors like "undefined reference to sqlite3_xxx", +it's that you lack the "sqlite3" library: install the libsqlite3-dev package. + +If you get a single linker error "Column.cpp: undefined reference to sqlite3_column_origin_name", +it's that your "sqlite3" library was not compiled with +the SQLITE_ENABLE_COLUMN_METADATA macro defined (see http://www.sqlite.org/compile.html#enable_column_metadata). +You can either recompile it yourself (seek help online) or you can comment out the following line in src/Column.h: + +```C++ +#define SQLITE_ENABLE_COLUMN_METADATA +``` + +### Continuous Integration + +This project is continuously tested under Ubuntu Linux with the gcc and clang compilers +using the Travis CI community service with the above CMake building and testing procedure. + +Detailed results can be seen online: https://travis-ci.org/SRombauts/SQLiteCpp + +### Thread-safety + +SQLite supports three mode of thread safety, as describe in "SQLite And Multiple Threads" : +see http://www.sqlite.org/threadsafe.html + +This SQLiteC++ wrapper does no add any lock (no mutexes) nor any other thread-safety mecanism +above the SQLite library itself, by design, for lightness and speed. + +Thus, SQLiteC++ naturally supports the "Multi Thread" mode of SQLite ; +"In this mode, SQLite can be safely used by multiple threads +provided that no single database connection is used simultaneously in two or more threads." + +But SQLiteC++ does not support the fully thread-safe "Serialized" mode of SQLite, +because of the way it shares the underling SQLite precompiled statement +in a custom shared pointer (See the inner class "Statement::Ptr"). + +### License + +Copyright (c) 2012-2015 Sébastien Rombauts (sebastien.rombauts@gmail.com) + +Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt +or copy at http://opensource.org/licenses/MIT) + +## Getting started +### First sample demonstrates how to query a database and get results: + +```C++ +try +{ + // Open a database file + SQLite::Database db("example.db3"); + + // Compile a SQL query, containing one parameter (index 1) + SQLite::Statement query(db, "SELECT * FROM test WHERE size > ?"); + + // Bind the integer value 6 to the first parameter of the SQL query + query.bind(1, 6); + + // Loop to execute the query step by step, to get rows of result + while (query.executeStep()) + { + // Demonstrate how to get some typed column value + int id = query.getColumn(0); + const char* value = query.getColumn(1); + int size = query.getColumn(2); + + std::cout << "row: " << id << ", " << value << ", " << size << std::endl; + } +} +catch (std::exception& e) +{ + std::cout << "exception: " << e.what() << std::endl; +} +``` + +### Second sample shows how to manage a transaction: + +```C++ +try +{ + SQLite::Database db("transaction.db3", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + + db.exec("DROP TABLE IF EXISTS test"); + + // Begin transaction + SQLite::Transaction transaction(db); + + db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)"); + + int nb = db.exec("INSERT INTO test VALUES (NULL, \"test\")"); + std::cout << "INSERT INTO test VALUES (NULL, \"test\")\", returned " << nb << std::endl; + + // Commit transaction + transaction.commit(); +} +catch (std::exception& e) +{ + std::cout << "exception: " << e.what() << std::endl; +} +``` + +### How to handle in assertion in SQLiteC++: +Exceptions shall not be used in destructors, so SQLiteC++ use SQLITECPP_ASSERT() to check for errors in destructors. +If you don't want assert() to be called, you have to enable and define an assert handler as shown below, +and by setting the flag SQLITECPP_ENABLE_ASSERT_HANDLER when compiling the lib. + +```C++ +#ifdef SQLITECPP_ENABLE_ASSERT_HANDLER +namespace SQLite +{ +/// definition of the assertion handler enabled when SQLITECPP_ENABLE_ASSERT_HANDLER is defined in the project (CMakeList.txt) +void assertion_failed(const char* apFile, const long apLine, const char* apFunc, const char* apExpr, const char* apMsg) +{ + // Print a message to the standard error output stream, and abort the program. + std::cerr << apFile << ":" << apLine << ":" << " error: assertion failed (" << apExpr << ") in " << apFunc << "() with message \"" << apMsg << "\"\n"; + std::abort(); +} +} +#endif +``` + +## How to contribute +### GitHub website +The most efficient way to help and contribute to this wrapper project is to +use the tools provided by GitHub: +- please fill bug reports and feature requests here: https://github.com/SRombauts/SQLiteCpp/issues +- fork the repository, make some small changes and submit them with pull-request + +### Contact +You can also email me directly, I will answer any questions and requests. + +### Coding Style Guidelines +The source code use the CamelCase naming style variant where : +- type names (class, struct, typedef, enums...) begins with a capital letter +- files (.cpp/.h) are named like the class they contains +- function and variable names begins with a lower case letter +- member variables begins with a 'm', function arguments begins with a 'a', boolean with a 'b', pointers with a 'p' +- each file, class, method and member variable is documented using Doxygen tags +See also http://www.appinf.com/download/CppCodingStyleGuide.pdf for good guidelines + +## See also - Some other simple C++ SQLite wrappers: + +See also the file WRAPPERS.md offering a more complete comparison of other wrappers. + - [sqdbcpp](http://code.google.com/p/sqdbcpp/): RAII design, simple, no dependencies, UTF-8/UTF-16, new BSD license + - [sqlite3cc](http://ed.am/dev/sqlite3cc): uses boost, modern design, LPGPL + - [sqlite3pp](http://code.google.com/p/sqlite3pp/): uses boost, but never updated since initial publication in may 2012, MIT License + - [SQLite++](http://sqlitepp.berlios.de/): uses boost build system, Boost License 1.0 + - [CppSQLite](http://www.codeproject.com/Articles/6343/CppSQLite-C-Wrapper-for-SQLite/): famous Code Project but old design, BSD License + - [easySQLite](http://code.google.com/p/easysqlite/): manages table as structured objects, complex + - [sqlite_modern_cpp](https://github.com/keramer/sqlite_modern_cpp): modern C++11, all in one file, MIT license diff --git a/appveyor.yml b/appveyor.yml index a18fc73..c4f10a7 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,13 +1,14 @@ -# Copyright (c) 2012-2015 Sébastien Rombauts (sebastien.rombauts@gmail.com) +# Copyright (c) 2012-2015 Sebastien Rombauts (sebastien.rombauts@gmail.com) # build format version: "{build}" # scripts that run after cloning repository +# NOTE : not updating submodule as cloning googletest does not work on AppVeyor install: - - git submodule update --init --recursive - sudo apt-get update -qq - sudo apt-get install -qq cppcheck +# - git submodule update --init --recursive # configurations to add to build matrix configuration: @@ -16,13 +17,14 @@ configuration: # scripts to run before build # using a symbolic link to get the "make test" to work as if launched from the root directorys +# NOTE : no unit tests as cloning googletest does not work on AppVeyor before_build: - mkdir build - cd build - - cmake -DSQLITECPP_RUN_CPPLINT=ON -DSQLITECPP_RUN_CPPCHECK=ON -DSQLITECPP_BUILD_EXAMPLES=ON -DSQLITECPP_BUILD_TESTS=ON .. + - cmake -DSQLITECPP_BUILD_EXAMPLES=ON -DSQLITECPP_BUILD_TESTS=OFF -DSQLITECPP_RUN_DOXYGEN=OFF .. - ln -s ../examples examples # build examples, and run tests (ie make & make test) build_script: - cmake --build . - - ctest --output-on-failure \ No newline at end of file +# - ctest --output-on-failure diff --git a/build.bat b/build.bat index 96ecca6..cb8062a 100644 --- a/build.bat +++ b/build.bat @@ -1,12 +1,14 @@ -@REM Copyright (c) 2012-2015 Sébastien Rombauts (sebastien.rombauts@gmail.com) -@REM +@REM Copyright (c) 2012-2015 Sebastien Rombauts (sebastien.rombauts@gmail.com) +@REM @REM Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt @REM or copy at http://opensource.org/licenses/MIT) - mkdir build cd build -@REM generate solution for Visual Studio, and build it -cmake -DSQLITECPP_RUN_CPPLINT=ON -DSQLITECPP_RUN_CPPCHECK=ON -DSQLITECPP_RUN_DOXYGEN=ON -DSQLITECPP_BUILD_EXAMPLES=ON -DSQLITECPP_BUILD_TESTS=ON .. + +@REM Generate a Visual Studio solution for latest version found +cmake -DSQLITECPP_BUILD_EXAMPLES=ON -DSQLITECPP_BUILD_TESTS=ON .. + +@REM Build default configuration (ie 'Debug') cmake --build . @REM prepare and launch tests diff --git a/build.sh b/build.sh index da667c7..5cd6e72 100755 --- a/build.sh +++ b/build.sh @@ -2,14 +2,15 @@ # # Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt # or copy at http://opensource.org/licenses/MIT) - mkdir -p build cd build -# generate solution for GCC -cmake -DSQLITECPP_RUN_CPPLINT=ON -DSQLITECPP_RUN_CPPCHECK=ON -DSQLITECPP_RUN_DOXYGEN=ON -DSQLITECPP_BUILD_EXAMPLES=ON -DSQLITECPP_BUILD_TESTS=ON .. + +# Generate a Makefile for GCC (or Clang, depanding on CC/CXX envvar) +cmake -DSQLITECPP_BUILD_EXAMPLES=ON -DSQLITECPP_BUILD_TESTS=ON .. +# Build (ie 'make') cmake --build . -# prepare and launch tests +# Prepare and run unit-tests (ie 'make test') mkdir -p examples/example1 cp ../examples/example1/example.db3 examples/example1 cp ../examples/example1/logo.png examples/example1