One of the things I’ve really enjoyed is learning little things about places I want to go and see. In Malaysia on the island of Borneo there is a train route and a couple of the stations can’t be found in Google maps. They have a name and that is all. The rail site claims they stop there but from the terrain and satellite view it appears like a mountainous tree filled valley. I want to go there.

Another is the TranzAlpine train route in New Zealand that winds between mountains and by riverbeds. I’m sure it will be breathtaking journey.

To help with exploring, I have an upcoming feature that will show flickr photos that are within 10kms of a train station. Here is an example of how google does it now with panaramio.

So I built trainlines.heroku.com

It’s an open repository of train routes. I’ve got regional australia, new zealand and hong kong, malaysia, singapore and the philippines on there at the moment. Google clustering takes care of visualisations at zoom levels so any level of route (metro, regional, international) can be supported but I do have an emphasis on regional and international routes. If you want to add a train route go right ahead.

If you can think of a suggestion to make it easier to use, let me know and I’ll consider it. For the meantime it’s feature complete (minus a few known issues).

For the testers out there that I know, if you feel the urge to break it, please go to trainlines-preprod.heroku.com and do your worst.

One of the questions missed is what is the right model for the business? An in-house software development shop providing for an organisation then may not have a choice about what is right. Some organisations don’t care what model is used or if any process is used at all. They control the money, which projects are initiated, stopped, started and when, they control the deadlines and the requirements. Through all of this they also control the quality.

In such cases picking any model is pointless because it’s going to fail. These models are not about software development; they are about business engagement and software development. Trying to control how the business engages with you via a model when they have their own model, and adhoc is a model, is pointless. They always win. It’s their money.

This leaves you with two options: get the business to change or come up with your own model that uses the current business engagement model.

The first option is the hardest; you may not be empowered to make such changes and the business may not want to change. This is where strong IT leadership from the CIO is needed. The second option is the short term solution. The goal is to achieve as much as you can knowing what you don’t control. With this in mind you can at least solve the pain points between your team and the other stakeholders involved in creating the software.

Obviously they have never had to debug code before.

I just raised a bug with cakephp that has had me confused for about a month now but it wasn’t a blocker. It became one and after almost two days of debugging and fishing for red herrings I finally uncovered the cause of my grief.

It turns out that it was a full-stop.

Let me explain the problem. The user would be successfully validated and then redirected to their home page. But would be logged out by the time they got there.

It turns out that when the session.cookie variable has a full-stop in it doesn’t retain the session information. The authentication part still works so as I was debugging it I was seeing code that works great. On the next request it was pretending like there was no session information. Tracing it back to the session.cookie configuration option took a while.

This isn’t a post about cakephp having bugs; most software has bugs and cakephp is generally good to work with.

This is about implicit dependencies in integration problems. The cakephp people may come back and say that this isn’t an issue and I should stop putting full-stops in my session cookie names… oh wait I haven’t even finished this article and they already have.

Let me tell another story; I was asked to test a service that was responsible for auditing. Other services would call this service to audit. I said there was not enough time to test it before the release and I was going on six weeks leave. They had business approval to go without auditing so that was the safe option.

I come back 6 weeks later and find auditing had gone to production without being tested.

Apparently without issue.

The first test I run finds that the consuming services are putting null in the source column so all audit records are being written and you can’t tell where they came from. Not a big issue as we only have 40 services. End sarcasm.

I raised the issue with the auditing service developer and he responded. “This isn’t a bug, it is the responsibility of a service to populate the source property”.

He is correct in one regard. But he is also wrong in another.

His service shouldn’t let the consuming services fail. They depend on the auditing service to let them know when they get it wrong.

A null source value is an invalid record as per the business and the auditing service should not allow invalid audit records to exist. Therefore bug.

A session cookie name with a fullstop is invalid as per cakephp code components and cakephp should not allow invalid session cookie names. Therefore to maintain the integrity of the system cakephp should ensure that it’s dependencies are correct.

Some frameworks like CakePHP provide behaviours which is a discrete behaviour that can be applied to any Model. This option was close but didn’t feel right. I wanted to be more explicit about my behaviours.

So what I did was abstract out common methods into interfaces that use the convention ISupport…

An example is ISupportDeletion which has the following contract:

interface ISupportDeletion
{
    public function Delete ($Id) ;
}

