load.initialize(async function (){
//This code will run during Vuser initialization
});

load.initialize("myFirstInitialize", async function (){
   //This code will run during Vuser initialization
}); 
load.initialize("mySecondInitialize", async function (){
   //This code will run during Vuser initialization
});

load.finalize(async function (){
//This code will run during Vuser finalization
});

load.finalize("myFirstFinalize", async function(){
   //This code will run during Vuser finalization
}); 
load.finalize("mySecondFinalize", async function(){
   //This code will run during Vuser finalization
});

load.action(async function(){
  //This will run first during the run phase    
});

load.action("myFirstAction", async function(){
  //This will run first during the run phase    
}); 
load.action("mySecondAction",async function(){
  //This will run second during the run phase
});

const jsonPage = new load.WebRequest({
url: "http://myserver/cgi-bin/json/generate_json_simple.asp",   
method: "GET"
returnBody: true
}); 
const jsonResponse = jsonPage.sendSync();

load.WebRequest.defaults.method = "POST"; 
const webRequest = new load.WebRequest("www.foo.bar");  
//webRequest.method === "POST"	

const webRequest = new load.WebRequest({
	url:"www.url.com"
	method: "POST",
	id: 1
}); 
//If you don't need to change the method (default is "GET") then you can do the following: 
const webRequest = new load.WebRequest("www.url.com");

new load.WebRequest({
        url: "http://someHostName",
        method: "POST",
        headers: {
            "Accept-Encoding": "gzip, deflate, sdch",
        },
        body: new load.MultipartBody([
                new load.MultipartBody.StringEntry("entry", "some text"),
                new load.MultipartBody.FileEntry("name_of_files",
                    "test.json",
                    "text/plain",  // Content-Type property, optional, default is 'text/plain'
                    "newFile.json" // filename property, optional, default is the file name
                )
            ],
            "---myBoundary---")// Boundary property, optional, randomly generated if not supplied
    }).sendSync();

new load.MultipartBody([
                new load.MultipartBody.StringEntry("myName", "myText")
                ]);

new load.MultipartBody([
                ["string","myName", "myText"]
                ]);

const webRequest = new load.WebRequest("www.url.com"); 
webRequest.send().then(function(response) {
			//Do something with the response
}).catch(function(error) {
			//Handle the error or throw it
});

Promise.all([
	(new load.WebRequest("www.first.com")).send(),
	(new load.WebRequest("www.second.com")).send(),
	(new load.WebRequest("www.third.com")).send()
]).then((results)=>{
	//This will be called when all 3 requests return
	//Do something with all 3 results
});			

const response1 = request1.sendSync(); //Create a WebResponse
load.log(response1.body); //Print the response body to the console
load.log("Request startTime: " + new Date(response.startTime).toISOString(), load.LogLevel.info); // print request start time               

const response = request.sendSync(); 
if (response.textCheck("Web Tours")){
    	load.log("Success!");\
} else {
	load.log("Failure!"); 
}

let messageHandler = function (message) {
      load.log(`Got message on ${socket.id}`, load.LogLevel.info); 
    }

    const socket = new load.WebSocket({
        url: "ws://myserver:8080",
        onMessage: messageHandler
    }); 

    socket.open(); 
    socket.send("Ping", false); 
    socket.send({dataPath: "c:\\myImg.png", isBinary: true}); 
    socket.close();

 let messageHandler = function (message) {
      load.log(`Received message ${message.data}, socket id ${socket.id}`, load.LogLevel.info); 
    }

    let errorHandler = function (err) {
        load.log('Socket error: ' + JSON.stringify(err), load.LogLevel.error); 
    }

    let openHandler = function (response) {
      load.log(`Socket id: ${response.id} opened.Status: ${response.status}`, load.LogLevel.info); 
    }

    let closeHandler = function (code) {
      load.log(`Socket id ${socket.id} closed, message: ${code}`, load.LogLevel.info); 
    }

    const socket = new load.WebSocket({
        url: "ws://myserver:8080",
        onMessage: messageHandler,
        onError: errorHandler,
        onOpen: openHandler,
        onClose: closeHandler
    });

