wrapper.c

来自「ST5518机顶盒系统文件系统源代码！绝对超值！」· C语言 代码 · 共 442 行

/******************************************************************************

   File Name : wrapper.c

Description : The file contain the standard test interface wrapper,
              and some general utility functions for avfs tests.

******************************************************************************/


/* we always need some STTBX_PRINT in this file to output the standard pass/fail
  information, but only do other outputs if it is turned on globally */

#ifdef STTBX_PRINT
#define DO_EXTRA_PRINT
#else
#define STTBX_PRINT
#endif


/* Includes ---------------------------------------------------------------- */

#ifndef STTBX_PRINT
#define STTBX_PRINT
#endif

#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>

#include "wrapper.h"

/* Exported Constants ------------------------------------------------------- */

TestPartitionDef_t TestPartitionDefs[4] =
{
    { 4 * GB_SECTORS, RESERVED_SECTORS, 1 },
        
    { 1 * GB_SECTORS, RESERVED_SECTORS + 4*GB_SECTORS, 1 },
        
    { 1 * GB_SECTORS, RESERVED_SECTORS + 5*GB_SECTORS + TEST_PARTITION_PADDING, 2 },
        
    { 1 * GB_SECTORS, RESERVED_SECTORS + 6*GB_SECTORS + TEST_PARTITION_PADDING, 4 },
};


/* Private Types ----------------------------------------------------------- */

/* Private Constants ------------------------------------------------------- */

/* Private Variables ------------------------------------------------------- */


static int DebugState = 0;

/* Private Macros ---------------------------------------------------------- */

#ifdef DO_EXTRA_PRINT
#define EXTRA_Print(x) STTBX_Print(x)
#else
#define EXTRA_Print(x)
#endif


/* Private Function Prototypes --------------------------------------------- */

static int IsInteger (char *);

static TestResult_t ExampleTest(int TestNo, TestVariant_t MaxVariant);

/* Functions --------------------------------------------------------------- */





/******************************************************************************
Function Name : SetWrapperDebug
  Description : 
   Parameters :
******************************************************************************/
void SetWrapperDebug (int On)
{
    DebugState = On;
}




/******************************************************************************
Function Name : StopTest
  Description : Stop the test in interactive mode.
   Parameters :
******************************************************************************/
BOOL StopTest (parse_t * pars_p, char *result_sym_p)
{
    return (TRUE);
}




/******************************************************************************
Function Name : Example
  Description : Example test section function.
   Parameters :
******************************************************************************/
BOOL Example (parse_t * pars_p, char *result_sym_p)
{
    char *Description = "Example test";
    
    TestVariant_t Max = TEST_VARIANT_A;
    
    TestCall_t TestList[] =
    {
        ExampleTest, /* Test 001 */
        NULL,        /* Test 002 */
    };
    
    GenericTest (pars_p, result_sym_p,
                 Description,
                 TestList, TABLE_LEN(TestList)-1,
		 Max);

    return (FALSE);
}






/******************************************************************************
Function Name : ExampleTest
  Description : The actual implementation of the test
   Parameters :
******************************************************************************/
static TestResult_t ExampleTest(int TestNo, TestVariant_t Variant)
{
    if (Variant == TEST_VARIANT_A)
    {
        return(TEST_PASSED);
    }
    else
    {
        return(TEST_FAILED);
    }
}




/******************************************************************************
Function Name : GenericTest
  Description : This implements the generic test structure.
   Parameters :
******************************************************************************/
BOOL GenericTest (parse_t * pars_p, char *result_sym_p, char *Name, TestCall_t * TestList, int MaxTest,
		  TestVariant_t MaxVariant)
{
    char StringArg[16];
    S32 IntArg;
    TestVariant_t VariantArg;

    int FirstTestNo = 0;
    int LastTestNo = MaxTest;
    TestVariant_t FirstVariant = TEST_VARIANT_A;
    TestVariant_t LastVariant = MaxVariant;

    TestResult_t TestResult = TEST_UNKNOWN;

    int TestNo;
    TestVariant_t VariantNo;

    /* Parse the test arguments */

    /* First argument */

    if (STTST_GetItem (pars_p, "", StringArg, sizeof (StringArg) - 1))
    {
	/* No argument */
	StringArg[0] = '\0';
    }

    if (IsInteger (StringArg))
    {
	IntArg = atoi (StringArg) - 1;

	if ((0 > IntArg) || (IntArg > MaxTest))
	{
	    /* Invalid arg */
	}
	else
	{
	    /* Valid arg */

	    FirstTestNo = LastTestNo = IntArg;

	    /* Second argument */
	    if (STTST_GetItem (pars_p, "", StringArg, sizeof (StringArg) - 1))
	    {
		/* No argument */
		StringArg[0] = '\0';
	    }

	    if (IsInteger (StringArg))
	    {
		IntArg = atoi (StringArg) - 1;

		if (IntArg < FirstTestNo)
		    IntArg = FirstTestNo;
		if (IntArg > MaxTest)
		    IntArg = MaxTest;

		LastTestNo = IntArg;

		/* Third argument */
		if (STTST_GetItem (pars_p, "", StringArg, sizeof (StringArg) - 1))
		{
		    /* No argument */
		    StringArg[0] = '\0';
		}
	    }
	}
    }

    /* Current argument */

    if ('\0' != StringArg[0])
    {
	VariantArg = (TestVariant_t) tolower (StringArg[0]);

	if ((0 > VariantArg) || (VariantArg > MaxVariant))
	{
	    /* Invalid arg */
	}
	else
	{
	    /* Valid arg */

	    FirstVariant = LastVariant = VariantArg;

	    /* Next argument */
	    if (STTST_GetItem (pars_p, "", StringArg, sizeof (StringArg) - 1))
	    {
		/* No argument */
		StringArg[0] = '\0';
	    }

	    if ('\0' != StringArg[0])
	    {
		VariantArg = (TestVariant_t) tolower (StringArg[0]);

		if (VariantArg < FirstVariant)
		    VariantArg = FirstVariant;
		if (VariantArg > MaxVariant)
		    VariantArg = MaxVariant;

		LastVariant = VariantArg;
	    }
	}
    }

    STTBX_Print (("SECTION : %s\n\n", Name));

    for (TestNo = FirstTestNo; (TestNo <= LastTestNo); TestNo++)
    {
	STTBX_Print (("    %3d    :", TestNo + 1));

	for (VariantNo = TEST_VARIANT_A; (VariantNo <= MaxVariant); VariantNo++)
	{
	    if ((FirstVariant > VariantNo) || (VariantNo > LastVariant))
	    {
		TestResult = TEST_NOT_RUN;
	    }
	    else if (NULL == TestList[TestNo])
	    {
		TestResult = TEST_NOT_WRITTEN;
	    }
	    else
	    {
		TestResult = (*TestList[TestNo]) (TestNo, VariantNo);
	    }

	    switch (TestResult)
	    {
		case TEST_PASSED:
		    STTBX_Print ((" PASS :"));
		    break;

		case TEST_FAILED:
		    STTBX_Print ((" FAIL :"));
		    break;

		case TEST_UNKNOWN:
		    STTBX_Print ((" UNK  :"));
		    break;

		case TEST_NOT_WRITTEN:
		    STTBX_Print ((" N/W  :"));
		    break;

		case TEST_NOT_APPLICABLE:
		    STTBX_Print ((" N/A  :"));
		    break;

		case TEST_NOT_RUN:
		    STTBX_Print ((" N/R  :"));
		    break;

		default:
		    STTBX_Print ((" <?>  :"));
		    break;
	    }
	}

	STTBX_Print (("\n"));
    }
    STTBX_Print (("\n"));

    return (FALSE);
}