Another example is the ISupportCollections contract:

interface ISupportCollections
{
    public function GetAll ($Page) ;
    public function GetAllCount () ;
    public function GetList ($List, $Page) ;
    public function GetListCount ($List) ;
}

The model then inherits these contracts piecing together promised behaviour from the setting of contracts. I had original thought that the model should only implement interfaces and never add new methods; but this would be pointless as each model would need to implement an interface designed for itself, which is extra coding for no benefit.

class User extends Model implements ISupportDeletion, ISupportObjectAccess
{
}

So there are a bunch of contracts that a model can support:

• ISupportActiveInactive
• ISupportCollections
• ISupportDefaultState
• ISupportDeletion
• ISupportFilteredCollections
• ISupportObjectAccess
• ISupportSuspendedState
• ISupportHistory
• ISupportComments
• ISupportTags
• ISupportVersioning

And as I come up with behaviour that belongs to more than one model then it’ll become a supported behaviour.

The idea is that the model is really just content but in my MVC setup I require the model manage its own behaviour. This is to stop data oriented code being scattered across the controllers. The controller defines user interaction while the model defines data interaction. Interactions have behaviour and common behaviours are defined in ISupport contracts.

Having an interface isn’t enough and does need to be implemented. This is where the behaviour implementations come in. For each ISupport contract there are one or more implementations of behaviour.

For example ISupportDeletion is implemented in two ways

• LogicalDeleteBehaviour
• PhysicalDeleteBehaviour

From the perspective of the controller it doesn’t care how the model implements the ISupportDeletion contract as long as it does. My user model requires logical deletion whilst most other models require physical deletion.

Let’s take a look at the User model cut down to only support deletion

class User extends Model implements ISupportDeletion
{
    protected $LogicalDeleteBehaviour = null ;

    public function __construct ()
    {
        parent::__construct () ;

        $this->LogicalDeleteBehaviour = new LogicalDeleteBehaviour ($this) ;
    }

    public function Delete ($id)
    {
        return $this->LogicalDeleteBehaviour->Delete ($id) ;
    }
}

As shown the constructer instantiates our logical delete behaviour and accepts the model itself as input. This is needed because the behaviour provides an implementation but is dependent on information in the model. So we dependency inject the model in.

If we were worried about the foot print of these behaviours we could delay their instantiation until needed. The delete operation is nothing more complicated then delegation to the behaviour.

Our behaviours are similar to the command pattern and when the need arises to provide undo support it could be implemented in the behaviour rather than each model.

Let’s take a look at a behaviour implementation:

class LogicalDeleteBehaviour extends Behaviour implements ISupportDeletion
{
    protected $model = null ;

    public function __construct ($model)
    {
        parent::__construct () ;

        $this->model = $model ;
    }

    /**
    * Logically deletes the record for the model
    */
    public function Delete ($Id)
    {
        if (!$Id)
        {
            return false ;
        }

        $qs = (
            "UPDATE " . $this->model->GetTable() . " " .
            "SET date_logically_deleted = NOW()" . " " .
            "WHERE " . $this->model->GetPK() . " = " . $Id . " " .
            "AND date_logically_deleted IS NULL"
        ) ;

        $this->model->query ($qs) ;

        return true ;
    }
}

The injection of the model is purely required to get the table name and the pk for the model although it could be assumed as id.

I’ve used inline SQL here but we could be calling a stored proc which would be preferred.

The physical deletion behaviour is not too different:

class PhysicalDeleteBehaviour extends Behaviour implements ISupportDeletion
{
    protected $model = null ;

    public function __construct ($model)
    {
        parent::__construct () ;

        $this->model = $model ;
    }

    /**
    * physically deletes the record for the model
    */
    public function Delete ($Id)
    {
        if (!$Id)
        {
            return false ;
        }

        $qs = (
            "DELETE FROM " . $this->model->GetTable() . " " .
            "WHERE " . $this->model->GetPK() . " = " . $Id
        ) ;

        $this->model->query ($qs) ;

        return true ;
    }
}

Testing

So this just helps us implement behaviour more easily but the big benefit for me was to also simplify the number of tests I had to write. Tests needed to be written in three places:

• Against the behaviour
• To prove the model implements the behaviour
• Integration tests against the model involving multiple behaviours

