Installing Natural on z/OS

#### Search Results

Search

# Installing Natural on z/OS

This document describes the steps for installing Natural (product code NAT) on z/OS.

- Prerequisites

- Installation Medium

- Installation Procedure

- Installation Verification

#### Related Topic:

For information on how to run Natural in a z/OS environment, see the Operations documentation.

#### Notation vrs or vr:

When used in this document, the notation `vrs` or `vr` represents the relevant product version (see also Version in the Glossary).

## Prerequisites

See General Prerequisites and System Support.

## Installation Medium

The installation medium contains the following data sets required for product installation:

Data Set Name | Contents
--- | ---
`ICSvrs.LOAD` | Load modules for ICU for Adabas & Natural (ICS)
`ICSvrs.SRCE` | Source modules for ICU for Adabas & Natural (ICS)
`MLCvrs.JOBS` | Sample installation jobs for the z/OS license check software The placeholder `vrs` in the library name represents the version of the license check software, which is not necessarily the same as the version of Natural. For detailed information on the license check software, see Mainframe Product Licensing.
`NATvrs.LICS` | Load modules for the z/OS license check software containing the LICUTIL license utility The placeholder `vrs` in the library name represents the version of the license check software, which is not necessarily the same as the version of Natural. For detailed information on the license check software and the LICUTIL utility, see Mainframe Product Licensing.
`NATvrs.LOAD` | Load modules
| Product license file for Natural For information on the license file and product licensing, see Mainframe Product Licensing.
`NAZvrs.LICS` | Product license file for Natural Batch for zIIP This license file is also valid the Natural TSO Interface. For information on the license file and product licensing, see Mainframe Product Licensing.
`NATvrs.SRCE` | Source modules and macros
`NATvrs.SYSF` | Natural system file definitions
`NATvrs.OBJS` | Object modules
`NATvrs.JOBS` | Sample installation jobs
`NATvrs.INPL` | Natural objects with examples

### Copying Data Sets to a z/OS Disk

Copy the data sets from the supplied installation medium to your disk before you perform the individual installation procedure for each component to be installed.

The way you copy the data sets depends on the installation method and the medium used:

- If you use System Maintenance Aid (SMA), refer to the copy job instructions provided in the System Maintenance Aid documentation.

- If you are not using SMA and want to copy the data sets from CD-ROM, refer to the README.TXT file on the CD-ROM.

- If you are not using SMA and want to copy the data sets from tape, follow the instructions in this section.

This section explains how to copy all data sets from tape to disk.

- Step 1: Copy Data Set COPY.JOB from Tape to Disk
- Step 2: Modify hilev.COPY.JOB on Your Disk
- Step 3: Submit COPY.JOB

#### Step 1: Copy Data Set COPY.JOB from Tape to Disk

- Modify the following sample job according to your requirements:

      //SAGTAPE JOB SAG,CLASS=1,MSGCLASS=X
      //* ---------------------------------
      //COPY EXEC PGM=IEBGENER
      //SYSUT1 DD DSN=COPY.JOB,
      // DISP=(OLD,PASS),
      // UNIT=(CASS,,DEFER),
      // VOL=(,RETAIN,SER=tape-volser),
      // LABEL=(2,SL)
      //SYSUT2 DD DSN=hilev.COPY.JOB,
      // DISP=(NEW,CATLG,DELETE),
      // UNIT=3390,VOL=SER=disk-volser,
      // SPACE=(TRK,(1,1),RLSE),
      // DCB=*.SYSUT1
      //SYSPRINT DD SYSOUT=*
      //SYSIN DD DUMMY
      //

  where:

  `tape-volser` is the VOLSER of the tape, for example: `T12345`,
  `hilev` is a valid high-level qualifier, and
  `disk-volser` is the VOLSER of the disk.

- Execute the job to copy the data set `COPY.JOB` to your disk.

#### Step 2: Modify hilev.COPY.JOB on Your Disk