/******************************************************************************
Function Name : IsInteger
  Description : Is the argument an integer string (ie only digits)
   Parameters :
******************************************************************************/
static int IsInteger (char *p)
{
    if (isdigit (*p++))
    {
	/* Posibly an integer */

	/* Are they all digits */

	while (isdigit (*p))
	    p++;
	return ('\0' == *p);
    }
    else
    {
	/* Not enphe digits */
	return (FALSE);
    }
}


/******************************************************************************
Function Name : OpenPartition
  Description : Standard function to open a partition
   Parameters : unit and partition numbers [in], device name [in] and handle [out] for partition
   Notes      : Term-inates device if Init succeeds but Open fails. Does not perform parameter
                    checking except through STAVFS calls
******************************************************************************/
TestResult_t OpenPartition (U16 UnitNum, U16 PartitionNum,
                    ST_DeviceName_t DevName, STAVFS_Handle_t * Handle_p)
{
    TestResult_t Result = TEST_PASSED;

    STAVFS_InitParams_t InitParams;
    STAVFS_OpenParams_t OpenParams;

    strcpy (InitParams.EVTName, EVT_DEVICE_NAME);
    strcpy (InitParams.ATAPIName, ATAPI_DEVICE_NAME);

    InitParams.Flags = 0;
    InitParams.MemoryPartition = system_partition;
    InitParams.Protocol = 1;
    InitParams.UnitNumber = UnitNum;
    InitParams.PartitionNumber = PartitionNum;

    OpenParams.Flags = 0;

    if (ST_NO_ERROR != STAVFS_Init (DevName, &InitParams))
    {
        EXTRA_Print (("Failed to initialise partition \"%s\"\n", DevName));
        Result = TEST_FAILED;
    }
    else
    {
        if (ST_NO_ERROR != STAVFS_FileSystemCheck (DevName, STAVFS_FSCK_DEFAULT))
        {
            EXTRA_Print(("File system check failed\n"));
            Result = TEST_FAILED;
        }
        else if (ST_NO_ERROR != STAVFS_Open (DevName, &OpenParams, Handle_p))
        {
            EXTRA_Print (("Failed to open partition \"%s\"\n", DevName));
            Result = TEST_FAILED;
        }
        
        if (Result == TEST_FAILED)
        {
            STAVFS_TermParams_t TermParams;
            TermParams.Flags = 0;

            if (ST_NO_ERROR != STAVFS_Term (DevName, &TermParams))
            {
                EXTRA_Print (("Failed to terminate partition \"%s\"\n", DevName));
            }
        }
    }

    return (Result);
}


/******************************************************************************
Function Name : ClosePartition
  Description : Standard function to Close and Term-inate a partition
   Parameters : device name and handle [in]
******************************************************************************/
TestResult_t ClosePartition (ST_DeviceName_t DevName, STAVFS_Handle_t Handle)
{
    TestResult_t Result = TEST_PASSED;

    STAVFS_TermParams_t TermParams;
    TermParams.Flags = 0;

    /* nb the following call is optional here, since Term is supposed to automatically
      close any open handles */
    if (ST_NO_ERROR != STAVFS_Close (Handle))
    {
        EXTRA_Print(("Failed to close partition \"%s\"\n", DevName));
        Result = TEST_FAILED;
    }

    if (ST_NO_ERROR != STAVFS_Term(DevName, &TermParams))
    {
        EXTRA_Print (("Failed to terminate partition \"%s\"\n", DevName));
        Result = TEST_FAILED;
    }

    return (Result);
}