Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Firefox/python/mozbuild/mozbuild/test/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 2 kB

Quelle test_expression.py Sprache: Python

import unittest

import mozunit

from mozbuild.preprocessor import Context, Expression

class TestContext(unittest.TestCase):
    """
    Unit tests for the Context class
    """

    def setUp(self):
        self.c = Context()
        self.c["FAIL"] = "PASS"

    def test_string_literal(self):
        """test string literal, fall-through for undefined var in a Context"""
        self.assertEqual(self.c["PASS"], "PASS")

    def test_variable(self):
        """test value for defined var in the Context class"""
        self.assertEqual(self.c["FAIL"], "PASS")

    def test_in(self):
        """test 'var in context' to not fall for fallback"""
        self.assertTrue("FAIL" in self.c)
        self.assertTrue("PASS" not in self.c)

class TestExpression(unittest.TestCase):
    """
    Unit tests for the Expression class
    evaluate() is called with a context {FAIL: 'PASS'}
    """

    def setUp(self):
        self.c = Context()
        self.c["FAIL"] = "PASS"

    def test_string_literal(self):
        """Test for a string literal in an Expression"""
        self.assertEqual(Expression("PASS").evaluate(self.c), "PASS")

    def test_variable(self):
        """Test for variable value in an Expression"""
        self.assertEqual(Expression("FAIL").evaluate(self.c), "PASS")

    def test_not(self):
        """Test for the ! operator"""
        self.assertTrue(Expression("!0").evaluate(self.c))
        self.assertTrue(not Expression("!1").evaluate(self.c))

    def test_equals(self):
        """Test for the == operator"""
        self.assertTrue(Expression("FAIL == PASS").evaluate(self.c))

    def test_notequals(self):
        """Test for the != operator"""
        self.assertTrue(Expression("FAIL != 1").evaluate(self.c))

    def test_logical_and(self):
        """Test for the && operator"""
        self.assertTrue(Expression("PASS == PASS && PASS != NOTPASS").evaluate(self.c))

    def test_logical_or(self):
        """Test for the || operator"""
        self.assertTrue(
            Expression("PASS == NOTPASS || PASS != NOTPASS").evaluate(self.c)
        )

    def test_logical_ops(self):
        """Test for the && and || operators precedence"""
        # Would evaluate to false if precedence was wrong
        self.assertTrue(
            Expression("PASS == PASS || PASS != NOTPASS && PASS == NOTPASS").evaluate(
                self.c
            )
        )

    def test_defined(self):
        """Test for the defined() value"""
        self.assertTrue(Expression("defined(FAIL)").evaluate(self.c))
        self.assertTrue(Expression("!defined(PASS)").evaluate(self.c))

if __name__ == "__main__":
    mozunit.main()

quality97%

¤ Dauer der Verarbeitung: 0.12 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.