- Modify `hilev.COPY.JOB` according to your requirements:

  Set `EXPDT` to a valid expiration date, for example, `99365`.

  Set `HILEV` to a valid high-level qualifier, for example, `USERLIB`.

  Set `LOCATION` to a storage location, for example, `STORCLAS=ABC` or `UNIT=3390,VOL=SER=USR123`.

#### Step 3: Submit COPY.JOB

- Execute `hilev.COPY.JOB` to copy single, multiple, or all data sets to your disk.

## Installation Procedure

Be sure to read Installation Process and Major Natural Features before you start the installation procedure.

- Step 1: Allocate and Copy the SMA User Libraries

- Step 2: Prepare, Convert, Assemble and Link the License File

- Step 3: Link Natural Modules to an APF Library

- Step 4: Start the Global Buffer Pool

- Step 5: Load the FNAT System File Definition

- Step 6: Load the FUSER System File Definition

- Step 7: Load the Scratch-Pad File Definition

- Step 8: Load the FREG System File Definition

- Step 9: Load the FDIC System File Definition

- Step 10: Load the FSEC System File Definition

- Step 11: Build the Natural Configuration Module

- Step 12: Build the Natural-Specific IBM Language Environment Options

- Step 13: Build the Natural Parameter Module

- Step 14: Link the Nucleus

- Step 15: Load New Natural Objects and Natural Error Messages

- Step 16: Create and Format the Roll File

- Step 17: Create and Start the Natural Roll Server

- Step 18: Create and Start the Natural Authorized Services Manager

- Step 19: Create and Start the Message Buffer Pool

- Step 20: Create Sample JCL for the Natural RPC Server

### Step 1: Allocate and Copy the SMA User Libraries

(Job I002, Steps 0010, 0020)

- Allocate the user-specific source, load and save libraries of System Maintenance Aid (SMA) and copy them to the `LOAD.SAVE` library.

### Step 2: Prepare, Convert, Assemble and Link the License File

(Job I007, Steps 0101, 0102, 0104 and optional Steps 0111, 0112, 0114, and optional Steps 1201, 1202, 1204)

You must install a valid Natural license file. An additional license file is required if you want to install Natural Batch for zIIP to enable support of the IBM z/IIP (IBM System z Integrated Information Processor).

For detailed information on the license file and product licensing, see Mainframe Product Licensing.

1. Copy the license file from the supplied installation medium to disk or transfer it from the PC as described in Transferring a License File from PC to a z/OS Host Using FTP in Mainframe Product Licensing.

2. Check, convert, assemble, and link the license file:

   Step 0101 | Check license file `NATvrs.LICS`. This job runs the CHECK function of the LICUTIL license utility (see below).
   Step 0102 | Convert license file into an assembler source. This job runs the MAKE function of the LICUTIL license utility (see below).
   Step 0104 | Assemble and link the assembler source to generate load module `NATLIC`. This module is then linked to the nucleus in Job I060.

   The functions and option settings provided by LICUTIL are described in Using the License Utility: LICUTIL in Mainframe Product Licensing.

3. This step is only required if you want to install Natural Batch for zIIP for a batch, batch server or TSO environment.

   Check, convert, assemble, and link the license file supplied for Natural Batch for zIIP:

   Step 0111 | Check license file `NAZvrs.LICS`. This job runs the CHECK function of the LICUTIL license utility.
   Step 0112 | Convert license file into an assembler source. This job runs the MAKE function of the LICUTIL license utility.
   Step 0114 | Assemble and link the assembler source to generate load module `NAZLIC`. This module is then linked to the nucleus in Job I060.

4. This step is only required if you want to install the Natural Optimizer Compiler.

   Check, convert, assemble, and link the license file supplied for the Natural Optimizer Compiler:

   Step 1201 | Check license file `NOCvrs.LICS`. This job runs the CHECK function of the LICUTIL license utility.
   Step 1202 | Convert license file into an assembler source. This job runs the MAKE function of the LICUTIL license utility.
   Step 1204 | Assemble and link the assembler source to generate load module `NOCLIC`. This module is then linked to the nucleus in Job I060.