Against the behaviour

These were unit tests against the ISupport contract to prove the implementation of the behaviour. So for the ISupportDeletion contract the following tests were written:

• Is Already Deleted
• Is Not Currently Deleted
• ID Not Supplied
• ID Does Not Exist

These were encapsulated in a test set object. These tests were written also using dependency injection to provide the model, the implementation and the test runner which contained methods for creating records, etc.

It’s all very abstract but a test reads like this:

protected function IsNotDeleted ()
{
    $this->runner->fixtureEmptyTable ($this->model, $this->table) ;
    $Id = $this->runner->{$this->CreateOperation}($this->model) ;

    $result = $this->model->Delete($Id) ;

    $this->runner->assertTrue ($result) ;
    $this->runner->assertFalse ($this->model->DoesExist ($Id)) ;
}

To test the Model implements Behaviour

Having tested the behaviour is a good start but we haven’t proven the model is even using that behaviour. So we need some tests against the model the proves that it supports the contract. The test looks like this:

function test_ISupportDeletion_Delete ()
{
    $this->UserTest =& new UserTest () ;

    $behaviourTestSet =& new ISupportDeletion_Delete_TestSet ($this, $this->UserTest, 'fixtureCreateUniqueUser');

    $behaviourTestSet->ExecuteTestSet () ;
}

We instantiate our User object for testing. We then create an instance of the behaviour test set passing in the test runner and the model. We then execute the behaviour test set using the model. This proves the model supports the contract assuming all tests pass.

Behaviour Integration Tests

Finally we have scenarios were you want to test logical delete behaviour with the object access behaviour. Object access provides a “Get” operation but given our understanding of what logical deletion is; the get should not return anything.

The behaviour test set for Get can’t handle this because it doesn’t know if the model uses physical or logical delete if it even supports delete.

So we write integration tests for this:

function test_ISupportObjectAccess_Get_Deleted ()
{
    $this->UserTest =& new UserTest () ;
    $this->fixtureEmptyTable ($this->UserTest, $this->UserTest->GetTable ()) ;

    $Id = $this->fixtureCreateUniqueUser ($this->UserTest) ;
    $this->UserTest->Delete ($Id) ;

    $result = $this->UserTest->Get ($Id) ;
    $this->assertFalse ($result) ;
}

These are just our normal tests that are written from the perspective of the model.

Finally before I go here are some diagrams of how the various objects inherit/interact with each other.

Interaction Contract Usage

Model Inheritance & Interaction Contracts

Behaviour Interaction Contracts

The first parameter is a char* pointer that is your source text. The next two are your find and replace char* pointers.

The result is returned to the caller as a pointer but you won’t have to worry about the memory as it is owned by HP Service Test.

const char* FindAndReplace (const char* Source, const char* const Find,const char* const Replace)
{
    //start by pointing to the start of the string
    long LengthOfSource = strlen (Source) ;
    long LengthOfStringToReplace = strlen (Find) ;

    char* LastFoundStart = (char*) Source ;
    char* NextFoundStart = 0 ;
    char* Buffer = 0 ;

    lr_set (Replace, "__FindAndReplace_Replace") ;
    lr_set ("", "__FindAndReplace_New") ;

The code looks for a substring and and replaces when found. It then jumps past that string before trying again. This is to avoid a scenario where our replaced string contains out find string and we get into a loop until memory expires.

    while (NextFoundStart = (char*) strstr (LastFoundStart, Find))
    {
        //Allocate a buffer to copy our string into. We want from LastFoundStart to NextFoundStart
        Buffer = (char*) malloc ( (NextFoundStart - LastFoundStart + 1) * sizeof (char)) ;

        //copy from LastFoundStart to NextFoundStart in to our new paramtere
        memcpy (Buffer, Source, (NextFoundStart - LastFoundStart) * sizeof (char)) ;

        //null terminate the string
        Buffer[(NextFoundStart - LastFoundStart) * sizeof (char)] = '\0' ;

        //Move our LastFoundStart to the end of the replaced string
        LastFoundStart = NextFoundStart + LengthOfStringToReplace ;

        //Copy our buffer into our new parameter
        lr_set (Buffer, "__FindAndReplace_Buffer") ;

        lr_set (lr_get ("{__FindAndReplace_New}{__FindAndReplace_Buffer}{__FindAndReplace_Replace}"), "__FindAndReplace_New") ;

        //tidy up for next round
        free (Buffer) ;
        Buffer = 0 ;
        lr_set ("", "__FindAndReplace_Buffer") ;
    }

Somewhat repeated code… because I’m somewhat lazy.

    NextFoundStart = ( (char*) Source) + LengthOfSource ;
    if (LastFoundStart != NextFoundStart)
    {
        //we still need to copy data
        //once we have found all our matches we need to copy the end of the string from the end of the last
        // find to the end of the string... assuming the last match was not at the end of the string
        //Allocate the final buffer
        Buffer = (char*) malloc ( (NextFoundStart - LastFoundStart + 1) * sizeof (char)) ;

        //copy from LastFoundStart to NextFoundStart in to our new paramtere
        memcpy (Buffer, LastFoundStart, (NextFoundStart - LastFoundStart) * sizeof (char)) ;

        //null terminate the string
        Buffer[(NextFoundStart - LastFoundStart) * sizeof (char)] = '\0' ;

        //Copy our buffer into our new parameter
        lr_set (Buffer, "__FindAndReplace_Buffer") ;

        lr_set (lr_get ("{__FindAndReplace_New}{__FindAndReplace_Buffer}"), "__FindAndReplace_New") ;

        //tidy up for next round
        free (Buffer) ;
        Buffer = 0 ;
        lr_set ("", "__FindAndReplace_Buffer") ;
    }

    return lr_get ("{__FindAndReplace_New}") ;
}

