AdLayer Managers

This document is about ways for managing an AdLayer subscriber and is intended for ad managers. Be sure to read the introduction for AdLayer integration too (adlayer-index.md.html), it contains that will help you understand the process better.

Creating a mapping file

A mapping file will help you map the page parameters that the application is passing to the DFP parameters of the server. For example for the app area about backing you can steer your ad server to deliver the ad on backing powder. The mapping file format can be either JSON or JSONP. A valid JSON file consists of key value pairs that are both enclosed in quotation marks. A JSONP mapping file looks like AdLayer.receiveMapping({json string});

JSON mapping file example:

{
  "platform": "hbbtv",
  "vendor": "@all",
  "model": "@all",
  "allowed": {
    "appName": [
      "epg",
      "hdtext",
    ],
    "pageType": [
      "index",
      "rubric",
      "shortclip",
      "fullclip"
    ],
  },
  "maps": {
    "toDfpZone": {
      "default" : "default_value",
      "117": "anna_und_die_liebe",
      "124": "enie_backt",
      "123": "die_strengsten_eltern"
    },
    "formatToNuggTg" : {
       "default" : "default_value",
       "117" : "nuggTgValueForFormat117"
    }
  },
  "rules": [
    {
      "DFPSite": "hbbtv_sixx",
      "DFPZone": "other",
      "fullbanner2": {
        "DFPKeyValues": "xx=fb2;xx=sco;xx=rt;u=pos=1,vpos=0;bt=0;dev=@vendor;"
      },
      "rectangle1": {
        "DFPKeyValues": "xx=rt1;xx=sco;xx=fb2;u=pos=1,vpos=0;bt=0;dev=@vendor;"
      },
      "preroll1": {
        "DFPKeyValues": "tile=DFPTile;bt=0;zz=10x1;xx=vp;xx=sco;pos=1;vpos=1;dev=@vendor;"
      },

      "allowedAds": ["preroll1", "presplit1d", "middroll5"]

    },
    {
      "format"  : "@any",
      "pageType": "@any",
      "DFPZone" : "other"
    }
  ]
}

To edit this json file you can use any text editor of your choice. However you must make sure that the syntax is valid. It is therefore advised that you use a special editor that supports JSON syntax highlighting and validation, for example Sublime Text.

A waterfall of ad rules

So the objective is to map the pageParameters to the ad server parameters that AdLayer uses to build the ad tag (the url to the specific ad). JSON mapping let's you do this in a form of the waterfall way. Consider the following rule:

{
   "format" : "Galileo",
   "pageType"   : ["home", "player"],
   "DFPZone": "galileo",
   "fullbanner2" : {
      "DFPZone" : "other"
   }
}

This rule says the following: If the application passes the format parameter with value "Galileo" and the pageType parameter with the value either "home" or "player" set the DFPZone parameter to be "galileo" for every ad, except for fullbanner2, for which the value of DFPZone is set to "others".

Rules are red and applied one after another in the order specified. Say that the application is requesting the ad fullbanner2 and is passing the following set of data:

AdLayer.setPageData({
    format : "Galileo",
    pageType : "home",
    referrer : "homepage"
})

And consider the following set of rules:

{
   "format"  : "Galileo",
   "pageType": ["home", "player"],
   "DFPZone" : "galileo",
   "fullbanner2" : {
      "DFPZone" : "other"
   }
},

{
   "format"   : "Galileo",
   "pageType" : ["home", "player"],
   "referrer" : "homepage",
   "DFPZone": "galileo.special",
}

The rules are processed from first to last. The first rule matches first for any ad because both format and pageType are matching. DFPZone becomes "galileo". Because the ad is fullbanner2 the first rule is matching again and DFPZone becomes "other". Then AdLayer moves to the next rule. Again the ruleset (format, pageType and referrer) are matched and thus DFPZone becomes "galileo.special". Since there are no more rules, this value is declared as final and is used in the ad request.

It is important to keep in mind that the set of page parameters differs from app to app, where is the set of DFP parameters remains the same for every app. In the example above the format, referrer and pageType are example page parameters that may or may not be used. Ad manager is responsible for defining a suitable set of page parameters at the beginning of every integration.

Your first concern is to make sure, that all required ad server parameters are filled with default values for any set of parameters. To make sure this happens, you specify your first rule without including any page parameters or ad names. Like so:

{
    "DFPSite": "hbbtv_sixx",
    "DFPZone": "other",
    "DFPKeyValues": "xx=fb2;xx=sco;xx=rt;u=pos=1,vpos=0;bt=0;",
    "nuggtg"   : "other",
    "allowedAds" : ["defaultAdGroupForGeneralCase"],
}

This rule will unconditionally match every AdLayer.setPageData since it does not specify any restrictions on parameter values. Furthermore this rule will set every parameter for the AdLayer to be able to perform an ad request. This rule should be your "all defaults" rule. For example to achieve the most views you would set here parameters that will cause the ad server to always deliver an ad. Then in next rules you use the passed pageParameters to to tailor your ad tags to specific parts of the app.

Important you have to make sure, that the mapping file has a rule like above. You should include any other DFP parameters if those are required for the ad server to deliver the proper response.

Default ad group

defaultAdGroupForGeneralCase is an alias of a default set of ads. This group includes the following ads:

preroll1, sponsor1, presplit1, midroll1, midroll1b, midroll1c, postsplit1, presplit2, midroll2, midroll2b, midroll2c, postsplit2, presplit3, midroll3, midroll3b, midroll3c, postsplit3, presplit4, midroll4, midroll4b, midroll4c, postsplit4, presplit5, midroll5, midroll5b, midroll5c, postsplit5, sponsor2, postroll1

You can use this alias in any configuration directive that accepts ad name and you can mix it with the names of single ads like so:

"allowedAds" : ["defaultAdGroupForGeneralCase", "midroll2e"],

DPF parameters that you have to fill.

Now that you are know how to specify the rules, lets look at all parameters that you should map:

  • DFPSite
  • DFPZone
  • DFPKeyValuestile (deprecated)
  • DFPKeyValues
  • nuggtg
  • midrollStart
  • allowedAds
  • disallowedAds
  • complementaryAds
  • showroom

All the parameters above except midrollStart, allowedAds, disallowedAds and complementaryAds are required to fill otherwise the final ad tag will have placeholders in it and will be incorrect.

midrollStart is a special parameter that you specify to tell the AdLayer when the midroll block is supposed to start. The value is in seconds from the beginning of the video regardless the block. You have to specify this for the first ad from the block. So if a midroll block begins with presplit1 then evaluted value of midrollStart parameter for presplit1 will be used to determine when the whole midroll block will be scheduled. If you don't specify this, then AdLayer will deliver midrolls every 10 minutes. If console is available, AdLayer will issue a warning about this. Example: midrollStart : 10

allowedAds is for specifying the selection of ads for the app. If you don't specify this, then all ads will be allowed. That is a lot of ads, so you should really specify some restriction. You specify either individual ad names like preroll1, preroll1a etc. or preset ad groups. Example: allowedAds : ["preroll1", "midroll1"]

disallowedAds is for specifying the ads that should be explicitly forbidden. For example you want to allow midroll2 for all videoclips but disallow some later for a particular format. Example: {format : "Galileo", disallowedAds : ["midroll2"]}

complementaryAds is for specifying additional ads that should be allowed for a particular set of parameters. It is a counterpart of and has precedence over disallowedAds. Example: {format : "Galileo", complementaryAds : ["midroll3"]}

showroom is meant for development and must not appear in production. You can use the showroom to force delivery of specific ads and ignore all other parameters. If showroom is specified, DFPSite is set to the value of showroom and it is also appended to the DFPKeyValues parameter.

Page parameter existence checks maps and other advanced features.

@any string is equivalent for an existence check. Rule: {format : @any} will match if AdLayer.setPageData has passed the format parameter with any non-falsy value.

@param tells the parser to use the value from the 'param' parameter. You can think of it as a variable. Consider the rule:

{
    "format" : ["galileo", "topmodel"],
    "DFPSite" : "@format.special"
}

For

AdLayer.setPageData({
    format : "galileo"
})

DFPSite will equal to "galileo.special". Use it in cases where it is not practical to list the the individual ad parameter values.

@param{useMap} tells the parser to take the value from param and look up the transformation value in the useMap value map. Recalling the JSON file example from the beginning of this section the value of DFPZone in {"DFPZone" : "@format{toDfpZone}"}will be "enie_backt" if format is equal to 117.

Device vendor identification