const socket = new load.WebSocket({
    url: "ws://ws.myhostname.com:8080",
    onMessage: (message)=>{ load.log(message.data); },
}); 

socket.open();

const socket = new load.WebSocket({
    url: "ws://ws.myhostname.com:8080",
    onMessage: (message)=>{ load.log(message.data); },
}); 
socket.open(); 

socket.send("ping");

const socket = new load.WebSocket({
    url: "ws://ws.myhostname.com:8080",
    onMessage: (message)=>{ load.log(message.dataPath); },
}); 
socket.open(); 

socket.send({dataPath: "c:\\myImg.png", isBinary:true});

const socket = new load.WebSocket({
    url: "ws://ws.myhostname.com:8080",
    onMessage: (message)=>{load.log(message);},
}); 
socket.open(); 

socket.send("ping", false); 
socket.close();

const socket = new load.WebSocket({
    url: "ws://ws.myhostname.com:8080",
    onMessage: (message) => {
        if (message.data === 'myMessage'){
          socket.continue(); 
        }
    },
}); 
socket.open(); 
socket.send("ping", false); 
await socket.waitForData(6000); 
socket.close();

const socket = new load.WebSocket({
    url: "ws://ws.myhostname.com:8080",
    onMessage: (message) => {
        if (message.data === 'myMessage'){
          socket.continue(); 
        }
    },
}); 
socket.open(); 
socket.send("ping", false); 
socket.waitForData(60000); 
socket.close();

const socket = new load.WebSocket({
    url: "ws://ws.myhostname.com:8080",
    onMessage: (message) => {
        if (message.data === 'end'){
          socket.close(); 
        }
    },
}); 
socket.open(); 
socket.send("ping", false); 
socket.waitForClose(3000);

 const client = new load.GrpcClient({
        host: "myHost",
        isInsecure: true,
        defaults: {
            headers: {
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18363"
            }
        }
    }); 

    const client = new load.GrpcClient('myHost');

const client = new load.GrpcClient('myHost'); 
const helloMethod = client.unaryRequest({
        id: 1,
        method: "package.Service.Hello",
        protoFile: "./proto/hello.proto"
    }); 
const response = helloMethod.sendSync();

const client = new load.GrpcClient('myHost'); 
const recordRoute = client.clientStreamRequest({
        id: 3,
        method: "routeguide.RouteGuide.RecordRoute",
        protoFile: "./proto/route_guide.proto",
        bodyArray: [{
            "latitude": 407838351,
            "longitude": -746143763
        },
        {
            "latitude": 415736605,
            "longitude": -742847522
        }]
    }); 
const response = recordRoute.sendSync();

const client = new load.GrpcClient('myHost'); 
const lotsOfReplies = client.serverStreamRequest({
      id: 1,
      method: "hello.HelloService.LotsOfReplies",
      protoFile: "./proto/hello.proto",
      body: {
        "greeting": `DevWeb hello`
      },
      extractors: [
        new load.JsonPathExtractor("myReply", "$[0].reply")
      ],  
    }); 
const response = lotsOfReplies.sendSync();

const client = new load.GrpcClient('myHost'); 
const helloMethod = client.unaryRequest({
        id: 1,
        method: "package.Service.Hello",
        protoFile: "./proto/hello.proto"
    }); 

const response = helloMethod.sendSync();

const client = new load.GrpcClient('myHost'); 
const helloMethod = client.unaryRequest({
    id: 1,
    method: "package.Service.Hello",
    protoFile: "./proto/hello.proto"
}); 

helloMethod.send().then(function(response) {
    //Do something with the response  
}).catch(function(error) {
    //Handle the error or throw it
});

const client = new load.GrpcClient('myHost'); 
const route = client.clientStreamRequest({
        id: 1,
        method: "routeguide.RouteGuide.RecordRoute",
        protoFile: "./proto/route_guide.proto",
        bodyArray: [{
            "latitude": 407838351,
            "longitude": -746143763
        },
        {
            "latitude": 415736605,
            "longitude": -742847522
        }],
    }); 