Get Event

void GetEvent (const char* EventId, const char* Event)
{
    if (!ExceptionReportingEnabled ())
    {
        //only check for exceptions if we are supposed to

        return ;
    }

    lr_save_string (EventId, "__EventId") ;

    Create_GetEvent_BatchFile (EventId) ;

    system ("ServiceTest.bat") ;

    ReadFile (lr_eval_string("{TempFile}"), "FileData", "ISO-10646-UCS-2") ;

    lr_xml_extract
    (
        "XML={FileData}",
        "FastQuery=ROOT/ROW",
        "XMLFragmentParam=__Event",
        "NotFound=Continue",
        LAST
    );

    lr_save_string (lr_eval_string ("{__Event}"), Event) ;
}

The follow function is used to create a batch file. This is the best option that trying to call the LogParser directly from the command line.

void Create_GetEvent_BatchFile (const char* EventId)
{
    long FileHandle = 0 ;

    lr_set (EventId, "__EventId") ;

    lr_set
    (
        lr_get
        (
            "\"\\\\vcclfs02-data1\\Wessupp\\Applications Test Team\\ServiceTest\\Tools\\Log Parser 2.2\\LogParser.exe\" -i:EVT -o:xml -schemaType:0 -compact -oCodepage:0
            \"SELECT
                EventLog,
                RecordNumber,
                TimeGenerated,
                TimeWritten,
                EventId,
                EventType,
                EventTypeName,
                EventCategory,
                EventCategoryName,
                SourceName,
                ComputerName,
                SID,
                Message
            INTO
                {TempFile}
            FROM
                \\\\{Server}\\{EventLogSource}
            WHERE
                RecordNumber = '{__EventId}'\""
        ),
        "__Create_GetEvent_BatchFile"
    ) ;

    lr_set (lr_get ("{__Create_GetEvent_BatchFile}"), "__ServiceTest_LastBatchBody") ;

    FileHandle = fopen("ServiceTest.bat", "w") ;
    if (!FileHandle)
    {
        lr_error_message ("Unable to create the \"ServiceTest.bat\" file.") ;

        return ;
    }

    fprintf (FileHandle, lr_get ("{__Create_GetEvent_BatchFile}")) ;
    fclose (FileHandle) ;
}

Get Most Recent Event Record Number

If we wanted to get the highest record number in the log at the current point in time; use this log parser call in the batch file.

lr_set
(
    lr_get
    (
        "\"\\\\vcclfs02-data1\\Wessupp\\Applications Test Team\\ServiceTest\\Tools\\Log Parser 2.2\\LogParser.exe\" -i:EVT -o:xml -schemaType:0 -compact -oCodepage:0
        \"SELECT
            MAX(RecordNumber)
        INTO
            {TempFile}
        FROM
            \\\\{Server}\\{EventLogSource}
        WHERE
            SourceName = '{FullServiceName}'\""
    ),
    "__Create_GetMostRecentEventRecordNumber_BatchFile"
) ;