5. This step is only required if you want to install Natural for Db2.

   Check, convert, assemble, and link the license file supplied for Natural for Db2:

   Step 1601 | Check license file `NDBvrs.LICS`. This job runs the CHECK function of the LICUTIL license utility.
   Step 1602 | Convert license file into an assembler source. This job runs the MAKE function of the LICUTIL license utility.
   Step 1604 | Assemble and link the assembler source to generate load module `NDBLIC`. This module is then linked to the nucleus in Job I060.

### Step 3: Link Natural Modules to an APF Library

(Job I009, Steps 1200, 1210, 1220, 1230, 1232, 1240, 1250)

If you want to use one of the Natural components listed in the table below, link the appropriate Natural module to an Authorized Program Facility (APF) library.

The table below indicates when a component is required and the System Maintenance Aid (SMA) parameters used to specify the module names.

Step/Component to be Installed | Module | SMA Parameter
--- | --- | ---
Step 1200: Global Buffer Pool1 See also Step 4: Start the Global Buffer Pool. | `NATGBPvr``` | `NAT-GLOBAL-BP` or `EDT-GLOBAL-BP`
Step 1210: Authorized Services Manager (ASM)1 You must use an ASM in the following cases: The Natural profile parameter `BPPROP` is set to `PLEX` or `GLOBAL` or `GPLEX` (buffer pool propagation is used). Natural global buffer pools are allocated in the system key; see Step 4: Start the Global Buffer Pool. Natural under CICS is used in a Parallel Sysplex environment (SIP function is required). Natural under IMS TM is used in terminal-oriented, non-conversational mode (SIP function is required). Natural under IMS TM is used, with the Accounting function writing SMF records. Enablement of zIIP support is required. Enablement of the Shared Memory Objects File Server of Natural for Db2 is required. Natural Development Server with `SECURITY_CACHING=YES` is used. See also Step 19: Create and Start the Natural Authorized Services Manager. | `NATASMvr` | `NAT-ASM`
Step 1220: Natural Roll Server1 You must use a Natural Roll Server in the following cases: The server front-end of Natural RPC (Remote Procedure Call) is used. Natural under IMS TM runs in a Parallel Sysplex environment. Natural under CICS runs in a Parallel Sysplex or CICSplex environment. See also Step 17: Create and Format the Roll File and Step 18: Create and Start the Natural Roll Server. | `NATRSMvr` | `ROLLSRV`
Step 1240: Message Buffer Pool 1 See also Step 20: Create and Start the Message Buffer Pool. | `NATMBPvr` | `NAT-MTBP`
Step 1250: Impersonation with the Natural RPC (Remote Procedure Call)2 See also Step 23: Create Sample JCL for the Natural RPC Server. | RPC Server Front-End | `NAT-RPC-FRONT`

1 described in the Operations documentation

2 described in the Natural RPC (Remote Procedure Call) documentation

### Step 4: Start the Global Buffer Pool

(Job I015, Steps 0100, 0101, 0102, 0104)

These steps are only required if you want to use a global buffer pool. For further information on the global buffer pool, see Natural Global Buffer Pool in the Operations documentation.

Installation of the Natural Authorized Services Manager (ASM) is mandatory if `ALLOWUSERKEYCSA(NO)` applies by default or has explicitly been specified in `SYS1.PARMLIB(DIAGxx)`. See also Allocation of the Natural GBP in the Operations documentation.

- Create the jobs required to start and stop a global buffer pool:

  Step | Job | Function
  --- | --- | ---
  0100 | `GBNASTRT` | Start global buffer pool
  0101 | `GBNASTOP` | Stop global buffer pool
  0102 | `GBEDSTRT` | Start editor global buffer pool
  0104 | `GBEDSTOP` | Stop editor global buffer pool

- If you want to use a Natural global buffer pool, start the job `GBNASTRT` before using Natural.