A special variable vendor is always available in the page parameters. You can therefore use @vendor in your mapping file to create conditional rules or maps like so:

{
    "format" : "@any",
    "vendor" : "samsung",
    "DFPSite" : "@format.samsung"
}

or even

{
    "format" : "@any",
    "vendor" : "@any",
    "DFPSite" : "@format.@vendor"
},

{
    "vendor" : "unknown",
    "DFPSite" : "special"
}

Currently vendor is set to "non-hbbtv" for all User Agents that do not conform to the HBBTV user agent string specification. If AdLayer is not able to identify the vendor from a conforming user agent the value of vendor is set to "unknown".

JSON mapping individual parameters description

platform key describes the platform and is for information only. AdLayer does not use this key vendor key currently not used by the AdLayer model key currently not used by the AdLayer

allowed array contains the selection of allowed values for a particular page parameter. In the example above the allowed value for appName are "epg" and "hdtext". Important the allowed parameter is a hard set. If you thus restrict a page parameter and the app sends a different value than AdLayer will simply ignore the ad and not issue the request to server. If console is available AdLayer will write a warning to it. So you should only use this with parameters that you really want to restrict the values of, for example to prevent typo mistakes or ad delivery to unwanted paths. If you are looking to restrict a particular ad tag to a specific set of page parameters do not use the allowed array, but rather create a new rule and list restriction parameters there.

rules array contains the selection of rules that will be applied based on the current page parameters. Individual rules are objects like this:

{
   "format"   : "Galileo",
   "pageType"     : ["home", "player"],
   "referrer" : "homepage",
   "DFPZone"  : "galileo.special",
}

maps object contains zero, one or more maps that you can use to simplify your rules section. See the previous section for details.

Nuggad setup

AdLayer has integrated support for nuggad keyvalues. If the app should be using nuggad the developers must pass nuggsid in the AdLayer.setup call and you must setup nuggtg in your mapping file. nuggtg is treated in the same way as the DFP parameters so you would set up the rules to deliver nuggtg. For example if you had a map that translates page parameter format to nuggad tag like so:

"formatToNuggRubric":{
    "default":"other",
    "117":"serie",
    "124":"kochen",
    "128":"shows",
    "129":"factual"
}

then you could specify your nuggtg like so:

{
    "format": "@any",
    "nuggad":{
        "nuggtg":"@format{formatToNuggRubric}
    }
 }

If the ad is not there ...

A number of reasons can cause the ad not to appear. If the ad is not coming you should open the affected page in an environment with a console to check for errors. For example if the page is part of a HBBTV application open it in Firefox with the FireHBBTV plugin switched on. Then check for any error messages in the console.

Following is the list of errors thrown by AdLayer intentionally due to a misconfiguration of some component:

  • Code 1 : No mapped data for adName Code 2 : "No url for adName Code 3 : "Unknown ad adName Cause: Either the submitted adName is wrong, or the mapping file is wrong. Doublecheck that your mapping file is not too restrictive and returns correct parameters for adName

  • Code 4 : "No container on page for adName Cause: Container with id specified in the setup call is missing on the page at the time the AdLayer.display call has been attempted. Application developer should fix the integration.

  • Code 5 : Map method not overridden and no mapping data available Cause: Doublecheck that the app really does call your mapping file and that the url to the mapping file is correct. Then doublecheck that your mapping file contains proper JSON.

  • Code 6 : Server response in unknown format Cause: Ad server returned unexpected response. You have to fix the ad server to return correct response format.

  • Code 8 : Setup required Cause: Application called to an AdLayer method prior to calling AdLayer.setup(). Application developer has to fix this.

  • Code 9 : Ad sequence not allowed: adName1 -> adName2. Call setPageData to reset this. Cause: Application requested another commercial without calling setPageData first. Application developer has to fix this.

  • Code 11 : Failed to fetch mapping data Code 13 : Failed to parse mapping data Code 14 : No mapping rules defined Cause: The mapping file is unreachable, corrupt or in the wrong format. Verify that the application really does call your mapping file and that the url is correct. Then doublecheck that your mapping file contains proper JSON.

If the console contains an error different from the ones described, than it probably is a bug. If the error is not inside the AdLayer library contact application developer to fix it.