Call like GetEvent above but you should trim the response so it can be cast as a number

void GetMostRecentEventRecordNumber (HpParameter StartEventCount)
{
    if (!ExceptionReportingEnabled ())
    {
        //only check for exceptions if we are supposed to
        return ;
    }

    Create_GetMostRecentEventRecordNumber_BatchFile () ;

    system ("ServiceTest.bat") ;

    ReadFile (lr_eval_string("{TempFile}"), "FileData", "UTF-8") ;

    lr_xml_get_values
    (
        "XML={FileData}",
        "FastQuery=ROOT/ROW/MAX_ALL_RecordNumber_",
        "ValueParam=__GetMostRecentEventRecordNumber_StartEventCount",
        "NotFound=Continue",
        LAST
    );

    Trim (lr_get("{__GetMostRecentEventRecordNumber_StartEventCount}"), StartEventCount)  ;
}

—

Implementing the trim function barely gets a mention in languages these days because having to implemented it in a new language is stoopid. However C is old and grizzled.

This version stores the result in a HP Paramater for use outside the function. You could return it if you wanted. If you did you would need to remove the free statement.

void Trim (const char* Bloated, const char* Parameter)
{
    long BloatedLength = strlen (Bloated) ;

    char* Trimmed = 0 ;
    long TrimmedLength = 0 ;

    long TrimFromStart = strspn (Bloated, " \t") ;
    long TrimFromEnd = 0 ;

    long index = 0 ;

We need to calculate the number of characters that are white space at the end of the string. This ignores new line characters.

    //Count Trailing whitespace
    index = BloatedLength - 1 ;
    while ( (Bloated[index] == ' ') || (Bloated[index] == '\t'))
    {
        TrimFromEnd++ ;

        if (index == 0)
        {
            break ;
        }

        index-- ;
    }

    TrimmedLength = BloatedLength - TrimFromEnd - TrimFromStart ;
    TrimmedLength++ ; //space for null terminating

    Trimmed = (char*) malloc (TrimmedLength * sizeof(char)) ;
    if (!Trimmed)
    {
        lr_error_message("Failed to allocate memory for the trimmed string") ;

        return ;
    }

Our actual trim is nothing more than memcpy so you could write a substring function and do it that way.

    //"trim"
    memcpy (Trimmed, Bloated + TrimFromStart, TrimmedLength) ;

    //set null terminating char
    Trimmed[TrimmedLength - 1] = '\0' ;

    lr_set (Trimmed, Parameter);

    free (Trimmed) ;
}

Here are some of my favourite string functions for use within service tests.

Get Random String of Length

enum GetStringOfLengthTypes
{
    AlphaOnly,
    NumericOnly,
    AlphaNumeric
} ;

const char* GetStringOfLength (const unsigned int length, const unsigned int Type)
{
    unsigned int i = 0 ;
    static const char Alpha[] = "abcdefghijklmnopqrstuvwxyz"
                                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    static const char Numeric[] = "0123456789" ;
    static const char AlphaNumeric[] = "abcdefghijklmnopqrstuvwxyz"
                                                    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                                    "0123456789" ;

    char* Value = (char*) malloc ( (sizeof(char) * length) + 1) ;

SrandSingleton is a global integer that is defaulted to zero. It represents a ’singleton’ object.

    if (SrandSingleton == 0)
    {
        srand (time (NULL)) ;
        SrandSingleton = 1 ;
    }

    for (i = 0; i < length; i++)
    {
        switch (Type)
        {
        case 0:
            Value[i] = Alpha[rand() % (sizeof (Alpha) - 1)] ;
            break ;
        case 1:
            Value[i] = Numeric[rand() % (sizeof (Numeric) - 1)] ;
            break ;
        case 2:
            Value[i] = AlphaNumeric[rand() % (sizeof (AlphaNumeric) - 1)] ;
            break ;
        }
    }

    Value[length] = '\0' ;

    lr_get (Value, "__GetStringOfLength_Total") ;

    free (Value) ;

    return lr_get ("{__GetStringOfLength_Total}") ;
}