- If you want to use an editor global buffer pool, start the job `GBEDSTRT` before using Natural.

### Step 5: Load the FNAT System File Definition

(Job I050, Step 0100)

Skip this step if you want to use an existing Natural `FNAT` system file.

Load the new Natural `FNAT` system file definition:

1. Specify the database ID and file number of the Adabas file where to load the new `FNAT` system file definition by using the Adabas ADALOD utility.

   In addition, you must specify this database ID and file number in the Natural parameter module as described in Step 13: Build the Natural Parameter Module.

2. Load the `FNAT` system file definition contained in the `NATvrs.SYSF` data set by using the Adabas ADALOD utility.

   The following ADALOD utility parameter must not be changed:

       ISNREUSE=YES

   The following ADALOD utility parameter setting is recommended:

       USERISN=YES

   If you reorganize an `FNAT` file or if you unload from or load data to the `FNAT` file (for example, by using `ADAULD`/`ADALOD`), you must specify the parameter `USERISN=YES` for the `ADALOD` utility to avoid Natural errors NAT7397 and NAT9988 which require that you re-INPL the Natural `FNAT` system file.

   If you specify the parameter `USERISN=YES` when you load a new `FNAT` system file, and you unload data from this `FNAT` file, the `ADALOD` utility assumes `USERISN=YES` as a default setting when reloading the data into the `FNAT` file.

### Step 6: Load the FUSER System File Definition

(Job I050, Step 0101)

Skip this step if you want to use an existing Natural `FUSER` system file.

Load the new Natural `FUSER` system file definition:

1. Specify the database ID and file number of the Adabas file where to load the new `FUSER` system file definition by using the Adabas ADALOD utility.

   In addition, you must specify this database ID and file number in the Natural parameter module as described in Step 13: Build the Natural Parameter Module.

2. Load the `FUSER` system file definition contained in the `NATvrs.SYSF` data set by using the Adabas ADALOD utility.

   The following ADALOD utility parameter must not be changed:

       ISNREUSE=YES

3. If you want to use existing Natural applications, copy all user-written objects to the empty `FUSER`.

4. If you want to use Natural Application Programming Interfaces (APIs), see Using a Natural API in the SYSEXT Utility documentation for further guidance.

### Step 7: Load the Scratch-Pad File Definition

(Job I050, Step 0102)

This step is only required if you want to use read-only system files. See also Natural Scratch-Pad File in the Operations documentation.

You can skip this step if you want to use an existing Natural scratch-pad file.

Load the new Natural scratch-pad system file definition:

1. Set the System Maintenance Aid (SMA) parameter `NAT-SCRF` to `Y` (Yes).

2. Specify the database ID and file number of the Adabas file where to load the scratch-pad file by using the Adabas ADALOD utility.

   In addition, you must specify this database ID and file number in the Natural parameter module as described in Step 13: Build the Natural Parameter Module.

3. Load the scratch-pad system file definition contained in the `NATvrs.SYSF` data set by using the Adabas ADALOD utility.

   The following ADALOD utility parameter must not be changed:

       ISNREUSE=YES

### Step 8: Load the FREG System File Definition

(Job I050, Step 0104)

This step is only required if registry information must be available to control concurrent user sessions limited with the Natural profile parameter `UCONMAX` (see the Parameter Reference documentation).

You can skip this step if you want to use an existing Natural `FREG` system file.

Load the new Natural `FREG` system file definition:

1. Set the System Maintenance Aid (SMA) parameter `NAT-FREG` to `Y` (Yes).

2. Specify the database ID and file number of the Adabas file where to load the `FREG` system file by using the Adabas ADALOD utility.

   In addition, you must specify this database ID and file number in the Natural parameter module as described in Step 13: Build the Natural Parameter Module.

3. Load the `FREG` system file definition contained in the `NATvrs.SYSF` data set by using the Adabas ADALOD utility.

   The following ADALOD utility parameter must not be changed:

       ISNREUSE=YES

