release-4.1

CODE VAULT RELEASE NOTES for 4.1

VERSION 4.1

Trygve Isaacson, August 2014

See specific 4.1 development release notes below for complete details. Major features summary:

• Improved Unicode code point support and features.
• Improved support for date data type in settings.
• New helper class VFileWriter.
• Abstract smart ptr definitions for C++11 and Boost.
• Example IDE projects for Xcode and Visual Studio.

VERSION 4.1d5

Trygve Isaacson, June 2014

code-vault#17

• Use heap allocated logger statics to avoid static destruction problems.

code-vault#16

• Use nullptr instead of NULL.

code-vault#15

• Fix issue with Boost/C++11 compile time switch.

code-vault#12

• Add example IDE projects for Xcode and Visual Studio.

code-vault#11

• Update VString interface to favor code points over characters in APIs.

code-vault#10

• Fix error handling with mktime() APIs.

code-vault#8

• Move all internal character usage to VCodePoint.

code-vault#7

• Revise unit tests to use new VUnit assertion macros.

code-vault#5

• Fix issue with Windows time conversion with UTC around DST.

VERSION 4.1d4

Trygve Isaacson, February 2014

VAULT-0043

• Rename mix-in classes as "interface" definitions.

VAULT-0044

• Fix compiler warnings from latest Xcode5 and Clang.

VAULT-0045

• Define aliases for shared_ptr casts for Boost and C++11.

VAULT-0046

• New file i/o helper class VFileWriter.
• Makes it simple to safely overwrite a file with new contents.

VERSION 4.1d3

Trygve Isaacson, October 2013

VAULT-0042

• Added support for dates in VSettings, with VDate construction from string.

VERSION 4.1d2

Trygve Isaacson, September 2013

VAULT-0041

• Fix Windows XP startup IPv6 DLL bug.

VAULT-0039

• Improved Unicode-aware APIs and support.
• VString continues to use UTF-8 bytes internally.
• As before, most C string functions and VString APIs work seamlessly with UTF-8.
• VCodePoint stores any Unicode code point; conversion with UTF-8, UTF-16.
• VString APIs for construct, append, etc. with VCodePoint.
• VStringIterator iterates over VString, returning VCodePoint elements.
• VString APIs for construct, append, get, etc. with std::wstring (UTF-16).
• You will want to pass std::wstring to "wide" OS APIs on Windows.

VERSION 4.1d1

Trygve Isaacson, August 2013

VAULT-0037

• Add VString API for platform-specific line endings.

VAULT-0038

• Optimize include statements to reduce compile times.

release-4.0

VERSION 4.0

Trygve Isaacson, August 2013

See specific 4.0 development release notes below for complete details. Major features summary:

• VClientSession/VServer, and VMessage broadcasting, use smart pointers instead of internal reference counting and locking.
• Vault fully supports 64-bit builds without compiler warnings.
• VSystemError provides API for extracting system/socket errors in a platform-independent way.
• VSocket implements DNS name resolution.
• VSocket supports IPv6.
• VSocket supports connection strategies; provided strategies include a parallel, threaded strategy.
• VInstant supports user-supplied time stamp formats, using the Java SimpleDateFormat formatting directives.
• VLogger allows user-configured output format, including the time stamp.
• Vault internally uses logger path names to allow more configurable control of log output filtering.
• VString implements a "small string optimization" (SSO) for better performance and less memory usage.

VERSION 4.0d9

Trygve Isaacson, July 2013

VAULT-0036

• SSO (small string optimization) implementation.
• VString can store small strings internally, avoiding heap buffer allocation.
• The base memory footprint of VString objects is unchanged.
• Performance is improved by 55%-60% for small strings.
• Memory usage is improved by 57%-67% for small strings.
• A "small" string is defined as 10 chars or fewer on 32-bit, 18 chars or fewer on 64-bit.
• Updated extras/vcpp_autoexp_snippets.txt (for the VC++ debugger) to match the new VString internals.

VERSION 4.0d8

Trygve Isaacson, July 2013

VAULT-0028

• Consolidated common socket code.
• Merged some common Unix and Windows socket code to avoid duplication.

VAULT-0031

• Refined logging with dot-separated logger path names
• every Vault logger emission has a specific naming scheme
• allows better control of log output and filtering in logging configuration

VAULT-0032

• Refer to shared_ptr template indirectly
• vconfigure.h now lets you indicate whether you want boost or std version of shared_ptr et al.

VERSION 4.0d7