const response = route.sendSync();

const client = new load.GrpcClient('myHost'); 
const route = client.clientStreamRequest({
        id: 1,
        method: "routeguide.RouteGuide.RecordRoute",
        protoFile: "./proto/route_guide.proto",
        bodyArray: [{
            "latitude": 407838351,
            "longitude": -746143763
        },
        {
            "latitude": 415736605,
            "longitude": -742847522
        }],
    }); 

route.send().then(function(response) {
    //Do something with the response  
}).catch(function(error) {
    //Handle the error or throw it
});

const client = new load.GrpcClient('myHost'); 
const features = client.serverStreamRequest({
        id: 1,
        method: "routeguide.RouteGuide.ListFeatures",
        protoFile: "./proto/route_guide.proto",
        body: {
            "lo": { "latitude":"407838351", "longitude":"-746143763" },
            "hi": { "latitude":"413700272", "longitude":"-742135189" }
        }
    }); 

const response = features.sendSync();

const client = new load.GrpcClient('myHost'); 
const features = client.serverStreamRequest({
        id: 1,
        method: "routeguide.RouteGuide.ListFeatures",
        protoFile: "./proto/route_guide.proto",
        body: {
            "lo": { "latitude":"407838351", "longitude":"-746143763" },
            "hi": { "latitude":"413700272", "longitude":"-742135189" }
        }
    }); 

features.send().then(function(response) {
    //Do something with the response  
}).catch(function(error) {
    //Handle the error or throw it
});

const client = new load.GrpcClient('myHost'); 
const helloMethod = client.unaryRequest({
        id: 1,
        method: "package.Service.Hello",
        protoFile: "./proto/hello.proto"
    }).sendSync(); 
load.log(helloMethod.status); 
load.log("Invoke startTime: " + new Date(helloMethod.startTime).toISOString(), load.LogLevel.info); // print invoke start time

const boundaryRule1 = new load.BoundaryExtractor("title", "<title>", "</title>"); 
const boundaryRule2 = new load.BoundaryExtractor("thirdImage", {
  leftBoundary: "<title>",
  rightBoundary: "</title>",
  occurrence: load.ExtractorOccurrenceType.Last
}); 
const boundaryRule3 = new load.BoundaryExtractor("someBase64", {
  leftBoundary: 'base64Encoded:"',
  rightBoundary: '",',
  converters: "base64Decode", //The extracted value will be automatically decoded from base64
  transform: (value, request, response) => {
    if (response.status === 500) { //For response status code 500, we want the extracted value to be "error"
      return "error"; 
    }
    return value
  }
}); 
const myPageRequest = new load.WebRequest({
  url: "http://myServer.com/main/product.html",
  method: "GET",
  returnBody: false, //You don't need to return the body to get the extractors
  extractors: [
    boundaryRule1, //Extract the title of the page
    boundaryRule3  //Extract a value and then decode it from base64
  ]
}); 
const myResponse = myPageRequest.sendSync(); 

//The extractor result value is available under the name of the extractor
load.log(`The title of the page is ${myResponse.extractors.title}`); 

load.log(`The third image is ${myResponse.extractors.thirdImage}`);

 const regexpRule1 = new load.RegexpExtractor("title","<title>(.*?)</title>","i"); 
 const regexpRule2 = new load.RegexpExtractor("fullTitle",{
   expression: "<title>(.*?)</title>",
   flags: "i",
   groupNumber: 0
 }); 
 const regexpRule3 = new load.RegexpExtractor("someImage",{
   expression:"<img>(.*?)</img>",
   flags:"i",
   occurrence:2,
   includeRedirections:true
   }); 
 const regexpRule4 = new load.RegexpExtractor("someBase64",{
   expression:"<myBase64htmlEncoded>(.*?)</myBase64htmlEncoded>",
   converters:"base64Decode,htmlUnescape",
   transform: (value, request, response)=>{
      if (request.url === "server1"){
        return "fixed "+value; 
      }
      return value
     }
   }); 
 const myPageRequest = new load.WebRequest({
      url: "http://myServer.com/main/product.html",
      method: "GET",
      returnBody: false, //You don't need to return the body to get the extractors
      extractors:[
          regexpRule1,  //Extract only the title of the page (group 0)
          regexpRule2,  //Extract the entire expression and all the groups
          regexpRule3,  //Extract the first group of the third occurrence including redirections
          regexpRule4   //Extract the value then convert it from base64 and unescape the HTML, then if the url was "server1" add a prefix to the value
        ]
  }); 

