KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use MatchOperation method of com.intuit.karate.MatchOperation class

Best Karate code snippet using com.intuit.karate.MatchOperation.MatchOperation

Source:MatchOperation.java

...38/**39 *40 * @author pthomas341 */42public class MatchOperation {43    public static final String REGEX = "regex";44    final Match.Context context;45    final Match.Type type;46    final Match.Value actual;47    final Match.Value expected;48    final List<MatchOperation> failures;49    boolean pass = true;50    private String failReason;51    MatchOperation(Match.Type type, Match.Value actual, Match.Value expected) {52        this(JsEngine.global(), null, type, actual, expected);53    }54    MatchOperation(JsEngine js, Match.Type type, Match.Value actual, Match.Value expected) {55        this(js, null, type, actual, expected);56    }57    MatchOperation(Match.Context context, Match.Type type, Match.Value actual, Match.Value expected) {58        this(null, context, type, actual, expected);59    }60    private MatchOperation(JsEngine js, Match.Context context, Match.Type type, Match.Value actual, Match.Value expected) {61        this.type = type;62        this.actual = actual;63        this.expected = expected;64        if (context == null) {65            if (js == null) {66                js = JsEngine.global();67            }68            this.failures = new ArrayList();69            if (actual.isXml()) {70                this.context = new Match.Context(js, this, true, 0, "/", "", -1);71            } else {72                this.context = new Match.Context(js, this, false, 0, "$", "", -1);73            }74        } else {75            this.context = context;76            this.failures = context.root.failures;77        }78    }79    private Match.Type fromMatchEach() {80        switch (type) {81            case EACH_CONTAINS:82                return Match.Type.CONTAINS;83            case EACH_NOT_CONTAINS:84                return Match.Type.NOT_CONTAINS;85            case EACH_CONTAINS_ONLY:86                return Match.Type.CONTAINS_ONLY;87            case EACH_CONTAINS_ANY:88                return Match.Type.CONTAINS_ANY;89            case EACH_EQUALS:90                return Match.Type.EQUALS;91            case EACH_NOT_EQUALS:92                return Match.Type.NOT_EQUALS;93            case EACH_CONTAINS_DEEP:94                return Match.Type.CONTAINS_DEEP;95            default:96                throw new RuntimeException("unexpected outer match type: " + type);97        }98    }99    private static Match.Type macroToMatchType(boolean each, String macro) {100        if (macro.startsWith("^^")) {101            return each ? Match.Type.EACH_CONTAINS_ONLY : Match.Type.CONTAINS_ONLY;102        } else if (macro.startsWith("^+")) {103            return each ? Match.Type.EACH_CONTAINS_DEEP : Match.Type.CONTAINS_DEEP;104        } else if (macro.startsWith("^*")) {105            return each ? Match.Type.EACH_CONTAINS_ANY : Match.Type.CONTAINS_ANY;106        } else if (macro.startsWith("^")) {107            return each ? Match.Type.EACH_CONTAINS : Match.Type.CONTAINS;108        } else if (macro.startsWith("!^")) {109            return each ? Match.Type.EACH_NOT_CONTAINS : Match.Type.NOT_CONTAINS;110        } else if (macro.startsWith("!=")) {111            return each ? Match.Type.EACH_NOT_EQUALS : Match.Type.NOT_EQUALS;112        } else {113            return each ? Match.Type.EACH_EQUALS : Match.Type.EQUALS;114        }115    }116    private static int matchTypeToStartPos(Match.Type mt) {117        switch (mt) {118            case CONTAINS_ONLY:119            case EACH_CONTAINS_ONLY:120            case CONTAINS_DEEP:121            case EACH_CONTAINS_DEEP:122            case CONTAINS_ANY:123            case EACH_CONTAINS_ANY:124            case NOT_CONTAINS:125            case EACH_NOT_CONTAINS:126            case NOT_EQUALS:127            case EACH_NOT_EQUALS:128                return 2;129            case CONTAINS:130            case EACH_CONTAINS:131                return 1;132            default:133                return 0;134        }135    }136    boolean execute() {137        switch (type) {138            case EACH_CONTAINS:139            case EACH_NOT_CONTAINS:140            case EACH_CONTAINS_ONLY:141            case EACH_CONTAINS_ANY:142            case EACH_EQUALS:143            case EACH_NOT_EQUALS:144            case EACH_CONTAINS_DEEP:145                if (actual.isList()) {146                    List list = actual.getValue();147                    Match.Type nestedMatchType = fromMatchEach();148                    int count = list.size();149                    for (int i = 0; i < count; i++) {150                        Object o = list.get(i);151                        context.JS.put("_$", o);152                        MatchOperation mo = new MatchOperation(context.descend(i), nestedMatchType, new Match.Value(o), expected);153                        mo.execute();154                        context.JS.bindings.removeMember("_$");155                        if (!mo.pass) {156                            return fail("match each failed at index " + i);157                        }158                    }159                    // if we reached here all / each LHS items completed successfully160                    return true;161                } else {162                    return fail("actual is not an array or list");163                }164            default:165            // do nothing166        }167        if (actual.isNotPresent()) {168            if (!expected.isString() || !expected.getAsString().startsWith("#")) {169                return fail("actual path does not exist");170            }171        }172        if (actual.type != expected.type) {173            switch (type) {174                case CONTAINS:175                case NOT_CONTAINS:176                case CONTAINS_ANY:177                case CONTAINS_ONLY:178                case CONTAINS_DEEP:179                case CONTAINS_ANY_DEEP:180                    if (!expected.isList()) {181                        MatchOperation mo = new MatchOperation(context, type, actual, new Match.Value(Collections.singletonList(expected.getValue())));182                        mo.execute();183                        return mo.pass ? pass() : fail(mo.failReason);184                    }185                    break;186                default:187                // do nothing188            }189            if (expected.isXml() && actual.isMap()) {190                // special case, auto-convert rhs                191                MatchOperation mo = new MatchOperation(context, type, actual, new Match.Value(XmlUtils.toObject(expected.getValue(), true)));192                mo.execute();193                return mo.pass ? pass() : fail(mo.failReason);194            }195            if (expected.isString()) {196                String expStr = expected.getValue();197                if (!expStr.startsWith("#")) { // edge case if rhs is macro198                    return type == Match.Type.NOT_EQUALS ? pass() : fail("data types don't match");199                }200            } else {201                return type == Match.Type.NOT_EQUALS ? pass() : fail("data types don't match");202            }203        }204        if (expected.isString()) {205            String expStr = expected.getValue();206            if (expStr.startsWith("#")) {207                switch (type) {208                    case NOT_EQUALS:209                        return macroEqualsExpected(expStr) ? fail("is equal") : pass();210                    case NOT_CONTAINS:211                        return macroEqualsExpected(expStr) ? fail("actual contains expected") : pass();212                    default:213                        return macroEqualsExpected(expStr) ? pass() : fail(null);214                }215            }216        }217        switch (type) {218            case EQUALS:219                return actualEqualsExpected() ? pass() : fail("not equal");220            case NOT_EQUALS:221                return actualEqualsExpected() ? fail("is equal") : pass();222            case CONTAINS:223            case CONTAINS_ANY:224            case CONTAINS_ONLY:225            case CONTAINS_DEEP:226            case CONTAINS_ANY_DEEP:227                return actualContainsExpected() ? pass() : fail("actual does not contain expected");228            case NOT_CONTAINS:229                return actualContainsExpected() ? fail("actual contains expected") : pass();230            default:231                throw new RuntimeException("unexpected match type: " + type);232        }233    }234    private boolean macroEqualsExpected(String expStr) {235        boolean optional = expStr.startsWith("##");236        if (optional && actual.isNull()) { // exit early237            return true;238        }239        int minLength = optional ? 3 : 2;240        if (expStr.length() > minLength) {241            String macro = expStr.substring(minLength - 1);242            if (macro.startsWith("(") && macro.endsWith(")")) {243                macro = macro.substring(1, macro.length() - 1);244                Match.Type nestedType = macroToMatchType(false, macro);245                int startPos = matchTypeToStartPos(nestedType);246                macro = macro.substring(startPos);247                if (actual.isList()) { // special case, look for partial maps within list248                    if (nestedType == Match.Type.CONTAINS) {249                        nestedType = Match.Type.CONTAINS_DEEP;250                    } else if (nestedType == Match.Type.CONTAINS_ANY) {251                        nestedType = Match.Type.CONTAINS_ANY_DEEP;252                    }253                }254                context.JS.put("$", context.root.actual.getValue());255                context.JS.put("_", actual.getValue());256                JsValue jv = context.JS.eval(macro);257                context.JS.bindings.removeMember("$");258                context.JS.bindings.removeMember("_");259                MatchOperation mo = new MatchOperation(context, nestedType, actual, new Match.Value(jv.getValue()));260                return mo.execute();261            } else if (macro.startsWith("[")) {262                int closeBracketPos = macro.indexOf(']');263                if (closeBracketPos != -1) { // array, match each264                    if (!actual.isList()) {265                        return fail("actual is not an array");266                    }267                    if (closeBracketPos > 1) {268                        String bracketContents = macro.substring(1, closeBracketPos);269                        List listAct = actual.getValue();270                        int listSize = listAct.size();271                        context.JS.put("$", context.root.actual.getValue());272                        context.JS.put("_", listSize);273                        String sizeExpr;274                        if (bracketContents.indexOf('_') != -1) { // #[_ < 5] 275                            sizeExpr = bracketContents;276                        } else { // #[5] | #[$.foo] 277                            sizeExpr = bracketContents + " == _";278                        }279                        JsValue jv = context.JS.eval(sizeExpr);280                        context.JS.bindings.removeMember("$");281                        context.JS.bindings.removeMember("_");282                        if (!jv.isTrue()) {283                            return fail("actual array length is " + listSize);284                        }285                    }286                    if (macro.length() > closeBracketPos + 1) {287                        macro = StringUtils.trimToNull(macro.substring(closeBracketPos + 1));288                        if (macro != null) {289                            if (macro.startsWith("(") && macro.endsWith(")")) {290                                macro = macro.substring(1, macro.length() - 1); // strip parens291                            }292                            if (macro.startsWith("?")) { // #[]? _.length == 3293                                macro = "#" + macro;294                            }295                            if (macro.startsWith("#")) {296                                MatchOperation mo = new MatchOperation(context, Match.Type.EACH_EQUALS, actual, new Match.Value(macro));297                                mo.execute();298                                return mo.pass ? pass() : fail("all array elements matched");299                            } else { // schema reference300                                Match.Type nestedType = macroToMatchType(true, macro); // match each301                                int startPos = matchTypeToStartPos(nestedType);302                                macro = macro.substring(startPos);303                                JsValue jv = context.JS.eval(macro);304                                MatchOperation mo = new MatchOperation(context, nestedType, actual, new Match.Value(jv.getValue()));305                                return mo.execute();306                            }307                        }308                    }309                    return true; // expression within square brackets is ok310                }311            } else { // '#? _ != 0' | '#string' | '#number? _ > 0'312                int questionPos = macro.indexOf('?');313                String validatorName = null;314                // in case of regex we don't want to remove the '?'315                if (questionPos != -1 && !macro.startsWith(REGEX)) {316                    validatorName = macro.substring(0, questionPos);317                    if (macro.length() > questionPos + 1) {318                        macro = StringUtils.trimToEmpty(macro.substring(questionPos + 1));319                    } else {320                        macro = "";321                    }322                } else {323                    validatorName = macro;324                    macro = "";325                }326                validatorName = StringUtils.trimToNull(validatorName);327                if (validatorName != null) {328                    Match.Validator validator = null;329                    if (validatorName.startsWith(REGEX)) {330                        String regex = validatorName.substring(5).trim();331                        validator = new Match.RegexValidator(regex);332                    } else {333                        validator = Match.VALIDATORS.get(validatorName);334                    }335                    if (validator != null) {336                        if (optional && (actual.isNotPresent() || actual.isNull())) {337                            // pass338                        } else if (!optional && actual.isNotPresent()) {339                            // if the element is not present the expected result can only be340                            // the notpresent keyword, ignored or an optional comparison341                            return expected.isNotPresent() || "#ignore".contentEquals(expected.getAsString());342                        } else {343                            Match.Result mr = validator.apply(actual);344                            if (!mr.pass) {345                                return fail(mr.message);346                            }347                        }348                    } else if (!validatorName.startsWith(REGEX)) { // expected is a string that happens to start with "#"349                        String actualValue = actual.getValue();350                        switch (type) {351                            case CONTAINS:352                                return actualValue.contains(expStr);353                            default:354                                return actualValue.equals(expStr);355                        }356                    }357                }358                macro = StringUtils.trimToNull(macro);359                if (macro != null && questionPos != -1) {360                    context.JS.put("$", context.root.actual.getValue());361                    context.JS.put("_", actual.getValue());362                    JsValue jv = context.JS.eval(macro);363                    context.JS.bindings.removeMember("$");364                    context.JS.bindings.removeMember("_");365                    if (!jv.isTrue()) {366                        return fail("evaluated to 'false'");367                    }368                }369            }370        }371        return true; // all ok372    }373    private boolean actualEqualsExpected() {374        switch (actual.type) {375            case NULL:376                return true; // both are null377            case BOOLEAN:378                boolean actBoolean = actual.getValue();379                boolean expBoolean = expected.getValue();380                return actBoolean == expBoolean;381            case NUMBER:382                if (actual.getValue() instanceof BigDecimal || expected.getValue() instanceof BigDecimal) {383                    BigDecimal actBigDecimal = toBigDecimal(actual.getValue());384                    BigDecimal expBigDecimal = toBigDecimal(expected.getValue());385                    return actBigDecimal.compareTo(expBigDecimal) == 0;386                } else {387                    Number actNumber = actual.getValue();388                    Number expNumber = expected.getValue();389                    return actNumber.doubleValue() == expNumber.doubleValue();390                }391            case STRING:392                return actual.getValue().equals(expected.getValue());393            case BYTES:394                byte[] actBytes = actual.getValue();395                byte[] expBytes = expected.getValue();396                return Arrays.equals(actBytes, expBytes);397            case LIST:398                List actList = actual.getValue();399                List expList = expected.getValue();400                int actListCount = actList.size();401                int expListCount = expList.size();402                if (actListCount != expListCount) {403                    return fail("actual array length is not equal to expected - " + actListCount + ":" + expListCount);404                }405                for (int i = 0; i < actListCount; i++) {406                    Match.Value actListValue = new Match.Value(actList.get(i));407                    Match.Value expListValue = new Match.Value(expList.get(i));408                    MatchOperation mo = new MatchOperation(context.descend(i), Match.Type.EQUALS, actListValue, expListValue);409                    mo.execute();410                    if (!mo.pass) {411                        return fail("array match failed at index " + i);412                    }413                }414                return true;415            case MAP:416                Map<String, Object> actMap = actual.getValue();417                Map<String, Object> expMap = expected.getValue();418                return matchMapValues(actMap, expMap);419            case XML:420                Map<String, Object> actXml = (Map) XmlUtils.toObject(actual.getValue(), true);421                Map<String, Object> expXml = (Map) XmlUtils.toObject(expected.getValue(), true);422                return matchMapValues(actXml, expXml);423            case OTHER:424                return actual.getValue().equals(expected.getValue());425            default:426                throw new RuntimeException("unexpected type (match equals): " + actual.type);427        }428    }429    private boolean matchMapValues(Map<String, Object> actMap, Map<String, Object> expMap) { // combined logic for equals and contains430        if (actMap.size() > expMap.size() && (type == Match.Type.EQUALS || type == Match.Type.CONTAINS_ONLY)) {431            int sizeDiff = actMap.size() - expMap.size();432            Map<String, Object> diffMap = new LinkedHashMap(actMap);433            for (String key : expMap.keySet()) {434                diffMap.remove(key);435            }436            return fail("actual has " + sizeDiff + " more key(s) than expected - " + JsonUtils.toJson(diffMap));437        }438        Set<String> unMatchedKeysAct = new LinkedHashSet(actMap.keySet());439        Set<String> unMatchedKeysExp = new LinkedHashSet(expMap.keySet());440        for (Map.Entry<String, Object> expEntry : expMap.entrySet()) {441            String key = expEntry.getKey();442            Object childExp = expEntry.getValue();443            if (!actMap.containsKey(key)) {444                if (childExp instanceof String) {445                    String childString = (String) childExp;446                    if (childString.startsWith("##") || childString.equals("#ignore") || childString.equals("#notpresent")) {447                        if (type == Match.Type.CONTAINS_ANY || type == Match.Type.CONTAINS_ANY_DEEP) {448                            return true; // exit early449                        }450                        unMatchedKeysExp.remove(key);451                        if (unMatchedKeysExp.isEmpty()) {452                            if (type == Match.Type.CONTAINS || type == Match.Type.CONTAINS_DEEP) {453                                return true; // all expected keys matched454                            }455                        }456                        continue;457                    }458                }459                if (type != Match.Type.CONTAINS_ANY && type != Match.Type.CONTAINS_ANY_DEEP) {460                    return fail("actual does not contain key - '" + key + "'");461                }462            }463            Match.Value childActValue = new Match.Value(actMap.get(key));464            Match.Type childMatchType;465            if (type == Match.Type.CONTAINS_DEEP) {466                childMatchType = childActValue.isMapOrListOrXml() ? Match.Type.CONTAINS_DEEP : Match.Type.EQUALS;467            } else {468                childMatchType = Match.Type.EQUALS;469            }470            MatchOperation mo = new MatchOperation(context.descend(key), childMatchType, childActValue, new Match.Value(childExp));471            mo.execute();472            if (mo.pass) {473                if (type == Match.Type.CONTAINS_ANY || type == Match.Type.CONTAINS_ANY_DEEP) {474                    return true; // exit early475                }476                unMatchedKeysExp.remove(key);477                if (unMatchedKeysExp.isEmpty()) {478                    if (type == Match.Type.CONTAINS || type == Match.Type.CONTAINS_DEEP) {479                        return true; // all expected keys matched480                    }481                }482                unMatchedKeysAct.remove(key);483            } else if (type == Match.Type.EQUALS) {484                return fail("match failed for name: '" + key + "'");485            }486        }487        if (type == Match.Type.CONTAINS_ANY || type == Match.Type.CONTAINS_ANY_DEEP) {488            return unMatchedKeysExp.isEmpty() ? true : fail("no key-values matched");489        }490        if (unMatchedKeysExp.isEmpty()) { 491            if (type == Match.Type.CONTAINS || type == Match.Type.CONTAINS_DEEP) {492                return true; // all expected keys matched, expMap was empty in the first place    493            }494            if (type == Match.Type.NOT_CONTAINS && !expMap.isEmpty()) {495                return true; // hack alert: the NOT_CONTAINS will be reversed by the calling routine496            }497        }498        if (!unMatchedKeysExp.isEmpty()) {499            return fail("all key-values did not match, expected has un-matched keys - " + unMatchedKeysExp);500        }501        if (!unMatchedKeysAct.isEmpty()) {502            return fail("all key-values did not match, actual has un-matched keys - " + unMatchedKeysAct);503        }504        return true;505    }506    private boolean actualContainsExpected() {507        switch (actual.type) {508            case STRING:509                String actString = actual.getValue();510                String expString = expected.getValue();511                return actString.contains(expString);512            case LIST:513                List actList = actual.getValue();514                List expList = expected.getValue();515                int actListCount = actList.size();516                int expListCount = expList.size();517                if (type != Match.Type.CONTAINS_ANY && type != Match.Type.CONTAINS_ANY_DEEP && expListCount > actListCount) {518                    return fail("actual array length is less than expected - " + actListCount + ":" + expListCount);519                }520                if (type == Match.Type.CONTAINS_ONLY && expListCount != actListCount) {521                    return fail("actual array length is not equal to expected - " + actListCount + ":" + expListCount);522                }523                for (Object exp : expList) { // for each item in the expected list524                    boolean found = false;525                    Match.Value expListValue = new Match.Value(exp);526                    for (int i = 0; i < actListCount; i++) {527                        Match.Value actListValue = new Match.Value(actList.get(i));528                        Match.Type childMatchType;529                        switch (type) {530                            case CONTAINS_DEEP:531                                childMatchType = actListValue.isMapOrListOrXml() ? Match.Type.CONTAINS_DEEP : Match.Type.EQUALS;532                                break;533                            case CONTAINS_ANY_DEEP:534                                childMatchType = actListValue.isMapOrListOrXml() ? Match.Type.CONTAINS_ANY : Match.Type.EQUALS;535                                break;536                            default:537                                childMatchType = Match.Type.EQUALS;538                        }539                        MatchOperation mo = new MatchOperation(context.descend(i), childMatchType, actListValue, expListValue);540                        mo.execute();541                        if (mo.pass) {542                            if (type == Match.Type.CONTAINS_ANY || type == Match.Type.CONTAINS_ANY_DEEP) {543                                return true; // exit early544                            } else {545                                found = true;546                                break; // next item in expected list547                            }548                        }549                    }550                    if (!found && type != Match.Type.CONTAINS_ANY && type != Match.Type.CONTAINS_ANY_DEEP) { // if we reached here, all items in the actual list were scanned551                        return fail("actual array does not contain expected item - " + expListValue.getAsString());552                    }553                }554                if (type == Match.Type.CONTAINS_ANY || type == Match.Type.CONTAINS_ANY_DEEP) {555                    return fail("actual array does not contain any of the expected items");556                }557                return true; // if we reached here, all items in the expected list were found558            case MAP:559                Map<String, Object> actMap = actual.getValue();560                Map<String, Object> expMap = expected.getValue();561                return matchMapValues(actMap, expMap);562            case XML:563                Map<String, Object> actXml = (Map) XmlUtils.toObject(actual.getValue());564                Map<String, Object> expXml = (Map) XmlUtils.toObject(expected.getValue());565                return matchMapValues(actXml, expXml);566            default:567                throw new RuntimeException("unexpected type (match contains): " + actual.type);568        }569    }570    private static BigDecimal toBigDecimal(Object o) {571        if (o instanceof BigDecimal) {572            return (BigDecimal) o;573        } else if (o instanceof Number) {574            Number n = (Number) o;575            return BigDecimal.valueOf(n.doubleValue());576        } else {577            throw new RuntimeException("expected number instead of: " + o);578        }579    }580    private boolean pass() {581        pass = true;582        return true;583    }584    private boolean fail(String reason) {585        pass = false;586        if (reason == null) {587            return false;588        }589        failReason = failReason == null ? reason : reason + " | " + failReason;590        context.root.failures.add(this);591        return false;592    }593    String getFailureReasons() {594        return collectFailureReasons(this);595    }596    private boolean isXmlAttributeOrMap() {597        return context.xml && actual.isMap()598                && (context.name.equals("@") || actual.<Map>getValue().containsKey("_"));599    }600    private static String collectFailureReasons(MatchOperation root) {601        StringBuilder sb = new StringBuilder();602        sb.append("match failed: ").append(root.type).append('\n');603        Collections.reverse(root.failures);604        Iterator<MatchOperation> iterator = root.failures.iterator();605        Set previousPaths = new HashSet();606        int index = 0;607        int prevDepth = -1;608        while (iterator.hasNext()) {609            MatchOperation mo = iterator.next();610            if (previousPaths.contains(mo.context.path) || mo.isXmlAttributeOrMap()) {611                continue;612            }613            previousPaths.add(mo.context.path);614            if (mo.context.depth != prevDepth) {615                prevDepth = mo.context.depth;616                index++;617            }618            String prefix = StringUtils.repeat(' ', index * 2);619            sb.append(prefix).append(mo.context.path).append(" | ").append(mo.failReason);620            sb.append(" (").append(mo.actual.type).append(':').append(mo.expected.type).append(")");621            sb.append('\n');622            if (mo.context.xml) {623                sb.append(prefix).append(mo.actual.getAsXmlString()).append('\n');...

MatchOperation

Using AI Code Generation

1def json = { a: 1, b: 2, c: 3 }2def json2 = { a: 1, b: 2, c: 3 }3def json3 = { a: 1, b: 2, c: 3, d: 4 }4def json4 = { a: 1, b: 2, c: 3, d: 4, e: 5 }5def json5 = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }6def json6 = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7 }7def json7 = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8 }8def json8 = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9 }9def json9 = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10 }10def json10 = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10, k: 11 }11def json11 = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10, k: 11, l: 12 }12def json12 = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10

