Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use existenceMap method in devicefarmer-stf

Best JavaScript code snippet using devicefarmer-stf

index.js

Source:index.js

1function isInteger(n) {2  return typeof n === 'number' && (n | 0) === n;3}4function isPositiveInteger(n) {5  return isInteger(n) && n > 0;6}7function isNonNegativeInteger(n) {8  return isInteger(n) && n >= 0;9}10function reduceToSum(a, b) {11  return a + b;12}13function toNumber(a) {14  return +a;15}16function fillSequentialArray(n) {17  if (!isNonNegativeInteger(n)) {18    throw Error(`Invalid argument: n must be a non-negative integer, ${n} was provided.`);19  }20  return [...Array(n)].map((_, i) => i);21}22function generateRandomIntegerBetween(n, m) {23  if (!isNonNegativeInteger(n)) {24    throw Error(`Invalid argument: n must be a non-negative integer, ${n} was provided.`);25  }26  if (!isNonNegativeInteger(m)) {27    throw Error(`Invalid argument: m must be a non-negative integer, ${m} was provided.`);28  }29  if (n === m) {30    throw Error(`Invalid argument: n and m cannot be equal, ${n} and ${m} were provided.`);31  }32  return Math.floor(Math.random() * m) + n;33}34function generateRandomPermutation(n) {35  if (!isNonNegativeInteger(n)) {36    throw Error(`Invalid argument: n must be a non-negative integer, ${n} was provided.`);37  }38  const numbers = fillSequentialArray(n);39  const permutation = [];40  for (let i = numbers.length - 1; i >= 0; --i) {41    const randomNumber = generateRandomIntegerBetween(0, n);42    permutation.push(numbers[randomNumber]);43    numbers.splice(randomNumber, 1);44  }45  return permutation;46}47const generateNextPermutationInvalidArgumentPreText = 'Invalid argument: permutation must be an array of non-negative, non gapping, sequential integers beginning from 0,';48const cachedPermutations = {};49function verifyPermutation(permutation) {50  if (!Array.isArray(permutation)) {51    throw Error(`${generateNextPermutationInvalidArgumentPreText} value of type: ${typeof permutation} was provided.`);52  }53  const existenceMap = {};54  for (let i = 0; i < permutation.length; ++i) {55    if (!isNonNegativeInteger(permutation[i])) {56      throw Error(`${generateNextPermutationInvalidArgumentPreText} index at ${i} has value ${permutation[i]}.`);57    }58    if (existenceMap[permutation[i]] === undefined) {59      existenceMap[permutation[i]] = i;60    } else {61      throw Error(`${generateNextPermutationInvalidArgumentPreText} duplicate value of ${permutation[i]} found at indices ${existenceMap[permutation[i]]} and ${i}.`);62    }63  }64  for (let i = 0; i < permutation.length; ++i) {65    if (existenceMap[i] === undefined) {66      throw Error(`${generateNextPermutationInvalidArgumentPreText} missing value: ${i}.`);67    }68  }69}70function generateNextPermutation(permutation, skipVerification = false) {71  if (!skipVerification) {72    verifyPermutation(permutation);73  }74  75  const base = permutation.length - 1;76  if (base === -1 || base === 0) {77    return undefined;78  }79  if (permutation[base] === base) {80    return permutation.slice(0, base - 1).concat([permutation[base], permutation[base - 1]]);81  }82  for (let i = base; i > 0; --i) {83    const currentDigit = permutation[i];84    const nextDigit = permutation[i - 1];85    if (currentDigit < nextDigit) {86      continue;87    }88    89    const precedingDigits = permutation.slice(0, i - 1);90    let newDigit = nextDigit + 1;91    while (precedingDigits.indexOf(newDigit) > -1) {92      ++newDigit;93    };94    let followingDigit = 0;95    const digitMap = {};96    const nextPermutation = precedingDigits.concat([newDigit]);97    nextPermutation.forEach((d) => digitMap[d] = true);98    while (followingDigit <= base) {99      if (!digitMap[followingDigit]) {100        digitMap[followingDigit] = true;101        nextPermutation.push(followingDigit);102      }103      ++followingDigit;104    }105    return nextPermutation;106  }107  return undefined;108}109function generatePermutations(n) {110  if (!isNonNegativeInteger(n)) {111    throw Error(`Invalid argument: n must be a non-negative integer, ${n} was provided.`);112  }113  const startingPermutation = fillSequentialArray(n);114  const permutations = [startingPermutation];115  let nextPermutation = generateNextPermutation(startingPermutation, true);116  while (nextPermutation) {117    permutations.push(nextPermutation);118    nextPermutation = generateNextPermutation(nextPermutation, true);119  }120  return permutations;121}122function generatePermutationsUpTo(n) {123  if (!isNonNegativeInteger(n)) {124    throw Error(`Invalid argument: n must be a non-negative integer, ${n} was provided.`);125  }126  const permutations = [];127  for (let i = 0; i < n; ++i) {128    permutations.push(generatePermutations(i));129  }130  return permutations;131}132const applyPermutationInvalidArgumentPreText = 'Invalid argument: alphabet must be an array of uniquely serializeable values,';133function verifyAlphabet(alphabet, allowDuplicates = false) {134  if (!Array.isArray(alphabet)) {135    throw Error(`${refactorIntegerInvalidArgumentPreText} alue of type: ${typeof alphabet} was provided.`);136  }137  const existenceMap = {};138  alphabet.forEach((letter, i) => {139    try {140      const serializedLetter = JSON.stringify(letter);141      if (!allowDuplicates && typeof existenceMap[serializedLetter] === 'number') {142        throw Error(`${refactorIntegerInvalidArgumentPreText} duplicate value of ${letter} serialized to ${serializedLetter} found at indices ${existenceMap[serializedLetter]} and ${i}.`);143      } else {144        existenceMap[serializedLetter] = i;145      }146    } catch {147      throw Error(`${refactorIntegerInvalidArgumentPreText} value at index ${i} can not be serialized.`);148    }149  });150}151function applyPermutationToAlphabet(permutation, alphabet, allowDuplicates = false, skipVerification = false) {152  if (!skipVerification) {153    verifyPermutation(permutation);154    verifyAlphabet(alphabet, allowDuplicates);155  }156  157  return permutation.map((p) => alphabet[p]);158}159function factorInteger(n, includeOne = false) {160  if (typeof n !== 'number' || (n | 0) !== n || n < 1) {161    throw Error(`Invalid argument: n must be a positive integer, ${n} was provided.`);162  }163  const upperBound = Math.ceil(Math.sqrt(n));164  const factors = [];165  let remainder = n;166  if (includeOne) {167    factors.push(1);168  }169  for (let i = 2; i < upperBound; ++i) {170    while (remainder > 0 && (remainder % i === 0)) {171      remainder /= i;172      factors.push(i);173    }174  }175  if (remainder > 0) {176    factors.push(remainder);177  }178  if (179    (factors.length === 0 && !includeOne) ||180    (factors.length === 1 && includeOne)181  ) {182    factors.push(n);183  }184  return factors;185}186const refactorIntegerInvalidArgumentPreText = 'Invalid argument: factors must be an array of positive integers,';187function verifyIntegerFactors(n, factors) {188  if (!Array.isArray(factors)) {189    throw Error(`${refactorIntegerInvalidArgumentPreText} value of type: ${typeof factors} was provided.`);190  }191  let product = 1;192  for(let i = 0; i < factors.length; ++i) {193    const factor = factors[i];194    if (!isPositiveInteger(factor)) {195      throw Error(`${refactorIntegerInvalidArgumentPreText} value of ${factor} at index ${i} with type ${typeof factor} was provided.`);196    }197    product *= factor;198  }199  if (product !== n) {200    throw Error(`${refactorIntegerInvalidArgumentPreText} factors provided [${factors.join(',')}] do not multiply to produce ${n}.`);201  }202  return factors;203}204function generateUniqueIntegerDigitPermutations(n) {205  if (!isPositiveInteger(n)) {206    throw Error(`Invalid argument: n must be a positive integer, ${n} was provided.`);207  }208  const digits = String(n).split('').map(toNumber);209  if (!cachedPermutations[digits.length]) {210    cachedPermutations[digits.length] = generatePermutations(digits.length);211  }212  const uniqueDigitPermutations = {};213  const digitPermutations = cachedPermutations[digits.length].map((p) => applyPermutationToAlphabet(p, digits, true, true));214  for (let i = 0; i < digitPermutations.length; ++i) {215    const integer = +digitPermutations[i].join('');216    if (uniqueDigitPermutations[integer]) {217      continue;218    }219    uniqueDigitPermutations[integer] = true;220  }221  return Object.keys(uniqueDigitPermutations).map(toNumber);222}223function updateAbacusBeadPosition(abacus, beadPosition) {224  for (let i = 0; i < beadPosition.length; ++i) {225    if (beadPosition[i] + 1 < abacus[i].length) {226      ++beadPosition[i];227      return;228    } else if (beadPosition[i] + 1 === abacus[i].length) {229      beadPosition[i] = 0;230    }231  }232}233function refactorInteger(n, factors = undefined, skipVerification = false) {234  if (!isPositiveInteger(n)) {235    throw Error(`Invalid argument: n must be a positive integer, ${n} was provided.`);236  }237  if (!skipVerification) {238    verifyIntegerFactors(n, factors);239  }240  const integerFactors = !Array.isArray(factors) ? factorInteger(n) : factors;241  if (n < 10 || integerFactors.length === 1) {242    return [n];243  }244  const refactors = {};245  const factorPermutations = {};246  for (let i = 0; i < integerFactors.length; ++i) {247    if (factorPermutations[integerFactors[i]]) {248      continue;249    }250    251    factorPermutations[integerFactors[i]] = integerFactors[i] < 10252      ? [integerFactors[i]]253      : generateUniqueIntegerDigitPermutations(integerFactors[i]);254  }255  const abacus = Object.values(factorPermutations);256  const beadPosition = abacus.map(() => 0);257  let refactor = 1;258  do {259    refactor = 1;260    for (let i = 0; i < beadPosition.length; ++i) {261      refactor *= abacus[i][beadPosition[i]];262    }263    updateAbacusBeadPosition(abacus, beadPosition);264    refactors[refactor] = true;265  } while (beadPosition.reduce(reduceToSum, 0) > 0);266  return Object.keys(refactors).map(toNumber);267}268function aggregateInteger(n) {269  if (!isNonNegativeInteger(n)) {270    throw Error(`Invalid argument: n must be a non-negative integer, ${n} was provided.`);271  }272  let aggregate = n;273  while (aggregate >= 10) {274    aggregate = String(aggregate).split('').map(toNumber).reduce(reduceToSum, 0);275  }276  return aggregate;277}278function verifyRefactorAggregates(refactorAggregates, aggregate, refactors, n) {279  refactorAggregates.forEach((r, i) => {280    if (r !== aggregate) {281      throw Error(`Refactored integer aggregate of ${r} for refactor ${refactors[i]} does not equal provided integer aggregate of ${aggregate} for ${n}`);282    }283  });284}285function aggregateIntegerRefactors(n, skipVerification = false) {286  if (!isPositiveInteger(n)) {287    throw Error(`Invalid argument: n must be a positive integer, ${n} was provided.`);288  }289  const aggregate = aggregateInteger(n);290  const refactors = refactorInteger(n, factorInteger(n), true);291  const refactorAggregates = refactors.map((r) => aggregateInteger(r));292  if (!skipVerification) {293    verifyRefactorAggregates(refactorAggregates, aggregate, refactors, n);294  }295  296  return {297    integer: n,298    refactors,299    aggregate,300    refactorAggregates301  };302}303function aggregateRandomIntegerRefactors(n, m, skipVerification = false) {304  return aggregateIntegerRefactors(generateRandomIntegerBetween(n, m), skipVerification);...

project-upgrades.ts

Source:project-upgrades.ts

1/*2 *  This file is part of CoCalc: Copyright Â© 2020 Sagemath, Inc.3 *  License: AGPLv3 s.t. "Commons Clause" â see LICENSE.md for details4 */5/*6Functions for determining various things about applying upgrades to a project.7WARNING: This should stay as simple typescript with no crazy dependencies for easy node.js unit testing.8*/9import * as misc from "smc-util/misc";10import { ProjectMap } from "../projects/store";11interface ExistenceMap {12  [keys: string]: boolean;13}14export function available_upgrades(opts: {15  account_id: string; // id of a user16  purchased_upgrades: object; // map of the total upgrades purchased by account_id17  project_map: ProjectMap; // immutable.js map of data about projects18  student_project_ids: ExistenceMap; // map project_id:true with keys *all* student19  // projects in course, including deleted20}) {21  /*22    Return the total upgrades that the user with given account_id has to apply23    toward this course.   This is all upgrades they have purchased minus24    upgrades they have applied to projects that aren't student projects in25    this course.  Thus this is what they have available to distribute to26    their students in this course.27    This is a map {quota0:x, quota1:y, ...}28    */29  let available = misc.copy(opts.purchased_upgrades);30  opts.project_map.forEach(function (project, project_id) {31    if (opts.student_project_ids[project_id]) {32      // do not count projects in course33      return;34    }35    const upgrades = project.getIn(["users", opts.account_id, "upgrades"]);36    if (upgrades != null) {37      available = misc.map_diff(available, upgrades.toJS());38    }39  });40  return available;41}42export function current_student_project_upgrades(opts: {43  account_id: string; // id of a user44  project_map: ProjectMap; // immutable.js map of data about projects45  student_project_ids: ExistenceMap; // map project_id:true with keys *all* student46}) {47  /*48    Return the total upgrades currently applied to each student project from49    everybody else except the user with given account_id.50    This output is a map {project_id:{quota0:x, quota1:y, ...}, ...}; only projects with51    actual upgrades are included.52    */53  const other = {};54  for (const project_id in opts.student_project_ids) {55    const users = opts.project_map.getIn([project_id, "users"]);56    if (users == null) {57      continue;58    }59    var x = undefined;60    users.forEach(function (info, user_id) {61      if (user_id === opts.account_id) {62        return;63      }64      const upgrades = info.get("upgrades");65      if (upgrades == null) {66        return;67      }68      x = misc.map_sum(upgrades.toJS(), x != null ? x : {});69    });70    if (x != null) {71      other[project_id] = x;72    }73  }74  return other;75}76export function upgrade_plan(opts: {77  account_id: string; // id of a user78  purchased_upgrades: object; // map of the total upgrades purchased by account_id79  project_map: ProjectMap; // immutable.js map of data about projects80  student_project_ids: ExistenceMap; // map project_id:true with keys *all* student81  //                                    projects in course, including deleted82  deleted_project_ids: ExistenceMap; // map project_id:true just for projects where83  //                                    student is considered deleted from class84  upgrade_goal: object; // [quota0:x, quota1:y]85}) {86  /*87    Determine what upgrades should be applied by this user to get88    the student projects to the given upgrade goal.  Preference89    is by project_id in order (arbitrary, but stable).90    The output is a map {student_project_id:{quota0:x, quota1:y, ...}, ...}, where the quota0:x means91    that account_id will apply x amount of quota0 total.  Thus to actually *do* the upgrading,92    this user (account_id) would go through the project map and set their upgrade contribution93    for the student projects in this course to exactly what is specified by this function.94    Note that no upgrade quota will be deducted from projects outside this course to satisfy95    the upgrade_goal.96    If a student_project_id is missing from the output the contribution is 0; if a quota is97    missing, the contribution is 0.98    The keys of the output map are **exactly** the ids of the projects where the current99    allocation should be *changed*.   That said, we only consider quotas explicitly given100    in the upgrade_goal map.101    */102  // upgrades, etc., that student projects already have (which account_id did not provide)103  const cur = exports.current_student_project_upgrades({104    account_id: opts.account_id,105    project_map: opts.project_map,106    student_project_ids: opts.student_project_ids,107  });108  // upgrades we have that have not been allocated to our course109  const available = exports.available_upgrades({110    account_id: opts.account_id,111    purchased_upgrades: opts.purchased_upgrades,112    project_map: opts.project_map,113    student_project_ids: opts.student_project_ids,114  });115  const ids = misc.keys(opts.student_project_ids);116  ids.sort();117  const plan = {};118  for (const project_id of ids) {119    if (opts.deleted_project_ids[project_id]) {120      // give this project NOTHING121      continue;122    }123    plan[project_id] = {};124    // we only care about quotas in the upgrade_goal125    for (var quota in opts.upgrade_goal) {126      const val = opts.upgrade_goal[quota];127      const need =128        val -129        ((cur[project_id] != null ? cur[project_id][quota] : undefined) != null130          ? cur[project_id] != null131            ? cur[project_id][quota]132            : undefined133          : 0);134      if (need > 0) {135        const have = Math.min(need, available[quota]);136        plan[project_id][quota] = have;137        available[quota] -= have;138      }139    }140    // is there an actual allocation change?  if not, we do not include this key.141    const upgrades = opts.project_map.getIn([142      project_id,143      "users",144      opts.account_id,145      "upgrades",146    ]);147    const alloc = upgrades != null ? upgrades.toJS() : {};148    let change = false;149    for (quota in opts.upgrade_goal) {150      if (151        (alloc[quota] != null ? alloc[quota] : 0) !==152        (plan[project_id][quota] != null ? plan[project_id][quota] : 0)153      ) {154        change = true;155        break;156      }157    }158    if (!change) {159      delete plan[project_id];160    }161  }162  return plan;...

twoSum.js

Source:twoSum.js

1//   Write a function that takes in a non-empty array of distinct integers and an2//   integer representing a target sum. If any two numbers in the input array sum3//   up to the target sum, the function should return them in an array, in any4//   order. If no two numbers sum up to the target sum, the function should return5//   an empty array.6//   Note that the target sum has to be obtained by summing two different integers7//   in the array; you can't add a single integer to itself in order to obtain the8//   target sum.9//   You can assume that there will be at most one pair of numbers summing up to10//   the target sum.11//   array =  = [3, 5, -4, 8, 11, 1, -1, 6]12//   targetSum = 1013//   output = [-1, 11]14//sol15//brute force method 16function twoNumberSum(array, targetSum) {17  if(!array.length) {18    return19  }20  // Write your code here.21  for(let i=0; i<array.length; i++) {22    for(let j =1; j<array.length && i !== j; j++) {23      if(array[i] + array[j] === targetSum) {24        return [array[i], array[j]]25      }26    }27  }28  return []29}30//using sort and pointers 31function twoNumberSum(array, targetSum) {32  // Write your code here.33  //sort the array 34  array.sort((a,b) => (a-b))35  //initialize left and right pointers 36  let l =0;37  let r = array.length - 1;38  // compare elements at left and right indices 39  while(l < r) {40    const currentSum = array[l] + array[r]41    if(currentSum < targetSum) {42    l++43    }else if(currentSum > targetSum) {44      r--45    }else if(currentSum === targetSum) {46      return [array[l], array[r]]47    }48  }49  return []50}51// Hint : x + y = target52// y = target - x53// using exitence map 54function twoNumberSum(array, targetSum) {55  // Write your code here.56  if(!array.length) {57    return58  }59  const existenceMap = {}60  for(let i=0; i<array.length; i++) {61    const val = targetSum - array[i]62    console.log('val ',val)63    if(existenceMap.hasOwnProperty(array[i])) {64      return [array[i], val]65    }else {66      existenceMap[val] = true67    }68  }69  return []70}71function twoNumberSum(array, targetSum) {72  // Write your code here.73  if (!array.length) {74    return;75  }76  let map = arrayMap(array);77  for (let i = 0; i < array.length; i++) {78    const val = targetSum - array[i];79    if (map[val] && i !== map[val]) {80      console.log([array[i], array[map[val]]]);81      return [array[i], array[map[val]]];82    }83  }84  return [];85}86function arrayMap(arr) {87  let map = {};88  for (let i = 0; i < arr.length; i++) {89    map[arr[i]] = i;90  }91  return map;92}...

Using AI Code Generation

1var stf = require('devicefarmer-stf-client');2var client = new stf.Client();3client.connect(function(err) {4  if (err) {5    throw err;6  }7  client.existenceMap(function(err, map) {8    if (err) {9      throw err;10    }11    console.log(map);12    client.disconnect();13  });14});15{ '2b2d8b91': true, '2b2d8b92': false }16var stf = require('devicefarmer-stf-client');17var client = new stf.Client();18client.connect(function(err) {19  if (err) {20    throw err;21  }22  client.existenceMap(function(err, map) {23    if (err) {24      throw err;25    }26    var serials = Object.keys(map);27    var connectedSerials = serials.filter(function(serial) {28      return map[serial];29    });30    console.log(connectedSerials);31    client.disconnect();32  });33});34var stf = require('devicefarmer-stf-client');35var client = new stf.Client();36client.connect(function(err) {37  if (err) {38    throw err;39  }40  client.existenceMap(function(err, map) {41    if (err) {42      throw err;43    }44    var serials = Object.keys(map);45    var disconnectedSerials = serials.filter(function(serial) {46      return !map[serial];47    });48    console.log(disconnectedSerials);49    client.disconnect();50  });51});

Using AI Code Generation

1var deviceUtil = require('devicefarmer-stf-device-util');2var device = {3  "display": {4  },5  "phone": {6  },7  "provider": {

Using AI Code Generation

1var client = require('devicefarmer-stf-client');2var existenceMap = client.existenceMap();3existenceMap.on('add', function (serial) {4console.log('device added', serial);5});6existenceMap.on('remove', function (serial) {7console.log('device removed', serial);8});9existenceMap.on('change', function (serial, present) {10console.log('device ' + (present ? 'added' : 'removed'), serial);11});12var client = require('devicefarmer-stf-client-nodejs-wrapper');13client.existenceMap().then(function (existenceMap) {14existenceMap.on('add', function (serial) {15console.log('device added', serial);16});17existenceMap.on('remove', function (serial) {18console.log('device removed', serial);19});20existenceMap.on('change', function (serial, present) {21console.log('device ' + (present ? 'added' : 'removed'), serial);22});23});24import com.devicefarmer.stf.client.Client;25import com.devicefarmer.stf.client.ExistenceMap;26import com.devicefarmer.stf.client.ExistenceMapListener;27public class Test {

Using AI Code Generation

1var stf = require('devicefarmer-stf');2stf.getDeviceList(function(err, devices) {3    if (err) {4        console.log(err);5    } else {6        var existenceMap = stf.existenceMap(devices);7        console.log(existenceMap);8    }9});10{ '1d7b6e0e': true,11  'f3b6e2b6': true }12* `getDeviceList(callback)`: returns the list of devices currently connected to the STF server13* `getDevice(serial, callback)`: returns the device with the given serial number14* `getDevicesByOwner(owner, callback)`: returns the list of devices currently owned by the given owner15* `getDevicesByGroup(group, callback)`: returns the list of devices currently owned by the given group16* `getDevicesByGroupAndOwner(group, owner, callback)`: returns the list of devices currently owned by the given group and owner17* `getDevicesByGroupOrOwner(group, owner, callback)`: returns the list of devices currently owned by the given group or owner18* `getDevicesByGroupAndNotOwner(group, owner, callback)`: returns the list of devices currently owned by the given group and not by the given owner19* `getDevicesByGroupOrNotOwner(group, owner, callback)`: returns the list of devices currently owned by the given group or not by the given owner20* `getDevicesByNotGroupAndOwner(group, owner, callback)`: returns the list of devices currently not owned by the given group and owned by the given owner

Using AI Code Generation

1var stf = require('devicefarmer-stf-client');2test.existenceMap('device1').then(function(result) {3    console.log(result);4});5var stf = require('devicefarmer-stf-client');6test.getDevice('device1').then(function(result) {7    console.log(result);8});9var stf = require('devicefarmer-stf-client');10test.getDevices().then(function(result) {11    console.log(result);12});13var stf = require('devicefarmer-stf-client');14test.getDevices().then(function(result) {15    console.log(result);16});17var stf = require('devicefarmer-stf-client');18test.getDevices().then(function(result) {19    console.log(result);20});21var stf = require('devicefarmer-stf-client');22test.getDevices().then(function(result) {23    console.log(result);24});25var stf = require('devicefarmer-stf-client');26test.getDevices().then(function(result) {27    console.log(result);28});29var stf = require('devicefarmer-stf-client');30test.getDevices().then(function(result) {31    console.log(result);

Using AI Code Generation

1var stf = require('devicefarmer-stf');2var device = new stf.Device();3var deviceSerial = 'ABC123456789';4device.existenceMap(deviceSerial).then(function (existenceMap) {5    console.log(existenceMap);6});7{8}9var stf = require('devicefarmer-stf');10var device = new stf.Device();11device.getDevices().then(function (devices) {12    console.log(devices);13});14  {15    "battery": {16    },17    "display": {18    },19    "phone": {20      "android": {

Using AI Code Generation

1var DeviceFarmer = require('devicefarmer-stf-client');2var df = new DeviceFarmer({3});4df.connect('test', 'test').then(function() {5  df.getDevices().then(function(devices) {6    devices.forEach(function(device) {7      console.log(device.serial + ": " + device.existenceMap);8    });9  });10});

Using AI Code Generation

1var client = require('devicefarmer-stf-client');2var serial = 'a4a4a4a4';3stfClient.existenceMap(serial, function(err, result) {4    if (err) {5        console.log('Error: ' + err);6    } else {7        console.log(result);8    }9});10{ serial: 'a4a4a4a4', exists: true }11{ serial: 'a4a4a4a4', exists: false }12var client = require('devicefarmer-stf-client');13var serial = 'a4a4a4a4';14stfClient.availabilityMap(serial, function(err, result) {15    if (err) {16        console.log('Error: ' + err);17    } else {18        console.log(result);19    }20});21{ serial: 'a4a4a4a4', available: true }22{ serial: 'a4a4a4a4', available: false }23var client = require('devicefarmer-stf-client');24var serial = 'a4a4a4a4';25stfClient.usageMap(serial, function(err, result) {26    if (err) {27        console.log('

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.