const myResponse = myPageRequest.sendSync(); 

//The extractor result value is available under the name of the extractor.
load.log(`The title of the page is ${myResponse.extractors.title}`); 

//Since we want only the title, we will take the extractor result of the first group
load.log(`The title of the page is ${myResponse.extractors.fullTitle.groups[0]}`); 
//We can get the full match as well
load.log(`The full matched expression is ${myResponse.extractors.fullTitle.full}`); //This will log <title>Products</title> to the log
//We can retrieve a particular occurrence
load.log(`The third image of the page is ${myResponse.extractors.someImage}`);

const productNameExtractor = new load.JsonPathExtractor("productName","$.products[0].name"); 
 const myPageRequest = new load.WebRequest({
      url: "http://myServer.com/main/products.json",
      method: "GET",
      returnBody: false, //You don't need to return the body to get the extractors
      extractors: productNameExtractor //Extract the name of the first product
  }); 

const myResponse = myPageRequest.sendSync(); 

//The extractor result value is available under the name of the extractor
load.log(`The name of the first product is ${myResponse.extractors.productName}`); 

 const productNameExtractor = new load.XpathExtractor("productName","/products[0]/name"); 
 const productNameExtractorSingle = new load.XpathExtractor("firstProductName",{
    path: "/products[*]",
    returnMultipleValues: false
 }); 

 const myPageRequest = new load.WebRequest({
      url: "http://myServer.com/main/products.xml",
      method: "GET",
      returnBody: false, //You don't need to return the body to get the extractors
      extractors:[
          productNameExtractor, //Extract the name of the first product
          productNameExtractorSingle //Extract the name of the first product
        ]
  }); 

const myResponse = myPageRequest.sendSync(); 

//The extractor result value is available under the name of the extractor
load.log(`The name of the first product is ${myResponse.extractors.productName}`);

const textCheck1 = new load.TextCheckExtractor("checkBody","hello"); 
 const textCheck2 = new load.TextCheckExtractor("checkAll",{
   text: "world",
   scope: load.ExtractorScope.All,
   failOn: false
 }); 

 const myPageRequest = new load.WebRequest({
      url: "http://myServer.com/main/products.json",
      method: "GET",
      returnBody: false, //You don't need to return the body to get the extractors
      extractors:[
          textCheck1, //Check that response body contains "hello"
          textCheck2  //Check both the body and the headers for the word "world" but fail the iteration if the word isn't found
        ]
  }); 

const myResponse = myPageRequest.sendSync(); 

//The extractor result value is available under the name of the extractor
if (myResponse.extractors.checkBody){
    load.log(`The world "hello" was found in the response body`); 
}

 const productNameExtractor = new load.HtmlExtractor("productName","div[productId=3]","productName"); 
 const productNameExtractorSingle = new load.HtmlExtractor("lastProductName",{
   querySelector: "div",
   attributeName: "productName",
   occurrence:load.ExtractorOccurrenceType.Last
 }); 

 const myPageRequest = new load.WebRequest({
      id: 1,
      url: "http://myServer.com/main/products.html",
      method: "GET",
      returnBody: false, //You don't need to return the body to get the extractors
      extractors:[
          productNameExtractor, //Extract the name of the product with id = 3 via the productName attribute
          productNameExtractorSingle //Extract the value of the productName attribute of the last div that has productName
        ]
  }); 

const myResponse = myPageRequest.sendSync(); 

//The extractor result value is available under the name of the extractor
load.log(`The name of the product is ${myResponse.extractors.productName}`); 

