Did I find the right examples for you? yes no

All Samples(382)  |  Call(382)  |  Derive(0)  |  Import(0)
Check that the expression is false.

src/s/t/stackalytics-HEAD/tests/unit/test_record_processor.py   stackalytics(Download)
        email = runtime_storage_inst.get_by_primary_key('<another-message-id>')
        self.assertTrue('mod:blueprint' in email['blueprint_id'])
        self.assertFalse('mod:invalid' in email['blueprint_id'])
 
    def test_review_number(self):
        homer_mark = next(itertools.ifilter(
            lambda x: x['date'] == (timestamp + 2), marks), None)
        self.assertFalse(homer_mark.get('disagreement'),
                         msg='No disagreement: core set +2 after +1')
 

src/t/r/trove-HEAD/trove/tests/unittests/guestagent/test_dbaas.py   trove(Download)
    def test_load_mysqld_options_error(self):
 
        dbaas.utils.execute = Mock(side_effect=ProcessExecutionError())
 
        self.assertFalse(dbaas.load_mysqld_options())
        self.mySqlAdmin.create_database(databases)
 
        self.assertFalse(dbaas.LocalSqlClient.execute.called,
                         "The client object was called when it wasn't " +
                         "supposed to")
        for text in expected:
            self.assertTrue(text in args[0].text, "%s not in query." % text)
        self.assertFalse("LIMIT " in args[0].text)
 
    def test_list_databases_with_limit(self):
            self.assertTrue(text in args[0].text, "%s not in query." % text)
 
        self.assertFalse("LIMIT " in args[0].text)
 
        self.assertTrue("AND schema_name > '" + marker + "'" in args[0].text)
            self.assertTrue(text in args[0].text, "%s not in query." % text)
 
        self.assertFalse("LIMIT " in args[0].text)
 
        self.assertTrue(("AND schema_name >= '%s'" % marker) in args[0].text)

src/h/e/heat-cfntools-1.2.7/heat_cfntools/tests/test_cfn_helper.py   heat-cfntools(Download)
        self.assertTrue(cfn_helper.to_boolean(1))
 
        self.assertFalse(cfn_helper.to_boolean(False))
        self.assertFalse(cfn_helper.to_boolean('false'))
        self.assertFalse(cfn_helper.to_boolean('no'))
        self.assertFalse(cfn_helper.to_boolean('0'))
        self.assertFalse(cfn_helper.to_boolean(0))

