**FREE

//=====================================================================
//
// Program......: MEDDFNTSTP
//
// Description..: MEDDFN Builder / Parser Test Program
//
// Erstellen mit:
//
// CRTRPGMOD MODULE(GOSCH1/MEDDFNTSTP)
//           SRCSTMF('/home/GOSCH/meddfn/meddfntstp.rpgle')
//           OPTION(*EVENTF)
//           DBGVIEW(*SOURCE)
//           TGTRLS(*CURRENT)
//
// CRTPGM PGM(GOSCH1/MEDDFNTSTP)
//        MODULE(GOSCH1/MEDDFNTSTP)
//        BNDSRVPGM(GOSCH1/MEDDFNSRV)
//        ACTGRP(*NEW)
//        TGTRLS(*CURRENT)
//
//=====================================================================

ctl-opt
   option(*srcstmt:*nodebugio);


/COPY './meddfn_h.rpgle'
/COPY './meddfnap_h.rpgle'
/COPY './meddfnpr.rpgle'


//=====================================================================
//
// Data
//
//=====================================================================

dcl-ds MediaDefinition
   likeds(MD_MediaDefinition_T);

dcl-ds OriginalDefinition
   likeds(MD_MediaDefinition_T);

dcl-ds Error
   likeds(MD_Error_T);

dcl-s DeviceIndex int(10);
dcl-s MediaIndex  int(10);
dcl-s VolumeIndex int(10);


//=====================================================================
//
// Prototypes
//
//=====================================================================

dcl-pr BuildTestDefinition;
end-pr;


//=====================================================================
//
// Main
//
//=====================================================================

BuildTestDefinition();


//---------------------------------------------------------------------
// Vorhandene MEDDFN löschen
//---------------------------------------------------------------------

dsply '----------------------------------------';
dsply 'MEDDFN Parser Test';
dsply '----------------------------------------';

dsply 'Deleting existing MEDDFN...';

monitor;

   clear Error;

   MD_DeleteMediaDefinition(
      MediaDefinition :
      Error);

   dsply 'Delete completed';

on-error;

   dsply 'No existing MEDDFN deleted';

endmon;


//---------------------------------------------------------------------
// MEDDFN erstellen
//---------------------------------------------------------------------

dsply 'Creating MEDDFN...';

clear Error;

MD_CreateMediaDefinition(
   MediaDefinition :
   Error);

dsply 'Create completed';


//---------------------------------------------------------------------
// Originaldefinition sichern
//---------------------------------------------------------------------

OriginalDefinition = MediaDefinition;


//---------------------------------------------------------------------
// MEDDFN lesen
//---------------------------------------------------------------------

dsply 'Retrieving MEDDFN...';

clear Error;

MD_RetrieveMediaDefinition(
   MediaDefinition :
   Error);

dsply 'Retrieve completed';


//=====================================================================
// Tests
//=====================================================================

dsply '----------------------------------------';
dsply 'Parser result';
dsply '----------------------------------------';


//=====================================================================
// General
//=====================================================================

if MediaDefinition.MediaDefinitionName =
      OriginalDefinition.MediaDefinitionName;

   dsply 'PASS MediaDefinitionName';

else;

   dsply 'FAIL MediaDefinitionName';

endif;


if MediaDefinition.LibraryName =
      OriginalDefinition.LibraryName;

   dsply 'PASS LibraryName';

else;

   dsply 'FAIL LibraryName';

endif;


if MediaDefinition.NumberOfDevices =
      OriginalDefinition.NumberOfDevices;

   dsply 'PASS NumberOfDevices';

else;

   dsply 'FAIL NumberOfDevices';

endif;


if MediaDefinition.TextDescription =
      OriginalDefinition.TextDescription;

   dsply 'PASS TextDescription';

else;

   dsply 'FAIL TextDescription';

endif;


if MediaDefinition.DeviceAllocation =
      OriginalDefinition.DeviceAllocation;

   dsply 'PASS DeviceAllocation';

else;

   dsply 'FAIL DeviceAllocation';

endif;


if MediaDefinition.SaveFormat =
      OriginalDefinition.SaveFormat;

   dsply 'PASS SaveFormat';

else;

   dsply 'FAIL SaveFormat';

endif;


if MediaDefinition.MaximumParallelResources =
      OriginalDefinition.MaximumParallelResources;

   dsply 'PASS MaximumParallelResources';

else;

   dsply 'FAIL MaximumParallelResources';

endif;


if MediaDefinition.MinimumParallelResources =
      OriginalDefinition.MinimumParallelResources;

   dsply 'PASS MinimumParallelResources';

else;

   dsply 'FAIL MinimumParallelResources';

endif;


//=====================================================================
// Devices
//=====================================================================