const webResponse2 = new load.WebRequest({
    id: 2,
    url: "https://myHost/auth/oauth2/grant",
    method: "GET",
    extractors: new load.HtmlExtractor("SAMLRequest", {
            "querySelector": "input[type=hidden][name=SAMLRequest]",
            "attributeName": "value"
        }),
    ],
}).sendSync();

 const cookie1 = new load.CookieExtractor("myCookie1", "jsessionid", "go.mic.com"); 
 const cookie2 = new load.CookieExtractor("myCookie2",{
   cookieName:"jsessionid",
   path:"/",
   occurrence:load.ExtractorOccurrenceType.Last
 }); 

 const myPageRequest = new load.WebRequest({
      url: "http://myServer.com/main/product.html",
      method: "GET",
      returnBody: false, //You don't need to return the body to get the extractors
      extractors:[
          cookie1, //Extract jsessionid cookie with domain go.mic.com value
          cookie2  //Extract jsessionid cookie with path \ value
        ]
  }); 

const myResponse = myPageRequest.sendSync(); 

//The extractor result value is available under the name of the extractor
load.log(`jsessionid with domain go.mic.com ${myResponse.extractors.cookie1}`); 

load.log(`jsessionid with path \ ${myResponse.extractors.cookie2}`);

const documentTitleExtractor = new load.RegexpExtractor("title","<title>(.*?)</title>","i"); 
const myPageRequest = new load.WebRequest({
	url: "http://myServer.com/main/product.html",
	method: "GET",
	returnBody: false, //You don't need to return the body to get the extractors
	extractors: [documentTitleExtractor]
}); 

const myResponse = myPageRequest.sendSync(); 

//The extractor result value is available under the name of the extractor
load.log(`The title of the page is ${myResponse.extractors.title}`); 
//The result is also stored on the load namespace
load.log(`The title of the page is ${load.extractors.title}`);

let transaction = new load.Transaction( "My Transaction");

let transaction = new load.Transaction( "My Transaction"); 
transaction.start();

let transaction = new load.Transaction("My Transaction"); 
transaction.start(); 
						
// ... later ...
						
transaction.stop(); 
//transaction.duration is now assigned with the duration

let transaction = new load.Transaction("My Transaction"); 
transaction.set(load.TransactionStatus.Passed, 1000); 
//The transaction is now considered successful and the duration is 1 second
//transaction.duration is now assigned with the duration

let transaction = new load.Transaction("My Transaction"); 
transaction.start(); 
						
// ... later ...
						
transaction.update(); 
if (transaction.duration > 2000) {
	transactionStatus = load.TransactionStatus.Failed; 
}
transaction.stop(transactionStatus);

var paramValue = load.params.myParam1; 
var nextParamValue = load.params.myParam1; //if nextValue is "always" this will be a new value
var someString = `The value of myParam1 is ${load.params.myParam1}`; //You can put it in a string with the standard JavaScript syntax

load.log("This will be written to the log", load.LogLevel.debug);

load.sleep(10.5); //スクリプトを10秒と500ミリ秒一時停止します

load.setUserCredentials({
	username: "loader",
	password: "runner",
	host:"*",
}); 
						