Trygve Isaacson, July 2013

VAULT-0030

• User configurability for log output and time stamp strings.
• You can now specify the format of VInstant time stamp strings via a VInstantFormatter.
• It implements almost all of the format specifiers defined by Java SimpleDateFormat.
• The existing APIs produce the same format as previously; they now use VInstantFormatter internally.
• You can now specify the overall format structure, and time stamp format of VLogAppender.
• This can be specified during construction or from dynamically loaded XML settings.
• The "format-spec" XML property for appender config defines the field layout (see VLogAppender docs).
• The "time-format" XML property for appender config defines the format of time stamps, same as VInstantFormatter.
• The default formats produce the same logger output as previously.
• Logger config settings for level can now use the level name as an alternative to the level number.

VAULT-0031

• Refined internal use of logging.
• Logging is generally at TRACE level.
• Significant events are logged at DEBUG level.
• All log statements use dot-separated path-like names for fine-grained control.

VAULT-0034

• Fixed bug in posting message to session that is not yet online that was introduced in 4.0d1.

VAULT-0035

• Fixed bug in attaching IO threads to VClientSession that was introduced in 4.0d1.

VERSION 4.0d6

Trygve Isaacson, June 2013

VAULT-0025

• Added support for system error codes and messages.
• VSystemError captures Unix errno or Windows GetLastError(), plus string conversion.
• Alternate version captures Winsock flavor of errors.
• VException constructors can take VSystemError parameter instead of error code, and use when formatting what() text.

VAULT-0026

• Added support for IPv6 addresses and socket connections.
• DNS resolve and socket connect now work with both IPv4 and IPv6 address family APIs.
• Fixed error handling bug in listener creation.
• Removed obsolete BSD-specific code.

VAULT-0027

• Added support for multi-threaded socket connection attempts.
• Simplest strategy just uses first address as you probably did before expecting 1 resolved address.
• Better strategy iterates over all resolved addresses until one connects.
• Complicated strategy multi-threads in an attempt to use the fastest server to respond to connection request.

VAULT-0032

• Made references to shared_ptr and related templates indirect.
• The VAULT_BOOST_SHARED_PTR_INCLUDE switch in vconfigure.h controls includes and several typedefs.
• If you define it, you get includes and typedefs using boost; otherwise, you get the C++11 typedefs.
• The types are VSharedPtr, VWeakPtr, and VEnableSharedFromThis.

VAULT-0029

• Miscellaneous
• Updated copyright dates and version strings.
• Reapply Astyle formatting, with edits for preferred initializer list bracing and preprocessor indentation.
• Fixed a bug in VClientSession::postOutputMessage() that was introduced in 4.0d1.

VERSION 4.0d5

Trygve Isaacson, May 2013

VAULT-0023

• Fixed bug relating to Winsock timeouts for large socket IDs.

VAULT-0024

• Implemented DNS resolve APIs to VSocket.

VERSION 4.0d4

Trygve Isaacson, February 2013

VAULT-0022

• Added support for 64-bit compilation on all supported platforms.

VAULT-0021

• Added support for minor Qt 5.0 API changes.

VERSION 4.0d3

Trygve Isaacson, November 2012

VAULT-0020

• Compatibility with Xcode 4 LLVM compiler, LLVM compiler warnings.
• Fixed possible crash in vararg string formatting.
• Fixed Bento unit test for non-ASCII character escaping.
• Added comments on best practices for VString creation macros.

VERSION 4.0d2

Trygve Isaacson, September 2012

VAULT-0019

• Navis update pull based on r139692.
• Static code evaluation tweaks.
• VLogger format changes. I plan to revert hardcoded timestamp format changes in 4.0 final release.
• VFSNode::setName() API to update a node internally, different from rename().
• Throws an exception if VInstant::getDateAndTime() is called on a non-specific time.
• Improved error code reporting in Windows version of VSocket::available() and write().
  Thanks to Jay Hamilton-Roth.

VERSION 4.0d1

Trygve Isaacson, July 2012

VAULT-0018

• Adoption of smart pointers in key components, in order to eliminate tricky
  code that was needed to deal with shared references to sessions and threads
  and messages, for careful tear-down of sessions and broadcasting a single
  message to multiple sessions.
• VMessage, and its references on VMessageQueue for message broadcast/lifecycle.
  V_ASSERT_INVARIANT_VMESSAGE_ENABLED is obsolete.
• VClientSession, and its references by VServer for session management.
• VThread, and its references as i/o threads and the global thread list/map.

