Adds properties into testcase element.
771199
def _fill_properties(verdict, result, testcase, testcase_id, testcase_title):
        """"""
        properties = etree.SubElement(testcase, "properties")
        etree.SubElement(
            properties,
            "property",
            {"name": "polarion-testcase-id", "value": testcase_id or testcase_title},
        )
        if verdict in Verdicts.PASS and result.get("comment"):
            etree.SubElement(
                properties,
                "property",
                {
                    "name": "polarion-testcase-comment",
                    "value": utils.get_unicode_str(result["comment"]),
                },
            )

        for param, value in six.iteritems(result.get("params") or {}):
            etree.SubElement(
                properties,
                "property",
                {
                    "name": "polarion-parameter-{}".format(param),
                    "value": utils.get_unicode_str(value),
                },
            )
874500
def fill_response_property(xml_root, name=None, value=None):
    """"""
    name, value = generate_response_property(name, value)
    response_property = None

    if xml_root.tag == "testsuites":
        response_property = _fill_testsuites_response_property(xml_root, name, value)
    elif xml_root.tag in ("testcases", "requirements"):
        response_property = _fill_non_testsuites_response_property(xml_root, name, value)
    else:
        raise Dump2PolarionException(_NOT_EXPECTED_FORMAT_MSG)

    return response_property
1292144
def include(prop):
    ''''''
    if isinstance(prop, QueryableAttribute):
        prop = prop.property
    assert isinstance(prop, (Column, ColumnProperty, RelationshipProperty))
    #assert isinstance(prop, RelationshipProperty)
    _included.add(prop)
1187970
public function process(\ReflectionProperty $property, TestCase $test)
    {
        /** @var \ReflectionProperty $property */
        $propertyDocComment = $property->getDocComment();
        if (preg_match(self::REGEX_MOCK, $propertyDocComment, $matches)) {
            $isPrivate = $property->isPrivate();
            if ($isPrivate) {
                $property->setAccessible(true);
            }
            $mock = $this->mockObjectFactory->create($matches[1]);
            $property->setValue($test, $mock);
            if ($isPrivate) {
                $property->setAccessible(false);
            }
        }
    }
1078091
private void generateMetaGetPropertyValue() {
        if (properties.size() == 0) {
            return;
        }
        data.ensureImport(Bean.class);
        addLine(2, "@Override");
        addLine(2, "protected Object propertyGet(Bean bean, String propertyName, boolean quiet) {");
        addLine(3, "switch (propertyName.hashCode()) {");
        for (PropertyGen prop : properties) {
            addLines(prop.generatePropertyGetCase());
        }
        addLine(3, "}");
        addLine(3, "return super.propertyGet(bean, propertyName, quiet);");
        addLine(2, "}");
        addBlankLine();
    }
271588
public void addAllToProperties(Properties props) {
		synchronized (this.confData) {
			for (Map.Entry<String, Object> entry : this.confData.entrySet()) {
				props.put(entry.getKey(), entry.getValue());
			}
		}
	}
756700
def _add_attr_property(self):
        
        property_ = property(self._getter, self._setter, None)
        # assign unconditionally to overwrite element name definition
        setattr(self._element_cls, self._prop_name, property_)
819318
def import_junit(junit_file, **kwargs):
    """"""
    xml_root = _get_xml_root(junit_file)

    results = []
    for test_data in xml_root:
        if test_data.tag != "testcase":
            continue

        verdict, comment, properties = _parse_testcase_record(test_data)
        properties, parameters = _extract_parameters_from_properties(properties)

        title = test_data.get("name")
        classname = test_data.get("classname")
        time = test_data.get("time", 0)
        filepath = test_data.get("file")

        data = [
            ("title", title),
            ("classname", classname),
            ("verdict", verdict),
            ("comment", comment),
            ("time", time),
            ("file", filepath),
        ]
        for key in sorted(properties):
            data.append((key, properties[key]))
        if parameters:
            data.append(("params", OrderedDict(parameters)))

        results.append(OrderedDict(data))

    return xunit_exporter.ImportedData(results=results, testrun=None)
