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

Copied to Clipboard!

How to use between method of are class

Best Mockery code snippet using are.between

OverlappingFieldsCanBeMerged.php

Source:OverlappingFieldsCanBeMerged.php

...39        }40        return $reason;41    }42    /**43     * A memoization for when two fragments are compared "between" each other for44     * conflicts. Two fragments may be compared many times, so memoizing this can45     * dramatically improve the performance of this validator.46     * @var PairSet47     */48    private $comparedFragmentPairs;49    /**50     * A cache for the "field map" and list of fragment names found in any given51     * selection set. Selection sets may be asked for this information multiple52     * times, so this improves the performance of this validator.53     *54     * @var \SplObjectStorage55     */56    private $cachedFieldsAndFragmentNames;57    public function getVisitor(ValidationContext $context)58    {59        $this->comparedFragmentPairs = new PairSet();60        $this->cachedFieldsAndFragmentNames = new \SplObjectStorage();61        return [62            NodeKind::SELECTION_SET => function(SelectionSetNode $selectionSet) use ($context) {63                $conflicts = $this->findConflictsWithinSelectionSet(64                    $context,65                    $context->getParentType(),66                    $selectionSet67                );68                foreach ($conflicts as $conflict) {69                    $responseName = $conflict[0][0];70                    $reason = $conflict[0][1];71                    $fields1 = $conflict[1];72                    $fields2 = $conflict[2];73                    $context->reportError(new Error(74                        self::fieldsConflictMessage($responseName, $reason),75                        array_merge($fields1, $fields2)76                    ));77                }78            }79        ];80    }81    /**82     * Algorithm:83     *84     * Conflicts occur when two fields exist in a query which will produce the same85     * response name, but represent differing values, thus creating a conflict.86     * The algorithm below finds all conflicts via making a series of comparisons87     * between fields. In order to compare as few fields as possible, this makes88     * a series of comparisons "within" sets of fields and "between" sets of fields.89     *90     * Given any selection set, a collection produces both a set of fields by91     * also including all inline fragments, as well as a list of fragments92     * referenced by fragment spreads.93     *94     * A) Each selection set represented in the document first compares "within" its95     * collected set of fields, finding any conflicts between every pair of96     * overlapping fields.97     * Note: This is the *only time* that a the fields "within" a set are compared98     * to each other. After this only fields "between" sets are compared.99     *100     * B) Also, if any fragment is referenced in a selection set, then a101     * comparison is made "between" the original set of fields and the102     * referenced fragment.103     *104     * C) Also, if multiple fragments are referenced, then comparisons105     * are made "between" each referenced fragment.106     *107     * D) When comparing "between" a set of fields and a referenced fragment, first108     * a comparison is made between each field in the original set of fields and109     * each field in the the referenced set of fields.110     *111     * E) Also, if any fragment is referenced in the referenced selection set,112     * then a comparison is made "between" the original set of fields and the113     * referenced fragment (recursively referring to step D).114     *115     * F) When comparing "between" two fragments, first a comparison is made between116     * each field in the first referenced set of fields and each field in the the117     * second referenced set of fields.118     *119     * G) Also, any fragments referenced by the first must be compared to the120     * second, and any fragments referenced by the second must be compared to the121     * first (recursively referring to step F).122     *123     * H) When comparing two fields, if both have selection sets, then a comparison124     * is made "between" both selection sets, first comparing the set of fields in125     * the first selection set with the set of fields in the second.126     *127     * I) Also, if any fragment is referenced in either selection set, then a128     * comparison is made "between" the other set of fields and the129     * referenced fragment.130     *131     * J) Also, if two fragments are referenced in both selection sets, then a132     * comparison is made "between" the two fragments.133     *134     */135    /**136     * Find all conflicts found "within" a selection set, including those found137     * via spreading in fragments. Called when visiting each SelectionSet in the138     * GraphQL Document.139     *140     * @param ValidationContext $context141     * @param CompositeType $parentType142     * @param SelectionSetNode $selectionSet143     * @return array144     */145    private function findConflictsWithinSelectionSet(146        ValidationContext $context,147        $parentType,148        SelectionSetNode $selectionSet)149    {150        list($fieldMap, $fragmentNames) = $this->getFieldsAndFragmentNames(151            $context,152            $parentType,153            $selectionSet154        );155        $conflicts = [];156        // (A) Find find all conflicts "within" the fields of this selection set.157        // Note: this is the *only place* `collectConflictsWithin` is called.158        $this->collectConflictsWithin(159            $context,160            $conflicts,161            $fieldMap162        );163        $fragmentNamesLength = count($fragmentNames);164        if ($fragmentNamesLength !== 0) {165            // (B) Then collect conflicts between these fields and those represented by166            // each spread fragment name found.167            $comparedFragments = [];168            for ($i = 0; $i < $fragmentNamesLength; $i++) {169                $this->collectConflictsBetweenFieldsAndFragment(170                    $context,171                    $conflicts,172                    $comparedFragments,173                    false,174                    $fieldMap,175                    $fragmentNames[$i]176                );177                // (C) Then compare this fragment with all other fragments found in this178                // selection set to collect conflicts between fragments spread together.179                // This compares each item in the list of fragment names to every other item180                // in that same list (except for itself).181                for ($j = $i + 1; $j < $fragmentNamesLength; $j++) {182                    $this->collectConflictsBetweenFragments(183                        $context,184                        $conflicts,185                        false,186                        $fragmentNames[$i],187                        $fragmentNames[$j]188                    );189                }190            }191        }192        return $conflicts;193    }194    /**195     * Collect all conflicts found between a set of fields and a fragment reference196     * including via spreading in any nested fragments.197     *198     * @param ValidationContext $context199     * @param array $conflicts200     * @param array $comparedFragments201     * @param bool $areMutuallyExclusive202     * @param array $fieldMap203     * @param string $fragmentName204     */205    private function collectConflictsBetweenFieldsAndFragment(206        ValidationContext $context,207        array &$conflicts,208        array &$comparedFragments,209        $areMutuallyExclusive,210        array $fieldMap,211        $fragmentName212    ) {213        if (isset($comparedFragments[$fragmentName])) {214            return;215        }216        $comparedFragments[$fragmentName] = true;217        $fragment = $context->getFragment($fragmentName);218        if (!$fragment) {219            return;220        }221        list($fieldMap2, $fragmentNames2) = $this->getReferencedFieldsAndFragmentNames(222            $context,223            $fragment224        );225        if ($fieldMap === $fieldMap2) {226            return;227        }228        // (D) First collect any conflicts between the provided collection of fields229        // and the collection of fields represented by the given fragment.230        $this->collectConflictsBetween(231          $context,232          $conflicts,233          $areMutuallyExclusive,234          $fieldMap,235          $fieldMap2236        );237        // (E) Then collect any conflicts between the provided collection of fields238        // and any fragment names found in the given fragment.239        $fragmentNames2Length = count($fragmentNames2);240        for ($i = 0; $i < $fragmentNames2Length; $i++) {241            $this->collectConflictsBetweenFieldsAndFragment(242                $context,243                $conflicts,244                $comparedFragments,245                $areMutuallyExclusive,246                $fieldMap,247                $fragmentNames2[$i]248            );249        }250    }251    /**252     * Collect all conflicts found between two fragments, including via spreading in253     * any nested fragments.254     *255     * @param ValidationContext $context256     * @param array $conflicts257     * @param bool $areMutuallyExclusive258     * @param string $fragmentName1259     * @param string $fragmentName2260     */261    private function collectConflictsBetweenFragments(262        ValidationContext $context,263        array &$conflicts,264        $areMutuallyExclusive,265        $fragmentName1,266        $fragmentName2267    ) {268        // No need to compare a fragment to itself.269        if ($fragmentName1 === $fragmentName2) {270            return;271        }272        // Memoize so two fragments are not compared for conflicts more than once.273        if (274            $this->comparedFragmentPairs->has(275                $fragmentName1,276                $fragmentName2,277                $areMutuallyExclusive278            )279        ) {280            return;281        }282        $this->comparedFragmentPairs->add(283            $fragmentName1,284            $fragmentName2,285            $areMutuallyExclusive286        );287        $fragment1 = $context->getFragment($fragmentName1);288        $fragment2 = $context->getFragment($fragmentName2);289        if (!$fragment1 || !$fragment2) {290            return;291        }292        list($fieldMap1, $fragmentNames1) = $this->getReferencedFieldsAndFragmentNames(293            $context,294            $fragment1295        );296        list($fieldMap2, $fragmentNames2) = $this->getReferencedFieldsAndFragmentNames(297            $context,298            $fragment2299        );300        // (F) First, collect all conflicts between these two collections of fields301        // (not including any nested fragments).302        $this->collectConflictsBetween(303          $context,304          $conflicts,305          $areMutuallyExclusive,306          $fieldMap1,307          $fieldMap2308        );309        // (G) Then collect conflicts between the first fragment and any nested310        // fragments spread in the second fragment.311        $fragmentNames2Length = count($fragmentNames2);312        for ($j = 0; $j < $fragmentNames2Length; $j++) {313            $this->collectConflictsBetweenFragments(314                $context,315                $conflicts,316                $areMutuallyExclusive,317                $fragmentName1,318                $fragmentNames2[$j]319            );320        }321        // (G) Then collect conflicts between the second fragment and any nested322        // fragments spread in the first fragment.323        $fragmentNames1Length = count($fragmentNames1);324        for ($i = 0; $i < $fragmentNames1Length; $i++) {325            $this->collectConflictsBetweenFragments(326                $context,327                $conflicts,328                $areMutuallyExclusive,329                $fragmentNames1[$i],330                $fragmentName2331            );332        }333    }334    /**335     * Find all conflicts found between two selection sets, including those found336     * via spreading in fragments. Called when determining if conflicts exist337     * between the sub-fields of two overlapping fields.338     *339     * @param ValidationContext $context340     * @param bool $areMutuallyExclusive341     * @param CompositeType $parentType1342     * @param $selectionSet1343     * @param CompositeType $parentType2344     * @param $selectionSet2345     * @return array346     */347    private function findConflictsBetweenSubSelectionSets(348        ValidationContext $context,349        $areMutuallyExclusive,350        $parentType1,351        SelectionSetNode $selectionSet1,352        $parentType2,353        SelectionSetNode $selectionSet2354    ) {355        $conflicts = [];356        list($fieldMap1, $fragmentNames1) = $this->getFieldsAndFragmentNames(357            $context,358            $parentType1,359            $selectionSet1360        );361        list($fieldMap2, $fragmentNames2) = $this->getFieldsAndFragmentNames(362            $context,363            $parentType2,364            $selectionSet2365        );366        // (H) First, collect all conflicts between these two collections of field.367        $this->collectConflictsBetween(368            $context,369            $conflicts,370            $areMutuallyExclusive,371            $fieldMap1,372            $fieldMap2373        );374        // (I) Then collect conflicts between the first collection of fields and375        // those referenced by each fragment name associated with the second.376        $fragmentNames2Length = count($fragmentNames2);377        if ($fragmentNames2Length !== 0) {378            $comparedFragments = [];379            for ($j = 0; $j < $fragmentNames2Length; $j++) {380                $this->collectConflictsBetweenFieldsAndFragment(381                    $context,382                    $conflicts,383                    $comparedFragments,384                    $areMutuallyExclusive,385                    $fieldMap1,386                    $fragmentNames2[$j]387                );388            }389        }390        // (I) Then collect conflicts between the second collection of fields and391        // those referenced by each fragment name associated with the first.392        $fragmentNames1Length = count($fragmentNames1);393        if ($fragmentNames1Length !== 0) {394            $comparedFragments = [];395            for ($i = 0; $i < $fragmentNames1Length; $i++) {396                $this->collectConflictsBetweenFieldsAndFragment(397                    $context,398                    $conflicts,399                    $comparedFragments,400                    $areMutuallyExclusive,401                    $fieldMap2,402                    $fragmentNames1[$i]403                );404            }405        }406        // (J) Also collect conflicts between any fragment names by the first and407        // fragment names by the second. This compares each item in the first set of408        // names to each item in the second set of names.409        for ($i = 0; $i < $fragmentNames1Length; $i++) {410            for ($j = 0; $j < $fragmentNames2Length; $j++) {411                $this->collectConflictsBetweenFragments(412                    $context,413                    $conflicts,414                    $areMutuallyExclusive,415                    $fragmentNames1[$i],416                    $fragmentNames2[$j]417                );418            }419        }420        return $conflicts;421    }422    /**423     * Collect all Conflicts "within" one collection of fields.424     *425     * @param ValidationContext $context426     * @param array $conflicts427     * @param array $fieldMap428     */429    private function collectConflictsWithin(430        ValidationContext $context,431        array &$conflicts,432        array $fieldMap433    )434    {435        // A field map is a keyed collection, where each key represents a response436        // name and the value at that key is a list of all fields which provide that437        // response name. For every response name, if there are multiple fields, they438        // must be compared to find a potential conflict.439        foreach ($fieldMap as $responseName => $fields) {440            // This compares every field in the list to every other field in this list441            // (except to itself). If the list only has one item, nothing needs to442            // be compared.443            $fieldsLength = count($fields);444            if ($fieldsLength > 1) {445                for ($i = 0; $i < $fieldsLength; $i++) {446                    for ($j = $i + 1; $j < $fieldsLength; $j++) {447                        $conflict = $this->findConflict(448                            $context,449                            false, // within one collection is never mutually exclusive450                            $responseName,451                            $fields[$i],452                            $fields[$j]453                        );454                        if ($conflict) {455                            $conflicts[] = $conflict;456                        }457                    }458                }459            }460        }461    }462    /**463     * Collect all Conflicts between two collections of fields. This is similar to,464     * but different from the `collectConflictsWithin` function above. This check465     * assumes that `collectConflictsWithin` has already been called on each466     * provided collection of fields. This is true because this validator traverses467     * each individual selection set.468     *469     * @param ValidationContext $context470     * @param array $conflicts471     * @param bool $parentFieldsAreMutuallyExclusive472     * @param array $fieldMap1473     * @param array $fieldMap2474     */475    private function collectConflictsBetween(476        ValidationContext $context,477        array &$conflicts,478        $parentFieldsAreMutuallyExclusive,479        array $fieldMap1,480        array $fieldMap2481    ) {482        // A field map is a keyed collection, where each key represents a response483        // name and the value at that key is a list of all fields which provide that484        // response name. For any response name which appears in both provided field485        // maps, each field from the first field map must be compared to every field486        // in the second field map to find potential conflicts.487        foreach ($fieldMap1 as $responseName => $fields1) {488            if (isset($fieldMap2[$responseName])) {489                $fields2 = $fieldMap2[$responseName];490                $fields1Length = count($fields1);491                $fields2Length = count($fields2);492                for ($i = 0; $i < $fields1Length; $i++) {493                    for ($j = 0; $j < $fields2Length; $j++) {494                        $conflict = $this->findConflict(495                            $context,496                            $parentFieldsAreMutuallyExclusive,497                            $responseName,498                            $fields1[$i],499                            $fields2[$j]500                        );501                        if ($conflict) {502                            $conflicts[] = $conflict;503                        }504                    }505                }506            }507        }508    }509    /**510     * Determines if there is a conflict between two particular fields, including511     * comparing their sub-fields.512     *513     * @param ValidationContext $context514     * @param bool $parentFieldsAreMutuallyExclusive515     * @param string $responseName516     * @param array $field1517     * @param array $field2518     * @return array|null519     */520    private function findConflict(521        ValidationContext $context,522        $parentFieldsAreMutuallyExclusive,523        $responseName,524        array $field1,525        array $field2526    )527    {528        list($parentType1, $ast1, $def1) = $field1;529        list($parentType2, $ast2, $def2) = $field2;530        // If it is known that two fields could not possibly apply at the same531        // time, due to the parent types, then it is safe to permit them to diverge532        // in aliased field or arguments used as they will not present any ambiguity533        // by differing.534        // It is known that two parent types could never overlap if they are535        // different Object types. Interface or Union types might overlap - if not536        // in the current state of the schema, then perhaps in some future version,537        // thus may not safely diverge.538        $areMutuallyExclusive =539            $parentFieldsAreMutuallyExclusive ||540            $parentType1 !== $parentType2 &&541            $parentType1 instanceof ObjectType &&542            $parentType2 instanceof ObjectType;543        // The return type for each field.544        $type1 = $def1 ? $def1->getType() : null;545        $type2 = $def2 ? $def2->getType() : null;546        if (!$areMutuallyExclusive) {547            // Two aliases must refer to the same field.548            $name1 = $ast1->name->value;549            $name2 = $ast2->name->value;550            if ($name1 !== $name2) {551                return [552                    [$responseName, "$name1 and $name2 are different fields"],553                    [$ast1],554                    [$ast2]555                ];556            }557            if (!$this->sameArguments($ast1->arguments ?: [], $ast2->arguments ?: [])) {558                return [559                    [$responseName, 'they have differing arguments'],560                    [$ast1],561                    [$ast2]562                ];563            }564        }565        if ($type1 && $type2 && $this->doTypesConflict($type1, $type2)) {566            return [567                [$responseName, "they return conflicting types $type1 and $type2"],568                [$ast1],569                [$ast2]570            ];571        }572        // Collect and compare sub-fields. Use the same "visited fragment names" list573        // for both collections so fields in a fragment reference are never574        // compared to themselves.575        $selectionSet1 = $ast1->selectionSet;576        $selectionSet2 = $ast2->selectionSet;577        if ($selectionSet1 && $selectionSet2) {578            $conflicts = $this->findConflictsBetweenSubSelectionSets(579                $context,580                $areMutuallyExclusive,581                Type::getNamedType($type1),582                $selectionSet1,583                Type::getNamedType($type2),584                $selectionSet2585            );586            return $this->subfieldConflicts(587                $conflicts,588                $responseName,589                $ast1,590                $ast2591            );592        }593        return null;594    }595    /**596     * @param ArgumentNode[] $arguments1597     * @param ArgumentNode[] $arguments2598     *599     * @return bool600     */601    private function sameArguments($arguments1, $arguments2)602    {603        if (count($arguments1) !== count($arguments2)) {604            return false;605        }606        foreach ($arguments1 as $argument1) {607            $argument2 = null;608            foreach ($arguments2 as $argument) {609                if ($argument->name->value === $argument1->name->value) {610                    $argument2 = $argument;611                    break;612                }613            }614            if (!$argument2) {615                return false;616            }617            if (!$this->sameValue($argument1->value, $argument2->value)) {618                return false;619            }620        }621        return true;622    }623    /**624     * @param Node $value1625     * @param Node $value2626     * @return bool627     */628    private function sameValue(Node $value1, Node $value2)629    {630        return (!$value1 && !$value2) || (Printer::doPrint($value1) === Printer::doPrint($value2));631    }632    /**633     * Two types conflict if both types could not apply to a value simultaneously.634     * Composite types are ignored as their individual field types will be compared635     * later recursively. However List and Non-Null types must match.636     *637     * @param OutputType $type1638     * @param OutputType $type2639     * @return bool640     */641    private function doTypesConflict(OutputType $type1, OutputType $type2)642    {643        if ($type1 instanceof ListOfType) {644            return $type2 instanceof ListOfType ?645                $this->doTypesConflict($type1->getWrappedType(), $type2->getWrappedType()) :646                true;647        }648        if ($type2 instanceof ListOfType) {649            return $type1 instanceof ListOfType ?650                $this->doTypesConflict($type1->getWrappedType(), $type2->getWrappedType()) :651                true;652        }653        if ($type1 instanceof NonNull) {654            return $type2 instanceof NonNull ?655                $this->doTypesConflict($type1->getWrappedType(), $type2->getWrappedType()) :656                true;657        }658        if ($type2 instanceof NonNull) {659            return $type1 instanceof NonNull ?660                $this->doTypesConflict($type1->getWrappedType(), $type2->getWrappedType()) :661                true;662        }663        if (Type::isLeafType($type1) || Type::isLeafType($type2)) {664            return $type1 !== $type2;665        }666        return false;667    }668    /**669     * Given a selection set, return the collection of fields (a mapping of response670     * name to field ASTs and definitions) as well as a list of fragment names671     * referenced via fragment spreads.672     *673     * @param ValidationContext $context674     * @param CompositeType $parentType675     * @param SelectionSetNode $selectionSet676     * @return array677     */678    private function getFieldsAndFragmentNames(679        ValidationContext $context,680        $parentType,681        SelectionSetNode $selectionSet682    ) {683        if (!isset($this->cachedFieldsAndFragmentNames[$selectionSet])) {684            $astAndDefs = [];685            $fragmentNames = [];686            $this->internalCollectFieldsAndFragmentNames(687                $context,688                $parentType,689                $selectionSet,690                $astAndDefs,691                $fragmentNames692            );693            $cached = [$astAndDefs, array_keys($fragmentNames)];694            $this->cachedFieldsAndFragmentNames[$selectionSet] = $cached;695        } else {696            $cached = $this->cachedFieldsAndFragmentNames[$selectionSet];697        }698        return $cached;699    }700    /**701     * Given a reference to a fragment, return the represented collection of fields702     * as well as a list of nested fragment names referenced via fragment spreads.703     *704     * @param ValidationContext $context705     * @param FragmentDefinitionNode $fragment706     * @return array|object707     */708    private function getReferencedFieldsAndFragmentNames(709        ValidationContext $context,710        FragmentDefinitionNode $fragment711    )712    {713        // Short-circuit building a type from the AST if possible.714        if (isset($this->cachedFieldsAndFragmentNames[$fragment->selectionSet])) {715            return $this->cachedFieldsAndFragmentNames[$fragment->selectionSet];716        }717        $fragmentType = TypeInfo::typeFromAST($context->getSchema(), $fragment->typeCondition);718        return $this->getFieldsAndFragmentNames(719            $context,720            $fragmentType,721            $fragment->selectionSet722        );723    }724    /**725     * Given a reference to a fragment, return the represented collection of fields726     * as well as a list of nested fragment names referenced via fragment spreads.727     *728     * @param ValidationContext $context729     * @param CompositeType $parentType730     * @param SelectionSetNode $selectionSet731     * @param array $astAndDefs732     * @param array $fragmentNames733     */734    private function internalCollectFieldsAndFragmentNames(735        ValidationContext $context,736        $parentType,737        SelectionSetNode $selectionSet,738        array &$astAndDefs,739        array &$fragmentNames740    )741    {742        $selectionSetLength = count($selectionSet->selections);743        for ($i = 0; $i < $selectionSetLength; $i++) {744            $selection = $selectionSet->selections[$i];745            switch (true) {746                case $selection instanceof FieldNode:747                    $fieldName = $selection->name->value;748                    $fieldDef = null;749                    if ($parentType instanceof ObjectType ||750                        $parentType instanceof InterfaceType) {751                        $tmp = $parentType->getFields();752                        if (isset($tmp[$fieldName])) {753                            $fieldDef = $tmp[$fieldName];754                        }755                    }756                    $responseName = $selection->alias ? $selection->alias->value : $fieldName;757                    if (!isset($astAndDefs[$responseName])) {758                        $astAndDefs[$responseName] = [];759                    }760                    $astAndDefs[$responseName][] = [$parentType, $selection, $fieldDef];761                    break;762                case $selection instanceof FragmentSpreadNode:763                    $fragmentNames[$selection->name->value] = true;764                    break;765                case $selection instanceof InlineFragmentNode:766                    $typeCondition = $selection->typeCondition;767                    $inlineFragmentType = $typeCondition768                        ? TypeInfo::typeFromAST($context->getSchema(), $typeCondition)769                        : $parentType;770                    $this->internalcollectFieldsAndFragmentNames(771                        $context,772                        $inlineFragmentType,773                        $selection->selectionSet,774                        $astAndDefs,775                        $fragmentNames776                    );777                    break;778            }779        }780    }781    /**782     * Given a series of Conflicts which occurred between two sub-fields, generate783     * a single Conflict.784     *785     * @param array $conflicts786     * @param string $responseName787     * @param FieldNode $ast1788     * @param FieldNode $ast2789     * @return array|null790     */791    private function subfieldConflicts(792        array $conflicts,793        $responseName,794        FieldNode $ast1,795        FieldNode $ast2796    )...

between

Using AI Code Generation

1class A {2    function foo() {3        if (isset($this)) {4            echo '$this is defined (';5            echo get_class($this);6            echo ")<br>";7        } else {8            echo "\$this is not defined.<br>";9        }10    }11}12class B {13    function bar() {14        A::foo();15    }16}17$a = new A();18$a->foo();19A::foo();20$b = new B();21$b->bar();22B::bar();23class A {24    function foo() {25        if (isset($this)) {26            echo '$this is defined (';27            echo get_class($this);28            echo ")<br>";29        } else {30            echo "\$this is not defined.<br>";31        }32    }33}34class B extends A {35    function bar() {36        A::foo();37        parent::foo();38        self::foo();39    }40}41$a = new A();42$a->foo();43A::foo();44$b = new B();45$b->bar();46B::bar();47class A {48    function foo() {49        if (isset($this)) {50            echo '$this is defined (';51            echo get_class($this);52            echo ")<br>";53        } else {54            echo "\$this is not defined.<br>";55        }56    }57}58class B extends A {59}60$a = new A();61$a->foo();62A::foo();63$b = new B();64$b->foo();65B::foo();66class A {67    function foo() {68        if (isset($this)) {69            echo '$this is defined (';70            echo get_class($this);71            echo ")<br>";72        } else {73            echo "\$this is not defined.<br>";74        }75    }76}77class B extends A {78    function foo() {79        parent::foo();80    }81}82$a = new A();83$a->foo();84A::foo();85$b = new B();86$b->foo();87B::foo();88class A {89    function foo() {90        if (isset($this)) {91            echo '$this is defined (';92            echo get_class($this

between

Using AI Code Generation

1class class1{2	public function __construct(){3		echo "class1";4	}5}6class class2{7	public function __construct(){8		echo "class2";9	}10}11class class3{12	public function __construct(){13		echo "class3";14	}15}16class class4{17	public function __construct(){18		echo "class4";19	}20}21class class5{22	public function __construct(){23		echo "class5";24	}25}26class class6{27	public function __construct(){28		echo "class6";29	}30}31class class7{32	public function __construct(){33		echo "class7";34	}35}36class class8{37	public function __construct(){38		echo "class8";39	}40}41class class9{42	public function __construct(){43		echo "class9";44	}45}46class class10{47	public function __construct(){48		echo "class10";49	}50}51class class11{52	public function __construct(){53		echo "class11";54	}55}56class class12{57	public function __construct(){58		echo "class12";59	}60}61class class13{62	public function __construct(){63		echo "class13";64	}65}66class class14{67	public function __construct(){68		echo "class14";69	}70}71class class15{72	public function __construct(){73		echo "class15";74	}75}76class class16{77	public function __construct(){78		echo "class16";79	}80}81class class17{82	public function __construct(){83		echo "class17";84	}85}86class class18{87	public function __construct(){88		echo "class18";89	}90}91class class19{92	public function __construct(){93		echo "class19";94	}95}96class class20{97	public function __construct(){98		echo "class20";99	}100}101class class21{102	public function __construct(){103		echo "class21";104	}105}106class class22{107	public function __construct(){108		echo "class22";109	}110}111class class23{112	public function __construct(){113		echo "class23";114	}115}116class class24{117	public function __construct(){118		echo "class24";119	}120}121class class25{122	public function __construct(){123		echo "class25";124	}125}126class class26{127	public function __construct(){128		echo "class26";129	}130}131class class27{132	public function __construct(){133		echo "class27";134	}135}136class class28{137	public function __construct(){

between

Using AI Code Generation

1class Test{2    public function __construct(){3        $this->method1();4    }5    public function method1(){6        $this->method2();7    }8    public function method2(){9        $this->method3();10    }11    public function method3(){12        $this->method4();13    }14    public function method4(){15        echo "method4";16    }17}18$test = new Test();19class Test{20    public function __construct(){21        $this->method1();22    }23    public function method1(){24        $this->method2();25    }26    public function method2(){27        $this->method3();28    }29    public function method3(){30        $this->method4();31    }32    public function method4(){33        $this->method5();34    }35    public function method5(){36        echo "method5";37    }38}39$test = new Test();40class Test{41    public function __construct(){42        $this->method1();43    }44    public function method1(){45        $this->method2();46    }47    public function method2(){48        $this->method3();49    }50    public function method3(){51        $this->method4();52    }53    public function method4(){54        $this->method5();55    }56    public function method5(){57        $this->method6();58    }59    public function method6(){60        echo "method6";61    }62}63$test = new Test();64class Test{65    public function __construct(){66        $this->method1();67    }68    public function method1(){69        $this->method2();70    }71    public function method2(){72        $this->method3();73    }74    public function method3(){75        $this->method4();76    }77    public function method4(){78        $this->method5();79    }80    public function method5(){81        $this->method6();82    }83    public function method6(){84        $this->method7();85    }86    public function method7(){87        echo "method7";88    }89}90$test = new Test();

between

Using AI Code Generation

1$var = new MyClass();2$var->myFunction();3$var = new MyClass();4$var->myFunction();5$var = new MyClass();6$var->myFunction();7$var = new MyClass();8$var->myFunction();9$var = new MyClass();10$var->myFunction();11$var = new MyClass();12$var->myFunction();13$var = new MyClass();14$var->myFunction();15$var = new MyClass();16$var->myFunction();17$var = new MyClass();18$var->myFunction();19$var = new MyClass();20$var->myFunction();21$var = new MyClass();22$var->myFunction();23$var = new MyClass();24$var->myFunction();25$var = new MyClass();26$var->myFunction();27$var = new MyClass();28$var->myFunction();29$var = new MyClass();30$var->myFunction();31$var = new MyClass();32$var->myFunction();33$var = new MyClass();34$var->myFunction();

between

Using AI Code Generation

1include('class.php');2$object = new class();3$object->method1();4$object->method2();5include('class.php');6$object = new class();7$object->method1();8$object->method2();9include('class.php');10$object = new class();11$object->method1();12$object->method2();13{14    function method1()15    {16    }17    function method2()18    {19    }20}21include('class.php');22$object = new class();23$object->method1();24$object->method2();25include('class.php');26$object = new class();27$object->method1();28$object->method2();29include('class.php');30$object = new class();31$object->method1();32$object->method2();33{34    function method1()35    {36    }37    function method2()38    {39    }40}41include('class.php');42$object = new class();43$object->method1();44$object->method2();45include('class.php');46$object = new class();47$object->method1();48$object->method2();49include('class.php');50$object = new class();51$object->method1();52$object->method2();

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.