### Step 9: Load the FDIC System File Definition

(Job I050, Step 0103)

Skip this step:

- if you want to install Predict. In this case, use the corresponding installation step described in the Predict Installation documentation.

- if you want to use an existing Natural `FDIC` system file.

Load the new Natural `FDIC` system file definition:

1. Specify the database ID and file number of the Adabas file where to load the new `FDIC` system file definition by using the Adabas ADALOD utility.

   In addition, you must specify this database ID and file number in the Natural parameter module as described in Step 13: Build the Natural Parameter Module.

2. Load the `FDIC` system file definition contained in the `NATvrs.SYSF` data set by using the Adabas ADALOD utility.

   The following ADALOD utility parameter must not be changed:

       ISNREUSE=YES

### Step 10: Load the FSEC System File Definition

(Job I050, Step 9900)

Skip this step, if you do not use Natural Security.

- If you use Natural Security, refer to Installing Natural Security.

### Step 11: Build the Natural Configuration Module

(Job I055, Step 0110)

This step is only required if you need to change the delivered `NATCONFG` module, for example, to adapt the `NTDVCE` macro definition to your requirements.

1. Change and assemble the source contained in the `hilev.NATvrs.SRCE` data set.

2. Link the resulting Natural configuration module `NATCONFG` to the environment-independent nucleus (see Step 14: Link the Nucleus).

   For more information on the configuration tables in `NATCONFG`, refer to Natural Configuration Tables in the Operations documentation.

### Step 12: Build the Natural-Specific IBM Language Environment Options

(Job I055, Step 0120 or 0130)

Build the Natural-specific runtime options for the IBM Language Environment (LE).

Step 0120 is only required if you need to adapt the LE options at the `.MVSDEF` label in the delivered `NATLEOPT` module to your requirements.

1. Set the System Maintenance Aid (SMA) parameter `NAT-LEOPT` to `Y` (Yes); the default setting is `N` (No).

2. Change the required LE options in the `NATLEOPT` source module contained in the `NATvrsSRCE` data set at the `.MVSDEF` label.

3. Assemble and link the `NATLEOPT` source module contained in the `NATvrsSRCE` data set.

4. Link the resulting `NATLEOPT` module to the environment-dependent nucleus (see Step 14: Link the Nucleus).

Step 0130 is only required if you have any non-Natural programs running in 24-bit addressing mode:

1. Set the SMA parameter `NAT-LEOPT-AMODE24` to `Y` (Yes); default is `N` (No).

2. Assemble the `NATLEOPT` module contained in the `NATvrsSRCE` data set.

3. Link the resulting `NATLEOPT` module to the environment-dependent nucleus (see Step 14: Link the Nucleus).

### Step 13: Build the Natural Parameter Module

(Job I060, Steps 0010, 0015)

Build the Natural parameter module for batch mode.