In some situations AdLayer is able to detect problems in the configuration. In this case it sets the DFPZone to void and writes a warning to console if it is available. The warning should help you to identify and correct the problems with the setup.

If there are no errors or warnings in the console, than your ad is probably disallowed either in the mapping file or by the publisher in the app.

Publishers are able to turn off one or more ads temporarily or for good by setting the [adName] or [blockName] to false in the configuration section of the play method, like so:

AdLayer.play({

    pageData: {
    //....
    },

    ads: {
        'preroll' : false,
        'presplit1' : false

    }
    //...
});

In the example above, the preroll block and the presplit1 ad are turned off and will never be requested or played.

Debugging the ads

If you as an ad manager wish to check the correctness of the implementation you can best do it in the following way:

  1. check the console Try launching the app in browser, fire up your console and check if it contains any errors. If any errors are present report them to the developer, there is a good chance, that these are exactly the cause of missing ads.

  2. Check the network communication Look for requests containing the words adproxy or doubleclick. Requests with adproxy or doubleclick and without track=1 are fetching a particular ad. In case of display ads if the request body looks like this: P7S1.fetchBanner() then the server sent back no ad or the response was malformed and the AdProxy has fallen back to empty ad. Correct response containing a display ad looks approximately like this:

     P7S1.fetchBanner({
         "name": "powercorner 151021Maxdome Supercorner SCO PM orderId=326526501 lineItemId=1179411981 creativeId=82333417581",
         "ad": [
             {
                 "format": "fullbanner",
                 "img": "http://pagead2.googlesyndication.com/pagead/imgad?id=CICAgKDT5c-E9QEQARgBMggVGW3cvJNkkQ",
                 "w": "728",
                 "h":"90"
             },
             {
                 "format": "rectangle",
                 "img": "http://pagead2.googlesyndication.com/pagead/imgad?id=CICAgKDT5Y-pBhABGAEyCBQY5mRYDnnC",
                 "w": "300",
                 "h":"250"
             }
         ],
         "target": "http://adclick.g.doubleclick.net/aclk?sa=L&ai=BzqpbC77nVvawIcnFzAaC2pWIAaWQ17oHAAAAEAEgADgAWO2A0duyAmCV2oiCmAeCARdjYS1wdWItMzY1OTM0OTE1MDEyMDUzNbIBGHd3dy5kY2xrLWRlZmF1bHQtcmVmLmNvbboBCWdmcF9pbWFnZcgBCdoBIGh0dHA6Ly93d3cuZGNsay1kZWZhdWx0LXJlZi5jb20vqQLUhSKd_aGyPsACAuACAOoCGDU3MzEvaGJidHZfcHJvNy9oZHQubmV3c_gCgtIekAOMBpgDjAaoAwHQBJBO4AQB0gUGEI3MsbIEkAYBoAYf2AcA4AcO&num=0&cid=5GjHnAPMECe1-eNkyhsJ1ld2&sig=AOD64_3lXVH1P-kw7AzsV3vCec-4pmrvzA&client=ca-pub-3659349150120535&adurl=http://maxdome-cdn.bittubes.com/maxdome/index.html%3Fid%3D11",
         "track": "",
         "track2": "",
         "track3": ""
     });

    In case of video ads correct response is of the form document.write([encoded VAST string]). For the ad to be played back the response must contain a URL of the video ad of type video/mp4 and the specified length of the commercial must be more than 2 seconds.

  3. Check the flow using a debugging script. Inject the following script into the application:

        AdLayer.on(AdLayer.events.adlayer.dataMapped ,function () {
        console.log('mapped:', JSON.parse(JSON.stringify(AdLayer.lastMappedParams)));
    });

    then run the application to the point where the ad should appear. For example when expecting a preroll block shortly before it should appear the console will contain the following output: mapped: Array [ Object, Object, Object, Object ] Every Object corresponds to a single ad. Every Object will contain the following fields:

    • adName - name of the ad
    • mapData - page parameters submitted by the application + some automatically generated by the AdLayer
    • mappedData - ad tag parameters generated by the AdLayer based on the mapData.

    Check if the mapData contains parameter that you would expect to see in the ad tag and adjust your mapping file as necessary.

    • If the ad is not playing and you see the mapped reports in console, the problem is most likely with your mapping file.
    • If the ad is not playing and you don't see the mapped reports in the console, the particular ad or ad block may have been disabled by either you in the mapping file or the application. Check your allowedAds and disallowedAds otherwise contact the developer to check if they have switched off a block. Please note that you should encourage the developers to not switch off any ads. You will be better off if you specify corresponding rules in the mapping file for then there will be no need for updating the application everytime you want to add a new commercial.

    You can inject the script above by running it from the console. Make sure that you run this well before the attempted ad playback. If you have a JSONP or JavaScript mapping file, you can just append the script there. However make sure you remove it afterwards, since it will cause errors on the TV. Do not put this script into mapping files already used in production!

  4. In order to check what page data is being set by application, add "adlayer_debug=1" query parameter to the application URL. This would work if application is using AdLayer v2.15.0 and newer.

        // For example, this URL
    http://myapp.com/index.php

    // Will become
    http://myapp.com/index.php?adlayer_debug=1

    // And this URL
    http://myapp.com/index.php?someAppParams=2

    // Will become
    http://myapp.com/index.php?someAppParams=2&adlayer_debug=1

    In case you can't change URL (e.g. you're debugging on the device), but still can use console, try running the following snippet before launching video:

        AdLayer.___s=AdLayer.setPageData;AdLayer.setPageData=function(d){console.group('AdLayer.setPageData called with params:');console.log(d);console.groupEnd();return AdLayer.___s(d)};

    Also, snippet above should work if application is using AdLayer v2.14.0 and older.