1369948
private void validateElementProperty(String propertyName, String controlValue, String resultValue, TestContext context) {
        if (StringUtils.hasText(controlValue)) {
            String control = context.replaceDynamicContentInString(controlValue);

            if (ValidationMatcherUtils.isValidationMatcherExpression(control)) {
                ValidationMatcherUtils.resolveValidationMatcher("payload", resultValue, control, context);
            } else {
                Assert.isTrue(control.equals(resultValue), String.format("Selenium web element validation failed, %s expected '%s', but was '%s'", propertyName, control, resultValue));
            }
        }
    }
403984
def addSuccess(self, test, capt):
        
        self.__insert_test_result(constants.State.PASS, test)
572939
function addCustomFeatureProperties(entity) {
  for (var i = 0; i < customProperties.length; i++) {
    if (entity.propertyNames.indexOf(customProperties[i]) === -1) {
      entity.addProperty(customProperties[i]);
    }
  }
}
840581
def addUnexpectedSuccess(self, test: unittest.case.TestCase) -> None:
        
        # noinspection PyTypeChecker
        self.add_result(TestState.unexpected_success, test)
517248
private void addSwitchCase(Node switchBlock, Node caseExpression,
                               Node statements)
    {
        if (switchBlock.getType() != Token.BLOCK) throw Kit.codeBug();
        Jump switchNode = (Jump)switchBlock.getFirstChild();
        if (switchNode.getType() != Token.SWITCH) throw Kit.codeBug();

        Node gotoTarget = Node.newTarget();
        if (caseExpression != null) {
            Jump caseNode = new Jump(Token.CASE, caseExpression);
            caseNode.target = gotoTarget;
            switchNode.addChildToBack(caseNode);
        } else {
            switchNode.setDefault(gotoTarget);
        }
        switchBlock.addChildToBack(gotoTarget);
        switchBlock.addChildToBack(statements);
    }
436156
def addSuccess(self, test: unittest.case.TestCase) -> None:
        
        # noinspection PyTypeChecker
        self.add_result(TestState.success, test)
499985
protected function extendEmptyCasesFromSuites(array $cases, TestSuite $suite)
    {
        $class = $suite->name;
        $file = $suite->file;

        /** @var TestCase $case */
        foreach ($cases as $case) {
            if (empty($case->class)) {
                $case->class = $class;
            }
            if (empty($case->file)) {
                $case->file = $file;
            }
        }
    }
1038333
void appendPropertiesTo( CssFormatter formatter ) {
        if( properties.isEmpty() ) {
            return;
        }
        formatter.addVariables( variables );
        for( Formattable prop : properties ) {
            switch( prop.getType() ) {
                case Formattable.RULE:
                    Rule rule = (Rule)prop;
                    // inline rules
                    if( rule.isValidCSS( formatter ) && rule.isInlineRule( formatter) ) {
                        rule.appendPropertiesTo( formatter );
                    }
                    break;
                default:
                    prop.appendTo( formatter );
            }
        }
        formatter.removeVariables( variables );
    }
843216
private List<TestCaseDef> extendBaseCases( FunctionInputDef inputDef, VarTupleSet validTuples, Iterator<TestCaseDef> baseCases)
    {
    List<TestCaseDef> testCases = new ArrayList<TestCaseDef>();
    
    // For each base test case...
    while( baseCases.hasNext())
      {
      TestCaseDef testCase = baseCases.next();
      logger_.debug( "Extending base test case={}", testCase);

      // Complete all variable bindings.
      if( makeComplete( testCase, validTuples, getVarsRemaining( inputDef, testCase)))
        {
        logger_.debug( "Completed test case={}", testCase);
        validTuples.used( testCase);
        testCases.add( testCase);
        }
      else
        {
        logger_.debug( "Can't complete test case={}", testCase);
        }
      }

    return testCases;
   }