load.setUserCredentials([{
	username: "john",
	password: "smith",
	domain:"mydomain",
	host:"^mfs1*"
},{
	username: "john",
	password: "doe",
	domain:"mydomain",
	host:"^mfs2*"
])

 load.setUserCredentials(new load.AWSAuthentication(load.AWSProviderType.Static, {
           accessKeyID: "myKey",
           secretAccessKey: "mySecret",
       })); 

    load.setUserCredentials(new load.AWSAuthentication(load.AWSProviderType.Env)); 

    load.setUserCredentials(new load.AWSAuthentication(load.AWSProviderType.Shared, {
        fileName: "example.ini",
    }));

   load.setUserCertificate("./cert.pem", "./key.pem"); 
   load.setUserCertificate("./cert.pem", "./key.pem", "myPass");

load.log("Before Exit"); 
load.exit("stop"); //Can also use load.exit(load.ExitType.stop); 
load.log("After Abort"); //This message will not be shown!

const request = new load.WebRequest({
    url: "http://someHostName",
    headers: {
        "x-secret-key": load.unmask("Tm90IHRoZSBwYXNzd29yZA==")
    }
}); 

const response = request.sendSync();

const request = new load.WebRequest({
    url: "http://someHostName",
    headers: {
        "x-secret-key": load.decrypt("Tm90IHRoZSBwYXNzd29yZA==")
    }
}); 

const response = request.sendSync();

load.exec("notepad.exe",["myFile.txt"]); 

const result = load.exec({
 command: "cmd.exe",
 args: ["/c","dir"],
 returnOutput: true
})

if (result.exitCode === 0) {
 load.log(`The files are ${result.output}`); 
} else {
 load.log(`Error running dir ${result.message}`,load.LogLevel.error); 
}

const bgPromise = load.exec({
   command: "backgroundCalculation.exe",
   isAsync: true
}); 
// ... rest of script ...
// at the end of the script: 
await bgPromise; 

await load.exec({
   command: "always_error.exe",
   isAsync: true
}).catch((error)=>{
  load.log(`The standard error data is ${error.content.error}`); 
});

load.action("Action", async function () {
    let counter = 0; 
    let timer = new load.Timer(() => {
        load.log(counter + ": timer [" + timer.id + "] called", load.LogLevel.info); 
        if (counter === 8) {
            load.log("timer expired", load.LogLevel.info); 
            timer.stop(); 
        }
        counter++; 
    }, 1000); 
    timer.startInterval(); 
    await timer.wait(); 
});

    load.action("Action", async function () {
        let timer = new load.Timer(() => {
                timer.stop(); 
        }, 5000); 
        timer.startTimeout(); 
        await timer.wait(); 
    });

    load.action("Action", async function () {
        let counter = 0; 
        let timer = new load.Timer(() => {
        }, 1000); 
        timer.startTimeout(); 
        await timer.wait(); 
    });

 load.action("Action", async function () {
      	 let counter = 0; 
        let timer = new load.Timer(() => {
            if (counter === 4) {
               timer.stop(); 
            }
            counter++; 
        }, 5000); 
        timer.startInterval(); 
        await timer.wait(); 
    });

load.action("Action", async function () {
        let counter = 0; 
        let timer = new load.Timer(() => {}, 5000); 
        timer.startTimeout(); 
        await timer.wait(); 
});

load.config.user.userId;   //1 for the first user

load.config.user.args["key1"];   //will return the value of key1 or undefined if not supplied
//OR
load.config.user.args.key1;   //will return the value of key1 or undefined if not supplied

load.config.script.name;  //"MyScript" if the script is located in C:\scripts\MyScript>
load.config.script.directory; //"C:\scripts\MyScript" if the script is located in C:\scripts\MyScript
load.config.script.fullPath;  //"C:\scripts\MyScript\main.js" if the script is located in C:\scripts\MyScript

load.config.host.name;   //The name of the machine running the script
load.config.host.platform; // win32 (for Windows), darwin (for iOS), linux (for Linux)

load.config.env.Path; //この仮想ユーザーを実行するマシンのパス

load.config.runtime.iteration; //仮想ユーザーの反復回数

load.utils.getByBoundary("<Foo>","<",">"); // returns Foo
load.utils.getByBoundary("Unbounded Foo>",undefined,">"); // returns Unbounded Foo
load.utils.getByBoundary("<Unbounded Foo","<",undefined); // returns Unbounded Foo
load.utils.getByBoundary("Some String","<",">"); //returns null

load.utils.reportDataPoint("My data point", 42);

let value = load.utils.base64Encode("hello"); 
// Output: aGVsbG8=

let word = load.utils.base64Encode("schön", { charset: "iso-8859-1" }); 
// Output: c2No9m4=

let test = load.utils.base64Encode("<<???>>", { base64URL: true,  noPadding: true }); 
// Output: PDw_Pz8-Pg

let value = load.utils.base64Decode("aGVsbG8="); 
// Output: hello

let word = load.utils.base64Decode("c2No9m4=", { charset: "iso-8859-1" }); 
// Output: schön

let test = load.utils.base64Decode("PDw_Pz8-Pg", { base64URL: true,  noPadding: true }); 
// Output: <<???>>

let uuid = load.utils.uuid();

let signing = load.utils.hash(load.HashAlgorithm.sha256, "my text"); 

let myHash = load.utils.hash(load.HashAlgorithm.sha256, "my text", load.HashOutputEncoding.base64RawURL);

let signing = load.utils.hash("my text",{
  algorithm: load.HashAlgorithm.sha256
}); 

let myHash = load.utils.hash("my text",{
  algorithm: load.HashAlgorithm.sha256,
  outputEncoding: load.HashOutputEncoding.base64RawURL
});

let signing = load.utils.hmac(load.HashAlgorithm.sha256, "my_big_secret", "hello world!"); 

let myHmac = load.utils.hmac(load.HashAlgorithm.sha256, "my_big_secret", "hello world!", load.HashOutputEncoding.base64RawURL);

let signing = load.utils.hmac("hello world!",{
  algorithm: load.HashAlgorithm.sha256,
 secret: "my_big_secret"
}); 

let myHmac = load.utils.hmac("hello world!",{
  algorithm: load.HashAlgorithm.sha256,
  secret: "my_big_secret",
  outputEncoding: load.HashOutputEncoding.base64RawURL
});

let samlMessage = `<samlp:AuthnRequest xmlns:samlp=\"urn:oasis:names:tc:SAML:2.0:protocol\" xmlns:saml=\"urn:oasis:names:tc:SAML:2.0:assertion\" ID=\"ONELOGIN_809707f0030a5d00620c9d9df97f627afe9dcc24\" Version=\"2.0\" ProviderName=\"SP test\" IssueInstant=\"2014-07-16T23:52:45Z\" Destination=\"http://idp.example.com/SSOService.php\" ProtocolBinding=\"urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST\" AssertionConsumerServiceURL=\"http://sp.example.com/demo1/index.php?acs\">
                      <saml:Issuer>http://sp.example.com/demo1/metadata.php</saml:Issuer>
                      <samlp:NameIDPolicy Format=\"urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress\" AllowCreate=\"true\"/>
                      <samlp:RequestedAuthnContext Comparison=\"exact\">
                        <saml:AuthnContextClassRef>urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport</saml:AuthnContextClassRef>
                      </samlp:RequestedAuthnContext>
                      </samlp:AuthnRequest>`; 
let samlEncode = load.utils.samlEncode(samlMessage); 
load.log(`samlEncode: ${samlEncode}`);

//base32 encoded string: "12345678901234567890"; 
let secret = "GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ"; 

totpTimestamp = Date.now(); 
load.log(`Time now is: ${totpTimestamp}`); 

let key = load.utils.totp(secret, totpTimestamp); 
load.log(`TOTP Token: ${key}`);

//base32 encoded string: "12345678901234567890"; 
let secret = "GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ"; 

totpTimestamp = Date.now(); 
load.log(`Time now is: ${totpTimestamp}`); 

let key = load.utils.totp(_secret, totpTimestamp, {digits: 8, algorithm: load.HashAlgorithm.sha512}); 
load.log(`TOTP Token: ${key}`);

nslookup -type=SRV _<service>._<protocol>.<domain>

let hostname = load.net.lookupService('xmpp-service', 'tcp', 'example.com'); 

let request = new load.WebRequest({
    id: 1,
    url: `https://${hostname}`,
    method: `GET`
});

const cookie = new load.Cookie({
	name:"myCookie",
	value:"foo"
})
load.addCookies(cookie);

const cookie = new load.Cookie({
	name:"myCookie",
	value:"foo"
})
load.addCookies(cookie); 

                    // later
						
load.deleteCookies(cookie);

const cookie = new load.Cookie({
	name:"myCookie",
	value:"foo"
})
load.addCookies(cookie); 

//later
                  
load.clearCookies();

qwerty=219ffwef9w0f; Domain=somecompany.co.uk; Path=/; Expires=Wed, 30 Aug 2019 00:00:00 GMT

const cookie1 = new load.Cookie({
                    name:"myCookie",
                    value:"foo"
                    domain: “somecompany.co.uk”
}); 
                    
const cookie2 = new load.Cookie("qwerty=219ffwef9w0f; Domain=somecompany.co.uk; Path=/; Expires=Wed, 30 Aug 2019 00:00:00 GMT");

const vtsClient = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
});