String is Empty?

enum EnabledOptions StringIsEmpty (const char* const a)
{
    if (strcmp (a, "") == '\0')
    {
        return Yes ;
    }
    else
    {
        return No ;
    }
}

Strings are Equal?

enum EnabledOptions StringsAreEqual (const char* const a, const char* const b)
{
    if (strcmp (a, b) == '\0')
    {
        return Yes ;
    }
    else
    {
        return No ;
    }
}

Is In String?

enum EnabledOptions IsInString (const char* const Source, const char* const Find)
{
    if (strstr (Source, Find) == 0)
    {
        return No ;
    }
    else
    {
        return Yes ;
    }
}

Does Registry Path Exist?

void CheckRegistryPathExists (const char* const Server, const char* const SubKey)
{
    const char LineSeperators[] = "\n" ;
    const char LinePartSeperators[] = "\t" ;
    char* LineToken;
    char* LinePartToken ;
    char* NextPartToken ;

    lr_set (Server, "__CheckRegistryValue_Server") ;
    lr_set (SubKey, "__CheckRegistryValue_SubKey") ;

Run the REG Query command and pipe the results into a temporary file.

    system
    (
        lr_get
        (
            "REG QUERY \"\\\\{__CheckRegistryValue_Server}\\{__CheckRegistryValue_SubKey}\" > {TempFile}"
        )
    ) ;

Read temp file in and look for the exact string specified below. If there is no registry value found then it writes a specific error message out. We can use this to determine whether our value exists in the registry.

    ReadFile (lr_get ("{TempFile}"), "RegExtract", "UTF-8") ;

    if (strstr (lr_get ("{RegExtract}"), "Error:  The system was unable to find the specified registry key or value") != '\0')
    {
        lr_error_message (lr_get ("The supplied registry path ({__CheckRegistryValue_Server}\\{__CheckRegistryValue_SubKey}) does not exist")) ;
    }
}

Check Registry Value

void CheckRegistryValue (const char* Server, const char* SubKey, const char* Property, const char* ExpectedValue)
{
    const char LineSeperators[] = "\n" ;
    const char LinePartSeperators[] = "\t" ;
    char* LineToken;
    char* LinePartToken ;
    char* NextPartToken ;

    lr_set (Server, "__CheckRegistryValue_Server") ;
    lr_set (SubKey, "__CheckRegistryValue_SubKey") ;
    lr_set (Property, "__CheckRegistryValue_Property") ;

    system
    (
        lr_get
        (
            "REG QUERY \"\\\\{__CheckRegistryValue_Server}\\{__CheckRegistryValue_SubKey}\" /v {__CheckRegistryValue_Property} > {TempFile}"
        )
    ) ;

    ReadFile (lr_get ("{TempFile}"), "RegExtract", "UTF-8") ;

There is a “standard” format for the REG query output.

    //Format for Reg output
    //    blank line
    //    declaration
    //    blank line
    //    path
    //    property type value

Tokenise the string and then parse it to get the value.

    LineToken = (char *)strtok(lr_get ("{RegExtract}"), LineSeperators); // Get the first token
    if (!LineToken)
    {
        lr_error_message ("Registry Value Not Found (No tokens found in string!)") ;
        return ;
    }

    while (LineToken != NULL)
    {
        // Find line that contains the property
        if (strstr (LineToken, lr_get ("{__CheckRegistryValue_Property}")) > 0)
        {
            //The format of the line is "property[\t]type[\t]value"
            LinePartToken = (char *)strtok(LineToken, LinePartSeperators); // Get the first token
            if (!LinePartToken)
            {
                lr_error_message ("Registry Value Not Found (No tokens found in string!)") ;
                return ;
            }

            while (LinePartToken != NULL)
            {
                NextPartToken = LinePartToken ;
                LinePartToken = (char *) strtok (NULL, LinePartSeperators) ;
            }

            //we have the last token in 'Next' so use that
            Trim (NextPartToken, "ActualValue") ;
            TrimNewLine (lr_get ("{ActualValue}"), "ActualValue") ;

            CompareStrings (lr_get ("{ActualValue}"), ExpectedValue) ;

            return ;
        }

        LineToken = (char *) strtok (NULL, LineSeperators) ;
    }

    lr_error_message ("Registry Value Not Found") ;
}