release-3.3.1

VERSION 3.3.1

Trygve Isaacson, June 2012
Revision #119.

• Various tweaks from 3.3 deployment experience:
• Improved performance of escaping Bento text.
• Bento now throws specific VBentoNotFoundException for missing attributes.
• Fixed Bento escape syntax for unprintable characters in XML.
• Added a public Bento attribute find API.
• Added full set of VDate comparison operators.
• Removed redundant thread ID information in VMessageHandler log output.
• Changed error message attribute name in Bento error response generated by VBentoMessageInputThread.
• Optimized VBinaryIOStream::readString32() to avoid an extra function call when not needed.
• Added Bento escape handling unit tests.
• Removed unreliable unit test that tried to exercise Win32 structured exceptions.
• Defined V_MAX_SIZE for maximum value of size_t.
• Fixed smart ptr bug that caused default logger deletion by setPrintStackInfo().
• Fixed failure to respect user-specified base log directory by VFileLogAppender.

release-3.3

Trygve Isaacson, November 2011

VLogger

Restructured logging infrastructure:

• Existing macro APIs for logging work as before.
• VLogger is now mostly a helper class through which most logger management is performed.
• VNamedLogger defines a log target with name and level. Existing macro APIs log to these.
• VLogAppender-derived classes define concrete output implementation (file, console, etc.).
• A logger can send its filtered (by log level) output to multiple appenders.
• An appender can receive output from multiple named loggers.
• A "global appender" is one to whom all loggers send their filtered output.
• A config API can be called at startup to set up logging based on a VSettings/XML config.
• Custom appender factories can be registered, so that config init can instantiate custom appenders.

VMutex/VMutexLocker

• Tightened locking constraints: only locker and unlocker classes may lock and unlock a mutex.
• Locker's lock/unlock can be overridden, so a mutex-specific subclass can detect bad locking sequences.

VThread

Removed obsolete/deprecated APIs and features:

• As of 3.2, VThread keeps track of threads; removed thread counter statistics.
• Removed unused VThreadActionListener interface used for keeping statistics.

Doxygen

• Updated doc comments to add missing items and better formatted output.
• Generated Doxygen HTML output.

General

• Corrected VString::split() API to be const.
• Streamlined comparison operators to always forward to operator== and operator< implementations.
• Consolidated and corrected ambiguity in non-specific instant/duration comparisons and operations.
• Bento attribute-not-found exceptions now include a stack trace.
• Cast ::sscanf to void when ignoring return value.
• Added #pragmas to silence static analysis warnings for includes of non-compliant Microsoft headers.
• Re-order includes so Boost headers are first if they are used.

release-3.2

VERSION 3.2

Trygve Isaacson, August 2011

VException

New option to have an exception capture and store a stack trace on construction.
Some classes capture the stack trace by default; others do not. It depends on typical use:

• VException has it as an option, OFF by default.
• VStackTraceException captures a stack trace.
• VEOFException and VSocketClosedException do not capture a stack trace.
• VRangeException, VUnimplementedException, and VOSStatusException have it as an option, ON by default.

VASSERT et al

Macro-based assertions that check a condition and if not satisfied, log an error and optionally
throw a VStackTraceException. This replaces the older primitive V_ASSERT macro and Vassert function.
On by default. To disable, in vconfigure.h define VAULT_THROW_ON_ASSERTION_FAILURE to 0.

VString

Strict formatting macro option:

• To enable, define VAULT_VSTRING_STRICT_FORMATTING in vconfigure.h.
• Forces use of VSTRING_FORMAT or VSTRING_ARGS macros to construct a string with vararg sprintf formatting.
• Allows compiler to optimize construction from literal string, skipping the formatting logic.
  Standard formatting directive constants made available to facilitate correctness in formatting strings.

VLogger

• New hierarchical logger naming mechanism: dot-separated logger names act as search hierarchy.
• Short-circuiting logic uses global max level to avoid logger lookup when possible.
• Loggers now organized by map instead of list.
• Current thread name is included in log statements.
• VStringVectorLogger allows storage to be specified by caller.

VThread

Thread objects are tracked:

• Current thread name can be looked up. Compatible with main thread and other non-VThread threads.
• Info on instantiated threads can be retrieved.
  Fixed handle leak on Win32 during thread termination.

VMutex

New API for checking whether a VMutex is held by the current thread.

VBento

• Refined XML conversion output.
• Interim change to allow node/attribute find to be case-insensitive.