1. Modify the settings of the Natural profile parameters supplied with this job, if required. The parameters and corresponding macros (if applicable) are described in the Parameter Reference documentation. The most important parameter/macro settings are described below.

   - Configure the z/OS batch interface: Modify the settings of the parameters supplied with the `NTOSP` macro to meet your requirements. For descriptions of these parameters, see the corresponding dynamic profile parameter `OSP`.

   - Adapt the following parameters:

         FNAT=(database-id,file-number)
         FUSER=(database-id,file-number)
         FDIC=(database-id,file-number)

     where `database-id` and `file-number` are either the database ID and file number you specified when loading the new `FNAT`, `FUSER` and `FSEC` system files (see Step 5, Step 6 and Step 9, respectively), or the database ID and file number of your existing Natural system files.

     These parameters are supplied with the `NTPRM` macro described in the Operations documentation.

   - If you want to to limit the number of concurrent users with the Natural profile parameter `UCONMAX`, proceed as follows:

     Supply the following parameter with the `NTPRM` macro:

         FREG=(database-id,file-number)

     where `database-id` and `file-number` are either the database ID and file number you specified when loading the new Natural `FREG` system file (see Step 8), or the database ID and file number of your existing Natural `FREG` system file.

   - If you want to use read-only system files, proceed as follows:

     Supply the following parameter with the `NTPRM` macro:

         ROSY=ON

     Specify the `NTLFILE` macro (see the parameter `LFILE`):

         NTLFILE 212,database-id,file-number

     where `database-id` and `file-number` are the database ID and file number you specified when loading the new Natural scratch-pad file (see Step 7), or the database ID and file number of your existing Natural scratch-pad file.

   - If you want to use a Natural global buffer pool, perform the following steps:

     Specify the `NTBPI` macro (see the `BPI` parameter):

         NTBPI TYPE=NAT,NAME=gbp-name

     where `gbp-name` is the name of the Natural global buffer pool to be used.

     Supply the following parameter with the `NTPRM` macro:

         SUBSID=subsystem-name

     where `subsystem-name` is the name of the Natural subsystem specified when creating the global buffer pool.

     Make sure that the System Maintenance Aid (SMA) parameter `NAT-GLOBAL-BP` is set to `Y` (Yes). This is the default setting.

     For detailed information on the Natural global buffer pool, see Natural Global Buffer Pool under z/OS in the Operations documentation.

2. Assemble and link the Natural parameter module.

### Step 14: Link the Nucleus

(Job I060, Steps 0020, 0105)

1. If you want Natural to run in the IBM Language Environment (LE), set the System Maintenance Aid (SMA) parameter `NAT-LE` to `Y` (Yes). The default setting is `N` (No).

2. Link the environment-dependent nucleus (Step 0020) for batch Natural.

   The list of modules to be linked for the environment-dependent nucleus is supplied with Step 0020.

   Do not link the environment-dependent nucleus with the linkage editor option `RENT`.

   If you want Natural to run in the IBM Language Environment (LE), specify `ENTRY LESTART` instead of `ENTRY CMSTART`.

3. Link the environment-independent nucleus (Step 0105).

   The list of modules to be linked for the environment-independent nucleus is supplied with Step 0105.

   Ensure that the Natural profile parameter `NUCNAME` (see the Parameter Reference documentation) specified in the Natural parameter module contains the name of the module resulting from this link step.

### Step 15: Load New Natural Objects and Natural Error Messages

(Job I061, Step 0100)

- Load the Natural objects and Natural error messages from the `NATvrs.INPL` data set into the Natural system files by using the Natural INPL utility.

  The Natural error messages comprise short and long message texts and the German (`ULANG=2`) short message texts. You can use the `ERRUPPER` program of the Natural SYSERR utility to convert the message texts to upper case.

  For details on the `ULANG` profile parameter and `ERRUPPER`, see the Parameter Reference and the Utilities documentation, respectively.

### Step 16: Create and Format the Roll File

(Job I200, Step 0101)

This step is only required if you want to use the Natural Roll Server. For information on the different types of roll files, see Roll File and LRB in the Operations documentation, and Natural under CICS and Natural under IMS TM in the TP Monitor Interfaces documentation.

- If you use the roll file of a previous version, it is sufficient to execute the `NATRSRFI RESET` function. See Formatting the Roll File in the Operations documentation.

- If you use a new roll file, create and start the job `FORMRF1` (supplied with Step 0101) before using Natural.

### Step 17: Create and Start the Natural Roll Server

(Job I200, Step 0102)

This step is only required if you want to use the Natural Roll Server described in Natural Roll Server Operation in the Operations documentation.

- Create and start the job `SAGRSM` (supplied with Step 0102) before using Natural. See Starting the Roll Server in the Operations documentation.

### Step 18: Create and Start the Natural Authorized Services Manager

(Job I200, Step 0103)

This step is only required if you want to use the Natural Authorized Services Manager (ASM) described in Authorized Services Manager under z/OS in the Operations documentation.