AdProxy and the purpose of it

AdProxy is a server software that is hosted at http://hbbtv-adproxy01.sim-technik.de/adproxy. AdProxy has been originally created to work around the problem of third-party cookies. That is while the app is hosted at app.de ads are coming from ad.71i.de and tracking URLs are scattered over different domains. Any cookies set on these domains are ignored on some devices/platforms. With AdProxy, AdLayer will send every ad or tracking request through the AdProxy address, which in turn will collect all incoming cookies, hash these and send it in a cookie called wrapper_proxy to the client.

Another feature of the AdProxy is to hide the VAST wrapper logic from the client. If the ad server ever delivers a wrapper directive in the VAST, AdProxy resolves it by following the chain of wrappers up until the point when the regular VAST is delivered. Tracking URLs from the intermediate wrappers are collected and added to the final VAST which is delivered to the client.

And finally the third important feature is to standardize the response of ad server to the format that AdLayer expects.

AdProxy forwards all the client headers to the ad server, so except from the origin IP the request is not at all modified. The IP of hbbtv-adproxy01.sim-technik.de has been whitelisted with the ad server.

To configure AdLayer to use AdProxy, app developers have to specify its address in proxyService parameter in the AdLayer.setup like so:

AdLayer.setup({
    proxyService : "http://ad-proxy01.sim-technik.de/adproxy",
    // ... further setup parameters
});

If the platform suffers from the third-party cookie problem then the app developers must additionally create a DNS record for a subdomain of app.de to point to the IP address of ad-proxy01.sim-technik.de. Then instead of the ad-proxy01.sim-technik.de domain they would use the newly created subdomain: proxyService : "http://adproxy.app.de/adproxy"

Generally it is advised that every app, that uses AdLayer should also use AdProxy unless there is a very specific reason against that. AdProxy can also be and is used without an ad layer for external apps, that have trouble implementing the full ad server communication.

Debugging with AdProxy switched on

You can force the AdProxy to show entire network communication for a specific URL by appending &debug to the URL like so:

http://hbbtv-adproxy01.sim-technik.de/adproxy?&url=http%3A%2F%2Fad.de.doubleclick.net%2FN5731%2Fadj%2Fhbbtv_sixx.video%2Fvc.sixx.paula_kommt%3Bsz%3D10x1%3Bpos%3D1%3Bvpos%3D1%3Bvtype%3D1%3Bzz%3D10x1%3Bbt%3D0%3Bxx%3Dvp%3Bxx%3Dsco%3Bupc%3D3670598%3Bdev%3Dunknown%3B%3Bi52%3D1%3Bd4%3D0%3Bd21%3D0%3Bd16%3D1%3Bf1%3D8%3Bf2%3D2%3Bf3%3D2%3Bi53%3D1%3Bd17%3D1%3Bi54%3D1%3Bd15%3D3%3Bv2%3D3%3Bd9%3D2%3Bd19%3D1%3Bd1%3D1%3Bd12%3D1%3Bd8%3D1%3Bd10%3D4%3Bd13%3D4%3Bn9%3D0%3Bn5%3D1%3Bn8%3D0%3Bn3%3D1%3Bd20%3D0%3Bc1%3D1%3Bc7%3D1%3Bi9%3D1%3Bi13%3D1%3Bi3%3D1%3Bi18%3D1%3Bi46%3D1%3Bi10%3D1%3Bi15%3D1%3Bi11%3D1%3Bi42%3D1%3Bi36%3D1%3Bi26%3D1%3Bmdid%3DokClxVtnddbbfHdcIvytn0FVUL0SrykCtQ25FPfkBu3dzHZ6rsbbuVwNSoCjvgG3C5CyznodOMQFmWBi%3Bord%3D14398895742751&debug=1