src/b/a/barbican-HEAD/barbican/tests/api/test_resources.py   barbican(Download)
                        .endswith(' '), "whitespace should be there")
        strip_whitespace(json_without_array)
        self.assertFalse(json_without_array['payload_content_type']
                         .startswith(' '), "whitespace should be gone")
        self.assertFalse(json_without_array['payload_content_type']
                        .endswith(' '), "whitespace should be there")
        strip_whitespace(json_with_array)
        self.assertFalse(json_with_array['an-array'][0]['name']
                         .startswith(' '), "whitespace should be gone")
        self.assertFalse(json_with_array['an-array'][1]['name']

src/t/r/trove-HEAD/trove/tests/unittests/backup/test_storage.py   trove(Download)
                 location) = storage_strategy.save(runner.manifest, runner)
 
        self.assertFalse(success, "The backup should have failed!")
        self.assertTrue(note.startswith("Error saving data to Swift!"))
        self.assertIsNone(checksum,
                 location) = storage_strategy.save(runner.manifest, runner)
 
        self.assertFalse(success, "The backup should have failed!")
        self.assertTrue(note.startswith("Error saving data to Swift!"))
        self.assertIsNone(checksum,
    def test_end_of_file(self):
        self.assertFalse(self.stream.end_of_file)
 
    def test_end_of_segment(self):
        self.assertFalse(self.stream.end_of_segment)

src/o/s/oslo.rootwrap-1.2.0/tests/test_rootwrap.py   oslo.rootwrap(Download)
    def test_CommandFilter(self):
        f = filters.CommandFilter("sleep", 'root', '10')
        self.assertFalse(f.match(["sleep2"]))
 
        # verify that any arguments are accepted
    def test_empty_commandfilter(self):
        f = filters.CommandFilter("sleep", "root")
        self.assertFalse(f.match([]))
        self.assertFalse(f.match(None))
 
    def test_empty_regexpfilter(self):
        f = filters.RegExpFilter("sleep", "root", "sleep")
        self.assertFalse(f.match([]))
        self.assertFalse(f.match(None))

src/z/u/zuul-HEAD/tests/test_scheduler.py   zuul(Download)
        self.assertTrue(self.job_has_changes(self.builds[2], B))
        self.assertTrue(self.job_has_changes(self.builds[4], A))
        self.assertFalse(self.job_has_changes(self.builds[4], B))
        self.assertTrue(self.job_has_changes(self.builds[4], C))
 
        self.assertEqual(self.builds[3].name, 'project-test2')  # C
 
        self.assertFalse(self.job_has_changes(self.builds[1], A))
        self.assertTrue(self.job_has_changes(self.builds[1], B))
        self.assertFalse(self.job_has_changes(self.builds[1], C))
 
        self.assertFalse(self.job_has_changes(self.builds[2], A))
        a = self.sched.triggers['gerrit'].getChange(1, 2)
        mgr = self.sched.layout.pipelines['gate'].manager
        self.assertFalse(trigger.canMerge(a, mgr.getSubmitAllowNeeds()))
 
        A.addApproval('CRVW', 2)

src/z/u/zuul-2.0.0/tests/test_scheduler.py   zuul(Download)
        self.assertTrue(self.job_has_changes(self.builds[2], B))
        self.assertTrue(self.job_has_changes(self.builds[4], A))
        self.assertFalse(self.job_has_changes(self.builds[4], B))
        self.assertTrue(self.job_has_changes(self.builds[4], C))
 
        self.assertEqual(self.builds[3].name, 'project-test2')  # C
 
        self.assertFalse(self.job_has_changes(self.builds[1], A))
        self.assertTrue(self.job_has_changes(self.builds[1], B))
        self.assertFalse(self.job_has_changes(self.builds[1], C))
 
        self.assertFalse(self.job_has_changes(self.builds[2], A))
        a = self.sched.triggers['gerrit'].getChange(1, 2)
        mgr = self.sched.layout.pipelines['gate'].manager
        self.assertFalse(trigger.canMerge(a, mgr.getSubmitAllowNeeds()))
 
        A.addApproval('CRVW', 2)

src/h/e/heat-HEAD/heat/tests/test_properties.py   heat(Download)
        self.assertIsNone(s.description)
        self.assertIsNone(s.default)
        self.assertFalse(s.required)
        self.assertEqual(0, len(s.constraints))
 
        self.assertEqual(description, schema.description)
        self.assertIsNone(schema.default)
        self.assertFalse(schema.required)
        self.assertEqual(1, len(schema.constraints))
 
        self.assertEqual(description, schema.description)
        self.assertIsNone(schema.default)
        self.assertFalse(schema.required)
        self.assertEqual(1, len(schema.constraints))
 
        self.assertEqual(description, schema.description)
        self.assertIsNone(schema.default)
        self.assertFalse(schema.required)
        self.assertEqual(2, len(schema.constraints))
 
        schema = properties.Schema.from_parameter(param)
 
        self.assertFalse(schema.required)
        self.assertEqual(1, len(schema.constraints))
 

src/m/o/mox3-0.7.0/mox3/tests/test_mox.py   mox3(Download)
    def testInvalidOr(self):
        """Or should be False if both Comparators return False."""
        self.assertFalse(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0)
 
 
    def testClauseOneFails(self):
        """And should be False if the first Comparator returns False."""
 
        self.assertFalse(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')
 
    def testAdvancedUsageFails(self):
        """Note: this test is reliant on In and ContainsKeyValue."""
        test_dict = {"mock": "obj", "testing": "isCOOL"}
        self.assertFalse(mox.And(mox.In("NOTFOUND"),
                         mox.ContainsKeyValue("mock", "obj")) == test_dict)
 
        self.assertTrue(mox.Func(equals_one) == 1)
        self.assertFalse(mox.Func(equals_one) == 0)
 
        self.assertFalse(mox.Func(always_none) == 1)

  1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9  Next