- Create and start the job `SAGASM` before using Natural.

### Step 19: Create and Start the Message Buffer Pool

(Job I200, Step 0107)

This step is only required if you want to use a message buffer pool described in Message Buffer Pool in the Operations documentation.

- Create and start the job `SAGMTBP` (supplied with Step 0107) before using Natural. See also Operating the Message Buffer Pool in the Operations documentation.

### Step 20: Create Sample JCL for the Natural RPC Server

(Job I200, Steps 0109, 0115, 0120)

These steps are only required if you want to use Natural RPC.

Sample Natural RPC server:

1. Set the parameters in the System Maintenance Aid (SMA) group `RPC` accordingly; in particular, set the parameter `NAT-RPC` to `Y` (Yes).

   For further information, see Starting a Natural RPC Server and Starting a Batch Server in a z/OS Environment in the Natural RPC (Remote Procedure Call) documentation.

2. Create the `CMPRMIN` sample input to execute a Natural RPC server in batch mode (Step 0109).

3. Create the sample JCL to execute a standard Natural RPC server task without RPC server front-end (Step 0115).

4. Create the sample JCL to execute a Natural RPC server task by the RPC server front-end (Step 0120). This JCL is necessary for impersonation.

## Installation Verification

This section provides instructions for verifying the successful installation of Natural.

- Test Batch Natural

- Test Online Natural

### Test Batch Natural

You can use the following sample JCL to invoke Natural in batch mode and check whether the Natural system files are available:

    //JOBNAME JOB (,,,999),CLASS=K,MSGCLASS=X,MSGLEVEL=(1,1)
    //*
    //NATBAT   EXEC PGM=NATvrsBA,COND=(0,LT)
    //STEPLIB   DD DSN=NATURAL.BATCH.LIBRARY,DISP=SHR
    //          DD DSN=ADAvrs.LOAD,DISP=SHR
    //DDCARD    DD *
    ADARUN DB=001,DE=3390,SVC=249,MODE=MULTI
    //CMPRINT   DD SYSOUT=X
    //CMPRT01   DD SYSOUT=X
    //CMWKF01   DD DUMMY
    //SYSOUT    DD DUMMY
    //CMSYNIN    *
    EDIT
    WRITE 'TESTBAT'
    END
    .E
    RUN
    SAVE TESTBAT
    FIN
    //

This job starts Natural, creates the example program `TESTBAT`, and executes the program with the system command `RUN`.

### Test Online Natural

You can use the following verification procedure to test Natural system functions in online mode and check whether the Natural system files are available.

1. Log on to the Natural user library `SYSTEM`:

       LOGON SYSTEM

2. Enter the following Natural system command:

       MAINMENU

3. Select Development Functions and enter the following:

   `C` in the Code field,
   `P` in the Type field, and
   `TEST` in the Name field.

4. In the editing area of the program editor, type the following:

       WRITE 'HELLO'
       END

5. Save the source code and exit the program editor.

6. In the Development Functions menu, enter the following:

   `L` in the Code field and
   `TES*` in the Name field.

7. On the LIST Objects in a Library screen, enter the `RU` line command for the `TEST` program.

8. Enter the following Natural system command:

       SYSDDM

9. In the SYSDDM utility menu, enter the following:

   `R` in the Code field and
   `EMPLOYEES` in the DDM Name field.

10. After pressing ENTER, enter the following:

    `C` in the Code field,
    the appropriate Natural system file number in the FNR field,
    the appropriate database ID in the DBID field, and
    `Y` in the Replace field.

    The specified DDM has been adapted to your environment.

11. Repeat Steps 9 and 10 for the `VEHICLES` DDM.

12. You can check whether the DDMs `EMPLOYEES` and `VEHICLES` are now available in your environment by logging on to the Natural system library `SYSEXSYN` and executing the example programs (for example, `AEDEX1R`) with the system command `RUN`.

### On this page

- Prerequisites
- Installation Medium
- Installation Procedure
- Installation Verification