VSocket

VSocketClosedException used to identify socket closure as separate from more obscure errors.

VMessagePool

This feature has been removed completely.

VCompactingDeque

A std::deque template subclass that avoids the STL deque behavior that is effectively a memory leak,
by compacting the deque when certain thresholds are reached.

VMessagePool

This feature has been removed completely.

General

• Improved 64-bit compilation strictness.
• VClientSession closes socket to trigger session shutdown if posting exceeds limits.
• VMessageInputThread warns if teardown is delayed beyond threshold.
• VStream::seek0() API used whenever possible.
• VUnit defines additional test assertions.
• New unit tests added.

release-3.1

VERSION 3.1

Trygve Isaacson, June 2010

• VInstant
  Support for clock simulation (offsets and time freezing).
  Simpler string getter APIs.
• VDuration
  New APIs for formatted duration strings.
• VChar
  New API isHexadecimal().
• VColor (new class)
  Colors. RGBA and CSS/HTML color names.
  Color pairs (foreground + background).
  Color maps (value or range => color pair).
  Color palettes (sets of color maps).
• VException
  Support for access to Win32 non-C++ "Structured Exception Handling".
  Support for VC++ exception on dynamic_cast.
• VGeometry
  New APIs for distances and finding nearest sides and vertexes of rectangles and polygons.
  Complete interoperability with corresponding Qt geometry types.
  New class VPoint3D.
  New class VLine.
• VBento
  Support for indicating string value encoding.
  Support for all geometry types.
  Support for color type.
  Added "set" APIs to allow replacing existing values.
  New API getParentNode().
• VString
  New constant accessor NATIVE_LINE_ENDING().
  APIs "char*() const" and "chars() const" now return const buffer values.
  New API endsWithIgnoreCase().
  New APIs for "contains" tests.
  New APIs split() modeled on Java String.split().
  New API getDataBufferConst() returns byte pointer, for easier use with buffer writing APIs.
  Fix to prevent problem when "%" is used to construct a string.
  QString conversion uses QString::fromUtf8().
• VFSNode
  New APIs to get well-defined (but platform-specific) system and user directories, and the executable.
  New API safelyOverwriteFile() to write a file using temporary-remove-rename pattern.
  New API to construct from node and child name.
  New convenience APIs readAll() and readTextFile() to read a file in a single line of code.
  Added support for iOS using one Objective-C API low-level API to get executable file path.
• VServer / VClientSession
  VServer now defines abstract API for posting a broadcast message.
  VServer now uses garbage collection (deferred deletion) of sessions to manage threads on teardown.
  VClientSession can now have a time limit on its standby queue.
  VClientSession is reference counted to work with server's session garbage collection.
  VClientSession no longer needs API for attached tasks, due to reference counting.
• VMessageHandler
  New name and session name properties, to improve log output.
  Participates in session reference counting.
  Additional logging to report mutex blocking problems.
• VMessageInputThread / VMessageOutputThread / VMessageQueue
  Participate in session reference counting.
  Output thread can now have a time and size limits on output queue.
  Message queue can now have a threshold that triggers log warnings about delayed processing.
• VMessagePool
  This class will be removed in a future release.
  Testing has shown that pooling is of no real performance benefit.
  It does, however, make leak testing harder.
  It also raises the possiblity of improper reuse bugs.
• VSocket / VSocketBase
  Improved getLocalHostIPAddress() to avoid use of DNS, and work better with multiple network interfaces.
  New APIs enumerateNetworkInterfaces() to discover what interfaces exist.
  New APIs setPreferredNetworkInterace() and setPreferredLocalIPAddressPrefix() provide control
  over choice of interface on a multi-interface system.
• VStream classes
  New API seek0() convenience alternative to seek(0, SEEK_SET).
  Overloaded streamCopy() APIs are all now simply declared as static methods of VStream.
  API readGuaranteed() now includes offset info when throwing EOF exception.
  New APIs VTextIOStream::readAll() read the whole stream into a string or string vector.
• VThread
  The userMain() and userThreadMain() static functions are now declared by this class.
  New API logStackCrawl() logs a stack crawl if support is installed.
  Cooperates with VException support for Win32 non-C++ "Structured Exception Handling".
  Thread creation failure now throws an exception. This is used by server/listener code to better
  handle failures.
  Platform-specific hooks on thread start and end allow:
  On Win32, VThread objects now support threadSelf(), via a mapping of thread ID to thread handle.
  On Mac OS X 10.6, the VThread name is set on the pthread, for use in debuggers and crash dumps.