MatchOperation

Using AI Code Generation

1* def json1 = read('classpath:json1.json')2* def json2 = read('classpath:json2.json')3* match json1 == { "name" : "John", "age" : 30, "salary" : 123.45 }4* match json1 != { "name" : "John", "age" : 30, "salary" : 123.45 }5* match json1 == { "name" : "John", "age" : 30, "salary" : 123.45, "address" : { "city" : "New York", "state" : "NY" } }6* match json1 != { "name" : "John", "age" : 30, "salary" : 123.45, "address" : { "city" : "New York", "state" : "NY" } }7* match json1 == { "name" : "John", "age" : 30, "salary" : 123.45, "address" : { "city" : "New York", "state" : "NY" } }8* match json1 != { "name" : "John", "age" : 30, "salary" : 123.45, "address" : { "city" : "New York", "state" : "NY" } }9* match json1 == { "name" : "John", "age" : 30, "salary" : 123.45, "address" : { "city" : "New York", "state" : "NY" } }10* match json1 != { "name" : "John", "age" : 30, "salary" : 123.45, "address" : { "city" : "New York", "state" : "NY" } }11* match json1 == { "name" : "John", "age" : 30, "salary" : 123.45, "address" : { "city" : "New York", "state" : "NY" } }12* match json1 != { "name" : "John", "age" : 30, "salary" :

MatchOperation

Using AI Code Generation

1import com.intuit.karate.MatchOperation2def match = MatchOperation.match(3    { it == 'foo' },4    { it == 'bar' }5import com.intuit.karate.MatchOperation6def match = MatchOperation.match(7    { it == 'foo' },8    { it == 'bar' }9import com.intuit.karate.MatchOperation10def match = MatchOperation.match(11    { it == 'foo' },12    { it == 'bar' }13import com.intuit.karate.MatchOperation14def match = MatchOperation.match(15    { it == 'foo' },16    { it == 'bar' }17import com.intuit.karate.MatchOperation18def match = MatchOperation.match(19    { it == 'foo' },20    { it == 'bar' }21import com.intuit.karate.MatchOperation22def match = MatchOperation.match(23    { it == 'foo' },24    { it == 'bar' }25import com.intuit.karate.MatchOperation26def match = MatchOperation.match(27    { it == 'foo' },28    { it == 'bar' }

MatchOperation

Using AI Code Generation

1* def input = {id: '123', name: 'John', phone: '1234567890'}2* match input == {id: '#number', name: '#string', phone: '#string'}3* def input = {id: '123', name: 'John', phone: '1234567890'}4* match input == {id: '#number', name: '#string', phone: '#string'}5* def input = {id: '123', name: 'John', phone: '1234567890'}6* match input == {id: '#number', name: '#string', phone: '#string'}7* def input = {id: '123', name: 'John', phone: '1234567890'}8* match input == {id: '#number', name: '#string', phone: '#string'}9* def input = {id: '123', name: 'John', phone: '1234567890'}10* match input == {id: '#number', name: '#string', phone: '#string'}11* def input = {id: '123', name: 'John', phone: '1234567890'}12* match input == {id: '#number', name: '#string', phone: '#string'}13* def input = {id: '123', name: 'John', phone: '1234567890'}14* match input == {id: '#number', name: '#string', phone: '#string'}15* def input = {id: '123', name: 'John', phone: '1234567890'}16* match input == {id: '#number', name: '#string', phone: '#string'}17* def input = {id: '123', name: 'John', phone: '1234567890'}18* match input == {id: '#number', name: '#string', phone: '#string'}19* def input = {id: '123', name: 'John', phone: '1234567890'}20* match input == {id: '#number', name: '#string', phone: '#string'}21* def input = {id: '123', name: 'John', phone: '1234567890'}22* match input == {id: '#number', name: '#string', phone: '#string'}23* def input = {id: '123', name: 'John', phone: '123

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.