for DeviceIndex = 1
   to OriginalDefinition.NumberOfDevices;

   dsply '----------------------------------------';

   dsply ('Device ' +
      %char(DeviceIndex));


   //------------------------------------------------------------------
   // Device Name
   //------------------------------------------------------------------

   if MediaDefinition.Device(DeviceIndex).DeviceName =
         OriginalDefinition.Device(DeviceIndex).DeviceName;

      dsply ('PASS D' +
         %char(DeviceIndex) +
         ' DeviceName');

   else;

      dsply ('FAIL D' +
         %char(DeviceIndex) +
         ' DeviceName');

   endif;


   //------------------------------------------------------------------
   // Number of Media Files
   //------------------------------------------------------------------

   if MediaDefinition.Device(DeviceIndex).NumberOfMediaFiles =
         OriginalDefinition.Device(DeviceIndex).NumberOfMediaFiles;

      dsply ('PASS D' +
         %char(DeviceIndex) +
         ' NumberOfMediaFiles');

   else;

      dsply ('FAIL D' +
         %char(DeviceIndex) +
         ' NumberOfMediaFiles');

   endif;


   //==================================================================
   // Media Files
   //==================================================================

   for MediaIndex = 1
      to OriginalDefinition.Device(DeviceIndex).NumberOfMediaFiles;

      dsply ('Media File ' +
         %char(MediaIndex));


      //----------------------------------------------------------------
      // Sequence Number
      //----------------------------------------------------------------

      if MediaDefinition.Device(DeviceIndex)
            .MediaFile(MediaIndex)
            .SequenceNumber =
         OriginalDefinition.Device(DeviceIndex)
            .MediaFile(MediaIndex)
            .SequenceNumber;

         dsply ('PASS D' +
            %char(DeviceIndex) +
            ' M' +
            %char(MediaIndex) +
            ' SequenceNumber');

      else;

         dsply ('FAIL D' +
            %char(DeviceIndex) +
            ' M' +
            %char(MediaIndex) +
            ' SequenceNumber');

      endif;


      //----------------------------------------------------------------
      // Starting Position In File
      //----------------------------------------------------------------

      if MediaDefinition.Device(DeviceIndex)
            .MediaFile(MediaIndex)
            .StartingPositionInFile =
         OriginalDefinition.Device(DeviceIndex)
            .MediaFile(MediaIndex)
            .StartingPositionInFile;

         dsply ('PASS D' +
            %char(DeviceIndex) +
            ' M' +
            %char(MediaIndex) +
            ' StartPosition');

      else;

         dsply ('FAIL D' +
            %char(DeviceIndex) +
            ' M' +
            %char(MediaIndex) +
            ' StartPosition');

      endif;


      //----------------------------------------------------------------
      // Number Of Volume Identifiers
      //----------------------------------------------------------------

      if MediaDefinition.Device(DeviceIndex)
            .MediaFile(MediaIndex)
            .NumberOfVolumeIdentifiers =
         OriginalDefinition.Device(DeviceIndex)
            .MediaFile(MediaIndex)
            .NumberOfVolumeIdentifiers;

         dsply ('PASS D' +
            %char(DeviceIndex) +
            ' M' +
            %char(MediaIndex) +
            ' NumberOfVolumes');

      else;

         dsply ('FAIL D' +
            %char(DeviceIndex) +
            ' M' +
            %char(MediaIndex) +
            ' NumberOfVolumes');

      endif;


      //===============================================================
      // Volume Identifiers
      //===============================================================

      for VolumeIndex = 1
         to OriginalDefinition.Device(DeviceIndex)
               .MediaFile(MediaIndex)
               .NumberOfVolumeIdentifiers;

         if MediaDefinition.Device(DeviceIndex)
               .MediaFile(MediaIndex)
               .VolumeIdentifier(VolumeIndex)
               .VolumeIdentifier =
            OriginalDefinition.Device(DeviceIndex)
               .MediaFile(MediaIndex)
               .VolumeIdentifier(VolumeIndex)
               .VolumeIdentifier;

            dsply ('PASS D' +
               %char(DeviceIndex) +
               ' M' +
               %char(MediaIndex) +
               ' V' +
               %char(VolumeIndex));

         else;

            dsply ('FAIL D' +
               %char(DeviceIndex) +
               ' M' +
               %char(MediaIndex) +
               ' V' +
               %char(VolumeIndex));

         endif;

      endfor;

   endfor;

endfor;


//=====================================================================
// Test completed
//=====================================================================

dsply '----------------------------------------';
dsply 'Parser test completed';
dsply '----------------------------------------';


//=====================================================================
// End
//=====================================================================

*inlr = *on;
return;


//=====================================================================
//
// BuildTestDefinition
//
// Builds a TAPE0200 test definition with:
//
//   Device 1
//      Media File 1 -> 0 Volumes
//      Media File 2 -> 1 Volume
//      Media File 3 -> 3 Volumes
//
//   Device 2
//      Media File 1 -> 1 Volume
//      Media File 2 -> 3 Volumes
//
//=====================================================================