Please note that this does not work with tracking URLs.

Testing midroll integration

In production midrolls are usually delivered every 10 - 12 minutes. It may become rather weary to test the integration if one has to wait 10 minutes for every test. You can avoid wating times by specifying a smaller number for midrollStart . For example:

{
    "format" : "midrolltest",
    "allowedAds" : ["defaultAdGroupForGeneralCase"],

    "midrollStart" : 15,
    "presplit2": {
        "midrollStart": 30
    },
}

This specifies the first midroll block to start after 15 seconds of content video and second midroll block to start after 30 seconds of content video. You can further reduce the waiting time by forbidding the preroll block.

Preparing data for the new app

Integrating AdLayer in the new app can be quite simple if you set the process right. There are a lot of different bits of information that the app developers should receive and it is important that they receive everything at the same time.

Here is a step by step instruction:

  1. Determine which ads will be in the app. Compile the list of the ads that should be available in the application.

  2. Determine which type of mapping file is appropriate for the new application. For that ask the developer if the platform is able to make requests to ad.71i.de to collect JSON data without restriction.

    • Yes: mapping file should be in JSON format
    • No: mapping should be in JSONP format.

In some very special cases you will have to create a JavaScript mapping file. You should by all means avoid resorting to JavaScript mapping.

  1. Create a simple mapping file, preferably with a single default rule, test that file on an existing AdLayer installation and make sure that some ads are coming. Do not fill up all the rules in the mapping file yet. Deploy this mapping file to the server and remember its URL.

  2. Determine which page parameters you would like the app to send and compile a list of these parameters. You should try to avoid parameters that would have constant value and keep the parameter list concise.

  3. Prepare showrooms for forced ad server behaviors. Due to frequency capping, geotargeting, etc. the ad server response varies. This is very confusing for the app developer, since it looks like a bug in the application or in AdLayer. Therefore you should prepare at least 2 showrooms:

    • Every ad request delivers the ad every time. Preferably it is the same ad for a unique position, i.e. the same video for preroll or the same graphic for a fullbanner.
    • Every ad request delivers a fallback or empty ad.

    If the app is supposed to use many ads, you can prepare more showrooms to help test different ad combinations.

  4. Determine if and how the app should be using AdProxy. Generally you would always want the app to use the AdProxy unless there is a very specific reason not to use it. You should inquire of the app developer if the platform has trouble remembering third party cookies.

    • No, there are no troubles with cookies: The proxyService parameter should be set to "http://hbbtv-adproxy01.sim-technik.de/adproxy".
    • Yes, third-party cookies can be blocked: Ask the app developers to create a subdomain that would point to the same IP address as hbbtv-adproxy01.sim-technik.de. For example if the app would be hosted at app.de you would ask them to create a subdomain adproxy.app.de.

  5. Determine if the app should be using the Unique ID feature. AdLayer has a UUID module that generates a random UUID and keeps it persistent throughout all apps that have integrated AdLayer. This uuid is submitted to the ad server with every request.

    • Yes: Have the host.html file handy (see Unique ID section for details)
    • No: Nothing is required.

  6. Determine if nuggad is required for this app.

    • Yes: Prepare nuggsid for app developers and be prepared to setup nuggtg in the mapping file.

  7. Send the following to the developers in one go:

  8. After the basic integration is done and you can confirm that the app can display showroom ads, you can start adding rules to the mapping file. If a console is available, AdLayer outputs the passed page parameters for every ad request. You can thus verify if the parameters passed are correct.

← Introduction