const vtsClient = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}); 
const myColumn = vtsClient.getColumn("myColumn");

const vtsClient = load.vtsConnect({
server: "http://my.server.com",
port: 1234
}); 
const myRow = vtsClient.getRow(2);

const vtsClient = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}); 
const myColumn = vtsClient.createColumn("myColumn");

const vtsClient = load.vtsConnect({
server: "http://my.server.com",
port: 1234
}); 
const columnValues = vtsClient.popColumns(["col1","col2"]); 
load.log(`The value of col1 is ${columnValues.col1}`);

const vtsClient = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}); 
const columnValues = vtsClient.rotateColumns(["col1","col2"], load.VTSPlacementType.unique); 
load.log(`The value of col1 is ${columnValues.col1}`);

const vtsClient = load.vtsConnect({
                    server: "http://my.server.com",
                    port: 1234
                    }); 
                    const columnValues = vtsClient.setValues(["col1","col2"], ["myValue1","myValue2"], load.VTSPlacementType.sameRow);

const vtsClient = load.vtsConnect({
         server: "http://my.server.com",
         port: 1234
       }); 
 vtsClient.replaceExistingValue(["col1","col2"], "myNewValue", "oldValue");

const vtsClient = load.vtsConnect({
         server: "http://my.server.com",
         port: 1234
       }); 
const row = vtsClient.searchRows(["userID"], ["junior5"], ","); 
load.log(`row: ${row.useHash}, ${row.userID}, ${row.userPWD}`) // e.g row: 3, junior5, 12345

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                    
                    myColumn.client.createColumn("newColumn");

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                   
myColumn.clear();

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                   
const size = myColumn.size(); 
load.log(`The size of someColumn is ${size}`);

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                   
myColumn.createIndex();

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                  
myColumn.dropIndex();

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                   
myColumn.addValue("myValue",true); //Will add "myValue" only if it doesn't exist in the column already

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                 
myColumn.clearField(3); //Will clear row 3 in this column

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                  
myColumn.incrementField(2, 10); //Will increment row 2 in the column by 10

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                  
const myValue = myColumn.getFieldValue(2);

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                
myColumn.setFieldValue(1, "new value"); 
                   
myColumn.setFieldValue(1, "even newer value","new value");

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                   
const someValue = myColumn.pop();

const myColumn = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getColumn("someColumn"); 
                 
const someValue = myColumn.rotate(load.VTSPlacementType.stacked);

const myRow = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getRow(1); 
                    
myRow.client.createColumn("newColumn");

const myRow = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getRow(1); 
                 
                    myRow.clear();

const myRow = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getRow(1); 
                    
const values = myRow.getValues(); 
load.log(`The value of myColumn is ${values.myColumn}`);

const myRow = load.vtsConnect({
	server: "http://my.server.com",
	port: 1234
}).getRow(1); 
myRow.setValues(["col1","col2"],["value1","value2"]);

const myFile = new load.File('data.xml');

const myFile = new load.File('data.xml'); 
const readResult = myFile.read({
  extractors:[
    new load.RegexpExtractor("title","<customerCode>(.*?)</customerCode>","i")
  ]
}); 

load.log(`The customer code in data.xml is ${readResult.extractors.title}`);

const myFile = new load.File('results.txt'); 
myFile.append(`vuser ${load.config.user.userId} passed the first page`);

 const myFile = new load.File('results.txt'); 
 myFile.write(`vuser ${load.config.user.userId} passed the first page`);

const myFile = new load.File('results.txt'); 
myFile.write(`vuser ${load.config.user.userId} passed the first page`); 
const isFileExists = myFile.isExists(); // returns true, if the file exists at the given moment.