dcl-proc BuildTestDefinition;

   dcl-pi *n;
   end-pi;


   clear MediaDefinition;


   //---------------------------------------------------------------
   // General
   //---------------------------------------------------------------

   MediaDefinition.MediaDefinitionName =
      'TEST0200X';

   MediaDefinition.LibraryName =
      'GOSCH1';

   MediaDefinition.TextDescription =
      'Test MEDDFN';

   MediaDefinition.MaximumParallelResources =
      2;

   MediaDefinition.MinimumParallelResources =
      2;

   MediaDefinition.DeviceAllocation =
      MD_DeviceAllocateAll;

   MediaDefinition.SaveFormat =
      MD_SaveFormatParallel;

   MediaDefinition.NumberOfDevices =
      2;


   //=================================================================
   // Device 1
   //=================================================================

   MediaDefinition.Device(1).DeviceName =
      'TAPMLBBRMS';

   MediaDefinition.Device(1).NumberOfMediaFiles =
      3;


   //---------------------------------------------------------------
   // Device 1 / Media File 1
   // 0 Volumes
   //---------------------------------------------------------------

   MediaDefinition.Device(1)
      .MediaFile(1)
      .SequenceNumber =
         0;

   MediaDefinition.Device(1)
      .MediaFile(1)
      .StartingPositionInFile =
         *ALL'0';

   MediaDefinition.Device(1)
      .MediaFile(1)
      .NumberOfVolumeIdentifiers =
         0;


   //---------------------------------------------------------------
   // Device 1 / Media File 2
   // 1 Volume
   //---------------------------------------------------------------

   MediaDefinition.Device(1)
      .MediaFile(2)
      .SequenceNumber =
         1;

   MediaDefinition.Device(1)
      .MediaFile(2)
      .StartingPositionInFile =
         *ALL'1';

   MediaDefinition.Device(1)
      .MediaFile(2)
      .NumberOfVolumeIdentifiers =
         1;

   MediaDefinition.Device(1)
      .MediaFile(2)
      .VolumeIdentifier(1)
      .VolumeIdentifier =
         'D1M2V1';


   //---------------------------------------------------------------
   // Device 1 / Media File 3
   // 3 Volumes
   //---------------------------------------------------------------

   MediaDefinition.Device(1)
      .MediaFile(3)
      .SequenceNumber =
         2;

   MediaDefinition.Device(1)
      .MediaFile(3)
      .StartingPositionInFile =
         *ALL'2';

   MediaDefinition.Device(1)
      .MediaFile(3)
      .NumberOfVolumeIdentifiers =
         3;

   MediaDefinition.Device(1)
      .MediaFile(3)
      .VolumeIdentifier(1)
      .VolumeIdentifier =
         'D1M3V1';

   MediaDefinition.Device(1)
      .MediaFile(3)
      .VolumeIdentifier(2)
      .VolumeIdentifier =
         'D1M3V2';

   MediaDefinition.Device(1)
      .MediaFile(3)
      .VolumeIdentifier(3)
      .VolumeIdentifier =
         'D1M3V3';


   //=================================================================
   // Device 2
   //=================================================================

   MediaDefinition.Device(2).DeviceName =
      'TAPMLBBRMS';

   MediaDefinition.Device(2).NumberOfMediaFiles =
      2;


   //---------------------------------------------------------------
   // Device 2 / Media File 1
   // 1 Volume
   //---------------------------------------------------------------

   MediaDefinition.Device(2)
      .MediaFile(1)
      .SequenceNumber =
         0;

   MediaDefinition.Device(2)
      .MediaFile(1)
      .StartingPositionInFile =
         *ALL'3';

   MediaDefinition.Device(2)
      .MediaFile(1)
      .NumberOfVolumeIdentifiers =
         1;

   MediaDefinition.Device(2)
      .MediaFile(1)
      .VolumeIdentifier(1)
      .VolumeIdentifier =
         'D2M1V1';


   //---------------------------------------------------------------
   // Device 2 / Media File 2
   // 3 Volumes
   //---------------------------------------------------------------

   MediaDefinition.Device(2)
      .MediaFile(2)
      .SequenceNumber =
         1;

   MediaDefinition.Device(2)
      .MediaFile(2)
      .StartingPositionInFile =
         *ALL'4';

   MediaDefinition.Device(2)
      .MediaFile(2)
      .NumberOfVolumeIdentifiers =
         3;

   MediaDefinition.Device(2)
      .MediaFile(2)
      .VolumeIdentifier(1)
      .VolumeIdentifier =
         'D2M2V1';

   MediaDefinition.Device(2)
      .MediaFile(2)
      .VolumeIdentifier(2)
      .VolumeIdentifier =
         'D2M2V2';

   MediaDefinition.Device(2)
      .MediaFile(2)
      .VolumeIdentifier(3)
      .VolumeIdentifier =
         'D2M2V3';

end-proc;