• VMutex / VMutexLocker
  New VMutex name property; used for new lock delay logging.
  New VMutexLocker name property; used for new lock delay logging.
  A threshold can be set to cause lock delay logging; logs whenever there is a delay in getting
  the lock, or when holding a lock for too long.
  Lock delay logging can be entirely disabled at compile time via VAULT_MUTEX_DELAY_CHECK in vconfigure.h.
• VLogger
  New API setPrintStackInfos() allows triggering of stack crawl output at desired log level.
  New API setRepetitionFilterEnabled() allows filtering to be turned off (or back on).
  Support for labeling with both the real and simulated clock values when clock simulation is in effect.
  Support for manipulating a logger's "next" chain at runtime.
  New classes VStringLogger and VStringVectorLogger allow logging to strings in memory.
• VSettings
  Changed string getter APIs to return the string. (See General)
  Full support for Vs64, VDuration, VGeometry, and VColor types.
  New constructor and other APIs for loading/saving the VSettings from/to an XML file with one line of code.
  New API findMutableNode() for use when adding to node tree.
  Allow the presence of "" first line when parsing.
• VHex
  New API bufferToPrintableASCIIString() for writing a buffer to a hex dump string.
  New API readHexDump() for loading a hex dump string into a binary stream such as a memory buffer.
  These two together provide a way of recording and later re-loading binary data, using human-readable text as the store.
• VMemoryTracker
  New module that supports optional ability to track memory allocations and find leaks.
  Feature is compiled in if VAULT_MEMORY_ALLOCATION_TRACKING_SUPPORT is set in vconfigure.h.
• VUnit
  New assert overloads to support more class types directly.
  New class VUnitOutputWriter abstaction allows unit tests to report results in various forms:
  New output writer classes for JUnit, plain text, and Team City result formats.
  Lots of new unit tests to cover more classes and new code.
  New APIs rerunUnit() and reset() allow the same unit test object to be run multiple times.
  Fixed bug in VFSNodeUnit that was revealed by testing on iOS4.
• VTypes
  New template function mapDeleteAllValues() deletes values in a map.
  Updated Linux compatibility testing on recent Ubuntu and Red Hat releases.
• General
  Numerous bug fixes.
  Fixed additional compiler warnings using ever-stricter warning levels.
  Added/replaced some alternate getter APIs in a form that returns a VString for convenience.
  Testing proved that the copy overhead of this tends to be much less than expected.
  In many cases the compiler doesn't even make a single extra copy of the string.
  This pattern makes the calling code much more readable.
• Thanks
  The following additional people contributed to fixes in this release:
  Jay Hamilton-Roth
  Sandeep Nevasekar
  Stuart Adamson
  Jon Ranstrom
  Aaron Barr
  Mike Pompa
  Chris Casey
  Edward Cheung

Upcoming Plans:

• Enable copy/assign in any remaining appropriate classes.
• Support VGeometry classes in new VUnit equality assertions.
• Wrap everything a "vault" namespace.
• Restructure VSocket classes using _platform file pattern.
• Be more consistent with use of error/strerror/WSAGetLastError.
• Remove VMessagePool mechanism which turns out to be of no real benefit.

release-3.0

VERSION 3.0

Trygve Isaacson, January 2008

3.0d1: reorg of public vs. internal platform headers

The platform-specific header files included by users of the Vault have been
simplified to include and define fewer things. The low-level internal details
needed by the Vault are no longer indirectly referenced by code that includes
Vault headers.

Previously, when you included the Vault headers, at some level this meant that
at the time of the include from your code, the compiler saw all of the low-level
platform-specific stuff that the Vault needs internally to work on that platform.

With this update, the public Vault header files don't reference those low-level
platform-dependent headers and definitions; they are contained in internal
platform-specific header files that only the Vault implementation files include
as needed.

This simplifies your compiler's environment when you include the Vault headers
(fewer files are included and fewer symbols are defined by the Vault), makes it
easier for the Vault to support each platform (there is even better isolation of
the platform-specific quirks), and makes it possible to support compilation
environments where there are conflicts in different header files that previously
made it impossible to compile (the client code can still compile
in a strange environment with the simplified Vault includes less likely to
conflict with anything, while the Vault implementation can compile in its own
cleaner environment and include everything it needs for the platform).

3.0d2: new vgeometry module

