Checklist For SQLite 3.7.7

  1. Check compiler warnings seen on the following builds:
    1. Linux GCC using options -Wall -Wextra
    2. OpenBSD GCC using options -Wall
    3. Windows VC++

  2. Verify that documentation files are up-to-date:
    1. Latest release on the index.html page
    2. Release announcement in changes.in
    3. Release accouncement in news.html
    4. No unresolved hyperlinks in the documentation build
    5. The compile-time options are all up-to-date (compile.html)
    6. Database footprint is up-to-date (features.html)
    7. Test metrics are up-to-date (testing.html)
    8. Check new/changed documentation for spelling and gramatical mistakes
    9. Verify that this checklist agrees with planning documents

  3. Review the differences between the release candidate and one or more prior releases to verify:
    1. No stray changes
    2. All significant changes are mentioned in the "changes" log of the documentation
    3. New code complies with style guidelines
    4. New code complies with design rules
    5. Comments have been updated to reflect code changes
    6. Variables and functions have been renamed to reflect changes in their use

  4. Verify SQLite compiles cleanly with all OMIT, ENABLE, and DISABLE options:
    1. tclsh ../tool/omittest.tcl -skip_run

  5. Run the following tests and verify output for platform Linux x86:
    1. tclsh releasetest.tcl
    2. tclsh th3make cov.rc (verify 100% branch test coverage)
    3. tclsh fulltest.tcl fast.rc test.rc
    4. tclsh th3make fast-ex.rc
    5. tclsh th3make cov.rc -DHAVE_LOCALTIME_R=1 (verify 100% coverage)

  6. Run the following tests and verify output for platform Linux x86_64:
    1. tclsh releasetest.tcl
    2. tclsh fulltest.tcl fast.rc test.rc
    3. tclsh th3make memdebug.rc
    4. tclsh th3make test-ex.rc

  7. Run the following tests and verify output for platform Mac OS-X x86:
    1. tclsh releasetest.tcl
    2. tclsh fulltest.tcl fast.rc test.rc

  8. Run the following tests and verify output for platform Max OS-X PPC:
    1. tclsh th3make -Os min.rc

  9. Run the following tests and verify output for platform Win32:
    1. make fulltest
    2. th3make test.rc
    3. th3make fast.rc

  10. Run the following tests and verify output for platform Win64:
    1. make fulltest
    2. th3make test.rc (compiled using VC++)
    3. th3make fast.rc

  11. Run the following tests and verify output for platform Android:
    1. th3make -Os min.rc

  12. Run the following tests and verify output for platform OpenBSD x86:
    1. make test
    2. th3make -Os min.rc

  13. On one or more platforms of the tester's choice:
    1. th3make alignment2.rc test.rc

  14. Run test suites on various compilers and at various optimization settings for each compiler and verify that identical results are obtained on each run. This checklist item is designed to verify that SQLite code does not use C code constructs that are undefined or implementation defined. In particular, make sure the code works the same with and without the -ftrapv option on GCC. What other compilers and/or options can we list here? Clang? LLVM?
  15. Verify that everything still works with SQLITE_MAX_ATTACHED in the 50 to 60 range.
  16. Update the amalgamation build for sqllogictest. Recompile and run the entire test suite in verification mode. Verify that there are no errors. Check-in the new amalgamation build in the sqllogictest Fossil repository.
  17. The veryquick.test TCL tests run under valgrind with no unexplained errors or warnings. Note that some tests deliberately reference memory that has previously been freed which will cause valgrind warnings. Those tests are clearly marked.
  18. Run TH3 tests tclsh th3make -Os min.rc under valgrind with no unexplained errors or warnings. Some TH3 tests deliberately do things that valgrind will complain about. Those tests are clearly marked.
  19. Build using the configure/make in main source tree.
    1. Make sure that autoconf has been run to update the configure script.
    2. Run "make test" to verify that the build works.
    3. Verify the correct version numbers have been installed.
    4. Verify that the --disable-amalgamation option to configure works.

  20. Build a library from the amalgamation using both SQLITE_ENABLE_FTS3 and SQLITE_ENABLE_RTREE and verify that no internal symbols are exported.
  21. Update the SQLite amalgamation that is built into Fossil. Recompile and run a complete test.
  22. Update the SQLite amalgamation that is built into the public Firefox sources. Recompile and verify that the new SQLite is being used (by checking the version mark in the header of one of the Firefox database files) and that Firefox still works correctly and efficiently.
  23. Copy the SQLite amalgamation into CEROD. Compile CEROD and run the test scripts in the test/ subdirectory. Verify correct output.
  24. Copy the SQLite amalgamation into SEE. Compile and test all five variations of SEE using a command similar to tclsh th3make see.rc min.rc -Os -DSQLITE_DEBUG -DSQLITE_MEMDEBUG, with or without the optional switches. Test controllers "test.rc" and "fast.rc" can be substituted for "min.rc"; each should be used at least once.
    1. see.c
    2. see-aes128-ofb.c
    3. see-aes256-ofb.c
    4. see-rc4.c
    5. see-aes128-ccm.c

  25. Run the following ZIPVFS tests on at least one platform each:
    1. testfixture ../zipvfs/test/zipvfs.test (See test/README.txt in the ZIPVFS source tree for details.)
    2. th3make zipvfs.rc test.rc
    3. th3make zipvfs.rc memdebug.rc
    4. th3make zipvfs.rc min.rc (Run under Valgrind with no unexplained errors)

  26. Build the amalgamation autoconf tarball. On Linux and Mac OS-X, unpack that tarball in a temporary directory and verify that it builds correctly.
  27. Build the TEA archive. On Linux and Mac OS-X, unpack that TEA archive into a temporary directory and verify that it builds correctly.
  28. Run performance tests comparing the new SQLite release against the previous version. Verify no performance regressions.
    1. The TCL speed*.test scripts
    2. The TH3 speed tests
    3. sqlite3 sqlite.fossil .dump >speed-c.sql
      fossil timeline -R sqlite.fossil -n 300 -sqltrace 2>>speed-c.sql
      fossil rebuild sqlite.fossil -sqltrace 2>>speed-c.sql

  29. Verify that the amalgamation builds are byte-for-byte identical on all workstation platforms.
  30. Verify that databases (including FTS3 and RTREE databases), rollback journals, and WAL files created by the release candidate are readable and writeable by historical versions of SQLite (as long as no unsupported features are used) and vice versa.
  31. Verify that databases, rollback journals, and WAL files are portable across
    1. 32/64 bit platforms, and
    2. little/big-endian platforms.

  32. Build and verify correct operation of sqlite3_analyzer on:
    1. Linux
    2. MacOSX
    3. Win32

  33. Run the CLI tests found under the tool subfolder in the main source tree and verify correct output.
  34. All changes in trunk have been merged into each of the following branches and those branches have been tested using TCL and TH3.
    1. sessions
    2. apple-osx

  35. Verify that all branches that are no longer active have been closed.
  36. Verify that the bug response checklist has been completed for all bugs found since the previous release.
  37. Verify that the new feature checklist has been completed for all enhancements made since the previous release.
Status: 
Comments: