How to use assert_subset method in wpt

Best JavaScript code snippet using wpt

requestmediakeysystemaccess.js

Source:requestmediakeysystemaccess.js

...13                assert_equals(e.name, expectedError);14            });15        }, prefix + modifiedtestname + ' should result in ' + expectedError );16    }17    function assert_subset(actual, expected, path) {18        if (typeof expected == 'string') {19            assert_equals(actual, expected, path);20        } else {21            if (expected.hasOwnProperty('length')) {22                assert_equals(actual.length, expected.length, path + '.length');23            }24            for (property in expected) {25                assert_subset(actual[property], expected[property], path + '.' + property);26            }27        }28    }29    function expect_config(keySystem, configurations, expectedConfiguration, testname) {30        promise_test(function(test) {31            return navigator.requestMediaKeySystemAccess(keySystem, configurations).then(function(a) {32                assert_subset(a.getConfiguration(), expectedConfiguration, testname + ': ');33            });34        }, testname);35    }36    // Tests for Key System.37    expect_error('', [{}], 'TypeError', 'Empty Key System');38    expect_error('com.example.unsupported', [{}], 'NotSupportedError', 'Unsupported Key System');39    expect_error(config.keysystem + '.', [{}], 'NotSupportedError', 'Key System ending in "."');40    expect_error(config.keysystem.toUpperCase(), [{}], 'NotSupportedError', 'Capitalized Key System');41    expect_error(config.keysystem + '\u028F', [{}], 'NotSupportedError', 'Non-ASCII Key System');42    // Parent of Clear Key not supported.43    expect_error(config.keysystem.match(/^(.*?)\./)[1], [{}], 'NotSupportedError', 'Root domain of Key System alone');44    expect_error(config.keysystem.match(/^(.*?)\./)[0], [{}], 'NotSupportedError', 'Root domain of Key System, with dot');45    expect_error(config.keysystem.match(/^(.*?\..*?)\./)[1], [{}], 'NotSupportedError', 'Domain of Key System along');46    expect_error(config.keysystem.match(/^(.*?\..*?)\./)[0], [{}], 'NotSupportedError', 'Domain of Key System, with dot');...

plans.py

Source:plans.py

...4def assert_in(element, set_):5    assert element in set_, (element, set_)6def assert_not_in(element, set_):7    assert element not in set_, (element, set_)8def assert_subset(subset, set_):9    assert subset <= set_, (subset, set_)10OBJECT_COUNT = 1e4                          # optimize for this many obs11LOGIC_COST = OBJECT_COUNT / 64.0            # perform logic on 64-bit words12LOG_OBJECT_COUNT = math.log(OBJECT_COUNT)13UNKNOWN = Expression_1('UNKNOWN')14def add_costs(costs):15    return (log_sum_exp(*(LOG_OBJECT_COUNT * c for c in costs)) /16            LOG_OBJECT_COUNT)17class Plan(object):18    __slots__ = ['_args', '_cost', '_rank']19    def __init__(self, *args):20        self._args = args21        self._cost = None22        self._rank = None23    @property24    def cost(self):25        if self._cost is None:26            self._cost = math.log(self.op_count()) / LOG_OBJECT_COUNT27        return self._cost28    @property29    def rank(self):30        if self._rank is None:31            s = repr(self)32            self._rank = self.cost, len(s), s33        return self._rank34    def __lt__(self, other):35        return self.rank < other.rank36    def permute_symbols(self, perm):37        return self.__class__.make(*(38            a.permute_symbols(perm)39            for a in self._args40        ))41@memoize_make42class Iter(Plan):43    __slots__ = ['_repr', 'var', 'body', 'tests', 'lets', 'stack']44    def __init__(self, var, body):45        Plan.__init__(self, var, body)46        assert var.is_var(), var47        assert isinstance(body, Plan), body48        self._repr = None49        self.var = var50        self.body = body51        self.tests = []52        self.lets = {}53        self.stack = set()54        self.optimize()55    def add_test(self, test):56        assert isinstance(test, Test), 'add_test arg is not a Test'57        self.tests.append(test.expr)58        self.stack.add(test)59    def add_let(self, let):60        assert isinstance(let, Let), 'add_let arg is not a Let'61        assert let.var not in self.lets, 'add_let var is not in Iter.lets'62        self.lets[let.var] = let.expr63        self.stack.add(let)64    def __repr__(self):65        if self._repr is None:66            # Optimized:67            # tests = ['if {}'.format(t) for t in self.tests]68            # lets = ['let {}'.format(l) for l in sorted(self.lets.iterkeys())]69            # self._repr = 'for {0}: {1}'.format(70            #     ' '.join([str(self.var)] + tests + lets),71            #     self.body)72            self._repr = 'for {}: {}'.format(self.var, self.body)73        return self._repr74    def validate(self, bound):75        assert_not_in(self.var, bound)76        bound = set_with(bound, self.var)77        for test in self.tests:78            assert_subset(test.vars, bound)79        for var, expr in self.lets.iteritems():80            assert_subset(expr.vars, bound)81            assert_not_in(var, bound)82        self.body.validate(bound)83    def op_count(self, stack=None):84        logic_cost = LOGIC_COST * (len(self.tests) + len(self.lets))85        object_count = OBJECT_COUNT86        for test_or_let in self.stack:87            object_count *= test_or_let.prob()88        let_cost = len(self.lets)89        body_cost = self.body.op_count(stack=self.stack)90        return logic_cost + object_count * (let_cost + body_cost)91    def optimize(self):92        node = self.body93        new_lets = set()94        while isinstance(node, Test) or isinstance(node, Let):95            if isinstance(node, Let):96                new_lets.add(node.var)97            expr = node.expr98            while expr.name == 'UNKNOWN':99                expr = expr.args[0]100            optimizable = (101                self.var in expr.vars and102                expr.vars.isdisjoint(new_lets) and103                sum(1 for arg in expr.args if self.var == arg) == 1 and104                sum(1 for arg in expr.args if self.var in arg.vars) == 1 and105                (isinstance(node, Let) or expr.is_rel())106            )107            if optimizable:108                if isinstance(node, Test):109                    self.add_test(node)110                else:111                    self.add_let(node)112            node = node.body113# TODO injective function inverse need not be iterated114@memoize_make115class IterInvInjective(Plan):116    __slots__ = ['fun', 'value', 'var', 'body']117    def __init__(self, fun, body):118        Plan.__init__(self, fun, body)119        assert fun.arity == 'InjectiveFunction'120        self.fun = fun.name121        self.value = fun.var122        (self.var,) = fun.args123        self.body = body124    def __repr__(self):125        return 'for {0} {1}: {2}'.format(self.fun, self.var, self.body)126    def validate(self, bound):127        assert_in(self.value, bound)128        assert_not_in(self.var, bound)129        self.body.validate(set_with(bound, self.var))130    def op_count(self, stack=None):131        return 4.0 + 0.5 * self.body.op_count()  # amortized132@memoize_make133class IterInvBinary(Plan):134    __slots__ = ['fun', 'value', 'var1', 'var2', 'body']135    def __init__(self, fun, body):136        Plan.__init__(self, fun, body)137        assert fun.arity in ['BinaryFunction', 'SymmetricFunction']138        self.fun = fun.name139        self.value = fun.var140        self.var1, self.var2 = fun.args141        self.body = body142    def __repr__(self):143        return 'for {0} {1} {2}: {3}'.format(144            self.fun, self.var1, self.var2, self.body)145    def validate(self, bound):146        assert_in(self.value, bound)147        assert_not_in(self.var1, bound)148        assert_not_in(self.var2, bound)149        self.body.validate(set_with(bound, self.var1, self.var2))150    def op_count(self, stack=None):151        return 4.0 + 0.25 * OBJECT_COUNT * self.body.op_count()  # amortized152@memoize_make153class IterInvBinaryRange(Plan):154    __slots__ = ['fun', 'value', 'var1', 'var2', 'lhs_fixed', 'body']155    def __init__(self, fun, fixed, body):156        Plan.__init__(self, fun, fixed, body)157        assert fun.arity in ['BinaryFunction', 'SymmetricFunction']158        self.fun = fun.name159        self.value = fun.var160        self.var1, self.var2 = fun.args161        assert self.var1 != self.var2162        assert self.var1 == fixed or self.var2 == fixed163        self.lhs_fixed = (fixed == self.var1)164        self.body = body165    def __repr__(self):166        if self.lhs_fixed:167            return 'for {0} ({1}) {2}: {3}'.format(168                self.fun, self.var1, self.var2, self.body)169        else:170            return 'for {0} {1} ({2}): {3}'.format(171                self.fun, self.var1, self.var2, self.body)172    def validate(self, bound):173        assert self.value in bound174        if self.lhs_fixed:175            assert_in(self.var1, bound)176            assert_not_in(self.var2, bound)177            self.body.validate(set_with(bound, self.var2))178        else:179            assert_in(self.var2, bound)180            assert_not_in(self.var1, bound)181            self.body.validate(set_with(bound, self.var1))182    def op_count(self, stack=None):183        return 4.0 + 0.5 * self.body.op_count()  # amortized184@memoize_make185class Let(Plan):186    __slots__ = ['var', 'expr', 'body']187    def __init__(self, expr, body):188        Plan.__init__(self, expr, body)189        assert isinstance(body, Plan)190        assert expr.is_fun()191        self.var = expr.var192        self.expr = expr193        self.body = body194    def __repr__(self):195        return 'let {0}: {1}'.format(self.var, self.body)196    def validate(self, bound):197        assert_subset(self.expr.vars, bound)198        assert_not_in(self.var, bound)199        self.body.validate(set_with(bound, self.var))200    __probs = {'NullaryFunction': 0.9}201    def prob(self):202        return self.__probs.get(self.expr.arity, 0.1)203    def op_count(self, stack=None):204        if stack and self in stack:205            return self.body.op_count(stack=stack)206        else:207            return 1.0 + self.prob() * self.body.op_count(stack=stack)208@memoize_make209class Test(Plan):210    __slots__ = ['expr', 'body']211    def __init__(self, expr, body):212        Plan.__init__(self, expr, body)213        assert not expr.is_var()214        assert isinstance(body, Plan)215        self.expr = expr216        self.body = body217    def __repr__(self):218        return 'if {0}: {1}'.format(self.expr, self.body)219    def validate(self, bound):220        assert_subset(self.expr.vars, bound)221        self.body.validate(bound)222    __probs = {'NLESS': 0.9}223    def prob(self):224        return self.__probs.get(self.expr.name, 0.1)225    def op_count(self, stack=None):226        if stack and self in stack:227            return self.body.op_count(stack=stack)228        else:229            return 1.0 + self.prob() * self.body.op_count(stack=stack)230@memoize_make231class Ensure(Plan):232    __slots__ = ['expr']233    def __init__(self, expr):234        Plan.__init__(self, expr)235        assert expr.args, ('expr is not compound', expr)236        self.expr = expr237    def __repr__(self):238        return 'ensure {0}'.format(self.expr)239    def validate(self, bound):240        assert_subset(self.expr.vars, bound)241    def op_count(self, stack=None):242        fun_count = 0243        if self.expr.name == 'EQUATION':244            for arg in self.expr.args:245                if arg.is_fun():246                    fun_count += 1...

test_national_statistic_filter.py

Source:test_national_statistic_filter.py

...85        ns_filter = NSFilter(self.testclient, dry_run=False, force=False)86        ns_filter.filter()87        def assert_pkg_stayed_the_same(package_name, pkg_dict):88            pkg = model.Package.by_name(unicode(package_name))89            PackageDictUtil.assert_subset(pkg.as_dict(), pkg_dict)90            91        def assert_pkg_filtered(package_name, pkg_dict):92            pkg = model.Package.by_name(unicode(package_name))93            expected_pkg = copy.deepcopy(pkg_dict)94            expected_pkg['extras']['national_statistic'] = 'no'95            PackageDictUtil.assert_subset(pkg.as_dict(), expected_pkg)96        97        assert_pkg_stayed_the_same('ons_pkg', self.pkgs[0])98        assert_pkg_filtered('ons_but_not_ns', self.pkgs[1])99        assert_pkg_stayed_the_same('not_ns_or_ons', self.pkgs[2])100        assert_pkg_stayed_the_same('not_ns', self.pkgs[3])...

feature_generators.py

Source:feature_generators.py

...26        super(HighTip, self).__init__(27            'high_tip', ['tip_amount', 'fare_amount'])28    def compute(self, df: pd.DataFrame, tip_fraction: float = 0.2) -> pd.DataFrame:29        """Computes whether the tip was at least tip_fraction of the fare."""30        assert_subset(self.required_columns, df.columns)31        tip_fraction_col = df.tip_amount / df.fare_amount32        feature_df = pd.DataFrame(33            {'high_tip_indicator': tip_fraction_col > tip_fraction})34        return feature_df[self.schema().keys()]35    def schema(self) -> dict:36        return {'high_tip_indicator': bool}37class Pickup(FeatureGenerator):38    def __init__(self):39        super(Pickup, self).__init__('pickup', ['tpep_pickup_datetime'])40    def compute(self, df: pd.DataFrame) -> pd.DataFrame:41        """Computes features related to the pickup time, such as weekday, hour, minute, and whether the pickup was during working hours."""42        assert_subset(self.required_columns, df.columns)43        pickup_weekday = df.tpep_pickup_datetime.dt.weekday44        pickup_hour = df.tpep_pickup_datetime.dt.hour45        pickup_minute = df.tpep_pickup_datetime.dt.minute46        work_hours = (pickup_weekday >= 0) & (pickup_weekday <= 4) & (47            pickup_hour >= 8) & (pickup_hour <= 18)48        feature_df = pd.DataFrame({'pickup_weekday': pickup_weekday,49                                   'pickup_hour': pickup_hour, 'pickup_minute': pickup_minute, 'work_hours': work_hours})50        return feature_df[self.schema().keys()]51    def schema(self) -> dict:52        return {'pickup_weekday': int, 'pickup_hour': int, 'pickup_minute': int, 'work_hours': bool}53class Trip(FeatureGenerator):54    def __init__(self):55        super(Trip, self).__init__('trip', ['tpep_dropoff_datetime',56                                            'tpep_pickup_datetime', 'trip_distance', 'passenger_count'])57    def compute(self, df: pd.DataFrame) -> pd.DataFrame:58        """Computes trip-related features, such as passenger count, trip distance, time taken for the trip, and average speed."""59        assert_subset(self.required_columns, df.columns)60        trip_time = (df.tpep_dropoff_datetime -61                     df.tpep_pickup_datetime).dt.seconds62        trip_speed = df.trip_distance / (trip_time + 1e7)63        feature_df = pd.DataFrame({'trip_time': trip_time, 'trip_speed': trip_speed,64                                   'trip_distance': df.trip_distance, 'passenger_count': df.passenger_count})65        return feature_df[self.schema().keys()]66    def schema(self) -> dict:67        return {'passenger_count': int, 'trip_distance': float, 'trip_time': int, 'trip_speed': float}68class Categorical(FeatureGenerator):69    def __init__(self):70        super(Categorical, self).__init__('categorical', ['PULocationID',71                                                          'DOLocationID', 'RatecodeID'])72    def compute(self, df: pd.DataFrame) -> pd.DataFrame:73        """Identity function for categorical features."""74        assert_subset(self.required_columns, df.columns)75        return df[self.schema().keys()]76    def schema(self) -> dict:...

Using AI Code Generation

1var assert = require('assert');2var assert_subset = require('wpt-tools').assert_subset;3var obj1 = {a: 1, b: 2, c: 3};4var obj2 = {a: 1, b: 2};5assert_subset(obj1, obj2);6var assert = require('assert');7var assert_subset = require('wpt-tools').assert_subset;8var obj1 = {a: 1, b: 2, c: 3};9var obj2 = {a: 1, b: 2};10assert_subset(obj1, obj2);11var assert = require('assert');12var assert_subset = require('wpt-tools').assert_subset;13var obj1 = {a: 1, b: 2, c: 3};14var obj2 = {a: 1, b: 2};15assert_subset(obj1, obj2);16var assert = require('assert');17var assert_subset = require('wpt-tools').assert_subset;18var obj1 = {a: 1, b: 2, c: 3};19var obj2 = {a: 1, b: 2};20assert_subset(obj1, obj2);21var assert = require('assert');22var assert_subset = require('wpt-tools').assert_subset;23var obj1 = {a: 1, b: 2, c: 3};24var obj2 = {a: 1, b: 2};25assert_subset(obj1, obj2);26var assert = require('assert');27var assert_subset = require('wpt-tools').assert_subset;28var obj1 = {a: 1, b: 2, c: 3};29var obj2 = {a: 1, b: 2};30assert_subset(obj1, obj2);31var assert = require('assert');

Using AI Code Generation

1var wpt = require('webpagetest');2var assert = require('assert');3var assert_subset = require('assert-subset');4var wpt = new WebPageTest('www.webpagetest.org');5var location = 'Dulles:Chrome';6var options = {7};8wpt.runTest(url, options, function (err, data) {9    if (err) {10        console.log('There was an error running the test: ' + err);11        return;12    }13    console.log('Test submitted for ' + data.data.url + ' with id ' + data.data.testId);14    wpt.getTestResults(data.data.testId, function (err, data) {15        if (err) {16            console.log('There was an error getting the test results: ' + err);17            return;18        }19        console.log('Test results for ' + data.data.testId + ':');20        console.log('First View: ' + data.data.summary.firstView);21        assert_subset(data.data.summary.firstView, {22        });23    });24});25{26  "dependencies": {27  },28  "devDependencies": {},29  "scripts": {30  },31}

Using AI Code Generation

1var assert_subset = require('./assert_subset.js');2var obj1 = {3};4var obj2 = {5};6assert_subset(obj1, obj2, 'obj1 is a subset of obj2');7var assert = require('assert');8module.exports = function assert_subset(obj1, obj2, msg) {9  assert(Object.keys(obj1).every(function(key) {10    return obj2.hasOwnProperty(key) && obj2[key] === obj1[key];11  }), msg);12};13var assert_subset = require('./assert_subset.js');14var obj1 = {15};16var obj2 = {17};18assert_subset(obj1, obj2, 'obj1 is a subset of obj2');19var assert = require('assert');20module.exports = function assert_subset(obj1, obj2, msg) {21  assert(Object.keys(obj1).every(function(key) {22    return obj2.hasOwnProperty(key) && obj2[key] === obj1[key];23  }), msg);24};25var assert_subset = require('./assert_subset.js');26var obj1 = {27};28var obj2 = {29};30assert_subset(obj1, obj2, 'obj1 is a subset of obj2');31var assert = require('assert');32module.exports = function assert_subset(obj1, obj2, msg) {33  assert(Object.keys(obj1).every(function(key) {

Using AI Code Generation

1importScripts("/resources/testharness.js");2test(function() {3  assert_subset({a:1, b:2}, {a:1});4  assert_subset({a:1, b:2}, {a:1, b:2});5  assert_subset({a:1, b:2}, {a:1, b:2, c:3});6  assert_subset({a:1, b:2}, {a:1, b:2, c:undefined});7  assert_subset({a:1, b:2}, {a:1, b:2, c:null});8  assert_subset({a:1, b:2}, {a:1, b:2, c:0});9  assert_subset({a:1, b:2}, {a:1, b:2, c:""});10  assert_subset({a:1, b:2}, {a:1, b:2, c:[]});11  assert_subset({a:1, b:2}, {a:1, b:2, c:{}});12  assert_subset({a:1, b:2}, {a:1, b:2, c:function(){}});13  assert_subset({a:1, b:2}, {a:1, b:2, c:Symbol()});14  assert_subset({a:1, b:2}, {a:1, b:2, c:NaN});15  assert_subset({a:1, b:2}, {a:1, b:2, c:Infinity});16  assert_subset({a:1, b:2}, {a:1, b:2, c:-Infinity});17  assert_subset({a:1, b:2}, {a:1, b:2, c:1/0});18  assert_subset({a:1, b:2}, {a:1, b:2, c:-1/0});19  assert_subset({a:1, b:2}, {a:1, b:2, c:0/0});20  assert_subset({a:1, b:2}, {a:1, b:2, c:undefined});21  assert_subset({a:1, b:2}, {a:1, b:2, c:undefined, d:4});22  assert_subset({a:1,

Using AI Code Generation

1test(function(){2    assert_subset([1,2,3], [2,3]);3    assert_subset([1,2,3], [1,2,3]);4    assert_subset([1,2,3], [1,2,3,4]);5}, "test the assert_subset");6test(function(){7    assert_not_subset([1,2,3], [4,5]);8    assert_not_subset([1,2,3], [3,4,5]);9    assert_not_subset([1,2,3], [1,2]);10}, "test the assert_not_subset");11test(function(){12    assert_array_subset([1,2,3], [2,3]);13    assert_array_subset([1,2,3], [1,2,3]);14    assert_array_subset([1,2,3], [1,2,3,4]);15}, "test the assert_array_subset");16test(function(){17    assert_array_not_subset([1,2,3], [4,5]);18    assert_array_not_subset([1,2,3], [3,4,5]);19    assert_array_not_subset([1,2,3], [1,2]);20}, "test the assert_array_not_subset");21test(function(){22    assert_object_subset({a:1, b:2}, {a:1});23    assert_object_subset({a:1, b:2}, {b:2});24    assert_object_subset({a:1, b:2}, {a:1, b:2});25    assert_object_subset({a:1, b:2}, {a:1, b:2, c:3});26}, "test the assert_object_subset");27test(function(){28    assert_object_not_subset({a:1, b:2}, {c:3});29    assert_object_not_subset({a:1, b:2}, {a:2});30    assert_object_not_subset({a:1, b:2}, {b:1});31    assert_object_not_subset({a:1, b:2}, {a:2, b:1});32}, "test the assert_object_not_subset");

Using AI Code Generation

1assert_subset(actual, expected, message, options);2assert_not_subset(actual, expected, message, options);3assert_in_array(actual, expected, message, options);4assert_not_in_array(actual, expected, message, options);5assert_array_equals(actual, expected, message, options);6assert_array_not_equals(actual, expected, message, options);7assert_approx_equals(actual, expected, message, options);8assert_approx_not_equals(actual, expected, message, options);9assert_class_string(actual, expected, message, options);10assert_class_string_not(actual, expected, message, options);

Using AI Code Generation

1var assert_subset = require('assert_subset');2var set1 = new Set([1, 2, 3]);3var set2 = new Set([2, 3]);4var set3 = new Set([4, 5, 6]);5assert_subset(set2, set1, "set2 is a subset of set1");6assert_subset(set3, set1, "set3 is a subset of set1");7var array1 = [1, 2, 3];8var array2 = [2, 3];9var array3 = [4, 5, 6];10assert_subset(array2, array1, "array2 is a subset of array1");11assert_subset(array3, array1, "array3 is a subset of array1");12var assert_not_subset = require('assert_not_subset');13var set1 = new Set([1, 2, 3]);14var set2 = new Set([2, 3]);15var set3 = new Set([4, 5, 6]);16assert_not_subset(set1, set2, "set1 is not a subset of set2");17assert_not_subset(set1, set3, "set1 is not a subset of set3");18var array1 = [1, 2, 3];19var array2 = [2, 3];20var array3 = [4, 5, 6];21assert_not_subset(array1, array2, "array1 is not a subset of array2");22assert_not_subset(array1, array3, "array1 is not a subset of array3");

Using AI Code Generation

1var actual = [1, 2, 3];2var expected = [1, 2, 3];3assert_subset(actual, expected, "array is an exact match");4var actual = [1, 2, 3];5var expected = [3, 1, 2];6assert_subset(actual, expected, "array is a subset", {ignoreOrder: true});7var actual = [1, 2, 3, 4];8var expected = [1, 2, 3];9assert_subset(actual, expected, "array is a subset", {ignoreExtra: true});10var actual = [1, 2, 3, 4];11var expected = [3, 1, 2];12assert_subset(actual, expected, "array is a subset", {ignoreOrder: true, ignoreExtra: true});13var actual = ["a", "b", "c"];14var expected = ["a", "c"];15assert_subset(actual, expected, "array is a subset", {ignoreOrder: true});16var actual = [{name: "foo", age: 20}, {name: "bar", age: 30}];17var expected = [{name: "foo"}];18assert_subset(actual, expected, "array is a subset", {ignoreOrder: true});19var actual = [{name: "foo", age: 20, address: {city: "Bangalore", state: "Karnataka"}}, {name: "bar", age: 30, address: {city: "Mysore", state: "Karnataka"}}];20var expected = [{name: "foo", address: {city: "Bangalore"}}];21assert_subset(actual, expected, "array is a subset", {ignoreOrder: true});22var actual = [{name: "foo", age: 20, address: {city: "Bangalore", state: "Karnataka", places

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.