This new module (source/containers/vgeometry.*) contains a set of data types
to describe simple coordinate geometries: sizes, points, rectangles, and
polygons. Each class is a template so that it can use either VDouble or
int as the dimensional type. Because use of double is preferred, the
simpler class names use the VDouble templates (VSize, VPoint, VRect, VPolygon)
while the longer names use the integer templates that have an "I" in their
name (VISize, VIPoint, VIRect, VIPolygon). The templates themselves end in
"T" (VSizeT, VPointT, VRectT, VPolygonT).

These classes were originally defined to allow interoperability with the
Qt4 graphics item view system. Their purpose is not to implement the
utility of having a coordinate system, but rather to allow the coordinate-based
data types to be accessed in non-Qt source code that uses the Code Vault
machinery such as Bento, streams, etc. to persist data. So the APIs provided
by these classes are very simple and data-oriented and do not provide much at
all in the way of coordinate space operations and calculations. (Note that the
Qt classes use the simpler name for integer-based coordinates, e.g. QRect, and
the longer name for double-based coordinates, e.g., QRectF. The "F" stands for
"float" even though the dimensional type being used is double rather than float.)

If you compile with VAULT_QT_SUPPORT defined (in vconfigure.h), then these
classes also have methods for converting to/from the related Qt classes. You
would only do this if you are compiling the Vault in a Qt application. (This
is similar to the Qt support in VString, which allows conversion to and from
a QString.)

Because these classes were designed to interoperate with Qt, the coordinate
system has the Y axis pointing down. This is common in computer graphics
UI systems (e.g., QuickDraw, GDI, Qt; and Quartz supports it), but is the
opposite of traditional 2D mathematical coordinate systems.

3.0d3: vbento enhancements

The Bento module has three primary enhancements.

First is support for the new geometry types, which it can serialize/deserialize
and transport.

Second is support for binary data. This means that if you have binary data you wish
to include in a Bento data stream, you have the option of doing it without breaking
the data down into its constituent typed fields. Of course, this is not the
preferred use because it misses Bento's whole purpose, but it can be useful in
certain cases where you have a blob or some other largely opaque object. When
reading the binary data, a new VMemoryStream subclass called VReadOnlyMemoryStream
is used; this class allows multiple readers on the same physical memory buffer.

Third is support for arrays. Previously, arrays were always accomplished by using
a child node to contain the array elements as its child nodes. This was natural
when the array elements were multi-field structures (i.e., it was an array of
non-trivial objects), but was more complex than necessary when the array elements
were merely primitive types. It was also possible to model the array by using
iteratively named attributes, but this felt more like a work-around than a natural
way to model it. Now, arrays of primitive data types are first-class elements.
Fundamentally, an array is an attribute of a node. An array is like a child node
in that it can hold a collection of sub-elements, but it is different (and simpler)
because it is not recursively hierarchical like a child node is, and the individual
elements are not named like individual attributes are. You can create Bento array
attributes directly from the appropriate std::vector type, or you can create it
empty and append individual array elements or a whole std::vector at a time.

3.0d4: miscellaneous cleanup

The Vault class APIs were given a vigorous scrubbing. Some of the changes:

• Non-virtual protected methods that were not meant for subclasses to call have
  been made private.
• All protected and private method names now start with an underscore.
• Some protected instance variables were made private.
• Some method and argument names were changed to avoid some overaggressive lint warnings.
• Got rid of all vararg APIs except for VString constructor and format().
• Improved multi-test assertInvariant methods for better performance.
• Made assertion use more easily enabled/disabled and with more granularity.
• The VUnit type-dependent overloaded VUNIT_ASSERT_XXX() macros and the assertEqual()
  and assertNotEqual() methods they invoke are now preferred to the older test() method.
  These new calls automatically provide the failed test output data in the text output
  text, as well as test ID by file and line number. This simplifies what you need to
  supply as labeling on each test. VBentoUnit has been revised to demonstrate use of this.
• All classes now use complete initializer lists.
• "sm" globals renamed to "g".
• Corrected Vs8/Vu8 printf/scanf formatting directives.
• Removed stray tab characters.
• Added copy/assign prevention ctor/operator= for non-copyable/assignable classes.
• Revised the definitions of the byte-swapping macros to avoid lint complaints that the
  no-op versions of the macros were no-ops. Also made signed/unsigned swaps distinct.
• Cleaned up spacing and formatting.
• Fixed all feasible warnings emitted when using pedantic and EffC++ warnings on.