Test_NcChar.cpp

Test of class NcChar.

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

#include <iostream>
using std::cout;
using std::endl;
#include "netcdf4"
using namespace netcdf;

static char const * const testFileName = "Test_NcChar.nc";
static char const * const varNames[] = { "oneChar", "oneStr", "strArray", "strVector" };
static char const dataScalar = 'Z';
static char const * const data1D = "Doh  ";     // length == 5
static char const * const data2D[] = { "Doh  ", "Rey  ", "Me   ", 0 };
static short data2DSize = 3;

//-----------------------------------------------------------------------------
void Create (NcFile & nc)
{
    NcDim dimLen = nc.AddDim( "len", 5 );                       // max length of char strings
    NcDim dimRec = nc.AddDim( "record", data2DSize );           // record dim
    std::vector<NcDim> dimVec;
    dimVec.push_back( dimRec );
    dimVec.push_back( dimLen );
    NcVar varScalar = nc.AddVar( varNames[0], ncChar );         // char of length 1
    NcVar var1D = nc.AddVar( varNames[1], ncChar, dimLen );     // char array of length 5
    var1D.PutAtt( "_FillValue", ' ' );
    NcVar var2D = nc.AddVar ( varNames[2], ncChar, dimVec);     // array of char*
    nc.ToDataMode();
}

//-----------------------------------------------------------------------------
void AddData (NcFile & nc)
{
    NcVar varScalar = nc.GetVar( varNames[0] );
    varScalar.Put( &dataScalar );
    NcVar var1D = nc.GetVar( varNames[1] );
    var1D.Put( data1D );
    NcVar var2D = nc.GetVar( varNames[2] );
    var2D.Put( data2D, data2DSize );
}

//-----------------------------------------------------------------------------
bool ReadAndCompare_Scalar (NcFile & nc)        // returns true if compared ok else false
{
    char data = '\0';
    NcVar varScalar = nc.GetVar( varNames[0] );
    varScalar.Get(&data);
    return ( data == dataScalar );
}

bool ReadAndCompare_1D (NcFile & nc)            // returns true if compared ok else false
{
    NcVar var1D = nc.GetVar( varNames[1] );
    std::string data;
    data.resize( var1D.GetDim(0).Size() );
    var1D.Get( &data[0] );
    return data == data1D;
}

bool ReadAndCompare_2D (NcFile & nc)            // returns true if compared ok else false
{
    NcVar var2D = nc.GetVar( varNames[2] );
    int const numRecords = var2D.GetDim(0).Size();
    char** csa = NULL;
    var2D.Get( csa, numRecords );

    // convert to strings
    std::vector< std::string > strVec;
    netcdf::ToVector( csa, strVec, numRecords );
    netcdf::FreeCStringArray( csa, numRecords );

    // compare
    bool ok = true;
    for ( short i = 0; i < (short)strVec.size(); ++i )
        ok &= ( strVec[i] == data2D[i] );
    return ok;
}

bool ReadAndCompare_Strings (NcFile & nc)               // returns true if compared ok else false
{
    NcVar var2D = nc.GetVar( varNames[2] );
    std::vector< std::string > strVec;
    var2D.Get( strVec );

    // compare
    bool ok = ( (short)strVec.size() == data2DSize );
    for ( short i = 0; i < (short)strVec.size() && ok; ++i )
        ok &= ( strVec[i] == data2D[i] );
    return ok;
}

bool ReadAndCompare_StringAt (NcFile & nc)              // returns true if compared ok else false
{
    NcVar var2D = nc.GetVar( varNames[2] );
    std::string data;
    var2D.Get( 1, data );       // read 2nd string

    // compare
    bool ok = ( data == data2D[1] );
    return ok;
}

std::string const & Test ( bool const result )
{
    static std::string const strs[] = { "passed", "failed" };
    return ( result ? strs[0] : strs[1] );
}

//-----------------------------------------------------------------------------
int main ()
{
    cout << "Test of class NcChar." << endl;
    try
    {
        cout << "Creating file: " << testFileName << endl;
        NcFile nc ( testFileName, NcFile::Replace );
        Create(nc);
        cout << "Adding data" << endl;
        AddData(nc);
        cout << "Reading data and comparing to original:" << endl;
        cout << "  scalar       : " << Test( ReadAndCompare_Scalar(nc) ) << endl;
        cout << "  1D var       : " << Test( ReadAndCompare_1D(nc) ) << endl;
        cout << "  2D var       : " << Test( ReadAndCompare_2D(nc) ) << endl;
        cout << "  std::strings : " << Test( ReadAndCompare_Strings(nc) ) << endl;
        cout << "  string[1]    : " << Test( ReadAndCompare_StringAt(nc) ) << endl;

        cout << "Creating a char array from an NcType object, initialized to Z: ";
        {
            NcChar::value_type* ca = MakeCArray( NcChar(), 5, 'Z' );
            if ( ca[0] == 'Z' && ca[4] == 'Z' )
                cout << "passed" << endl;
            else
                cout << "failed" << endl;
            delete [] ca;
        }
    }
    catch (std::exception const & e)
    {
        cout << "Exception: " << e.what() << endl;
    }
    catch (...)
    {
        cout << "Error: unknown error." << endl;
    }
    cout << "\n   all done!" << endl;
    return 0;
}
//-----------------------------------------------------------------------------