def test_can_be_pickled(self):
     obj = [1, 2, 3]
     delegator = SimpleDelegator(obj)
     pickled = pickle.dumps(delegator)
     del delegator
     unpickled_delegator = pickle.loads(pickled)
     expect(get_delegated(unpickled_delegator)) == obj

        def is_returned_when_file_exists(template):
            template.root = "my_root"

            with patch('pathlib.Path.is_file', Mock(return_value=True)):
                path = template.path

            expect(path) == Path("my_root/abc/default.png")

 def should_be_sigmoid_of_sum_of_incoming_values(self):
     incoming = StubSynapse(1.0)
     neuron = Neuron()
     neuron.add_incoming(incoming)
     neuron.add_incoming(incoming)
     neuron.fire()
     expect(neuron.activation) == sigmoid(2.0)

 def test_display_non_verbose(self, stdout):
     locs = NumberedPoints(['Home', '52.168;0.040'],
                           config_locations={'Home': (52.015, -0.221)})
     locs.format = 'locator'
     locs.verbose = False
     locs.display('extsquare')
     expect(stdout.getvalue()) == 'IO92va33\nJO02ae40\n'

 def it_expects_greater_than_or_equal(self):
     expect(1) >= 1
     expect(2) >= 1
     def _fails(): expect(1) >= 2
     assert_raises(AssertionError, _fails)
     assert fail_msg(_fails) == (
         'Expected something greater than or equal to 2 but got 1')

    def when_off_ci(monkeypatch):
        monkeypatch.delenv('CI', raising=False)
        monkeypatch.delenv('CONTINUOUS_INTEGRATION', raising=False)
        monkeypatch.delenv('TRAVIS', raising=False)
        monkeypatch.delenv('APPVEYOR', raising=False)

        expect(services.detected()) == False

 def it_expects_containment(self):
     expect([1]).contains(1)
     def _fails():
         expect([2]).contains(1)
     assert_raises(AssertionError, _fails)
     assert fail_msg(_fails) == (
         "Expected [2] to contain 1 but it didn't")

 def test___repr__(self):
     expect(repr(Cell(4, 52.015, -0.221, 21, 46, 40000, 10, 0, 1,
                      datetime.datetime(2008, 4, 15, 15, 21, 35),
                      datetime.datetime(2008, 4, 15, 15, 28, 49)))) == \
         ('Cell(4, 52.015, -0.221, 21, 46, 40000, 10, 0, 1, '
          'datetime.datetime(2008, 4, 15, 15, 21, 35), '
          'datetime.datetime(2008, 4, 15, 15, 28, 49))')

 def test_relevant_changes(self):
     ok = SprinterChange(pk=1, component='Forms')
     not_ok = SprinterChange(pk=2, component='ORM')
     achievement = Achievement(component='Forms')
     changes = [ok, not_ok]
     filtered = achievement.relevant_changes(changes)
     expect(filtered) == [ok]

    def test_get(self, outbox_class):
        outbox_class.return_value.get.return_value = self.mail

        response = self.client.get(self._reverse())

        expect(response.status_code) == 200
        expect(response.context['mail']) == self.mail

 def test_import_locations(self):
     trackpoints = Trackpoints(open("tests/data/gpx_tracks"))
     data = list(map(str, sorted(trackpoints[0], key=lambda x: x.name)))
     expect(data[0]) == """Home (52°00'54"N, 000°13'15"W on 2008-07-26T00:00:00+00:00) [My place]"""
     expect(
         data[1]
     ) == """MSR (52°10'01"N, 000°23'24"E on 2008-07-27T00:00:00+00:00) [Microsoft Research, Cambridge]"""

        def it_redirects_to_lose_alt_when_bad_url(client):
            url = "http:invalid"
            response = client.get("/sad-biden/hello.jpg?alt=" + url)

            expect(response.status_code) == 302
            expect(load(response, as_json=False)).contains(
                '<a href="/sad-biden/hello.jpg">')

        def it_redirects_to_lose_alt_when_unknown_url(client):
            url = "http://example.com/not/a/real/image.jpg"
            response = client.get("/sad-biden/hello.jpg?alt=" + url)

            expect(response.status_code) == 302
            expect(load(response, as_json=False)).contains(
                '<a href="/sad-biden/hello.jpg">')

 def test_can_read_from_properties(self):
     class C(SimpleDelegator):
         @property
         def prop(self):
             return 123
     c = C(mock.Mock())
     expect(c.prop) == 123

 def it_can_compare_bytes(self):
     null = bytes((0,))
     expect(null) == null
     data = bytes(range(9, 32))
     def _fails():
         expect(data) == data + null
     assert_raises(AssertionError, _fails)

        def it_returns_an_error_when_no_metrics_specified(client):
            status, data = load(client.put("/my_owner/my_repo"))

            expect(status) == 400
            expect(data) == {
                'message': "No metrics provided."
            }

 def test_dump_zone_file(self):
     zones = Zones(open("tests/data/timezones"))
     expect(Zones.dump_zone_file(zones)) == [
         "AN\t+121100-0690000\tAmerica/Curacao",
         "AO\t-084800+0131400\tAfrica/Luanda",
         "AQ\t-775000+1663600\tAntarctica/McMurdo\tMcMurdo Station, Ross Island",
     ]

        def it_returns_an_error_for_unknown_projects(client):
            status, data = load(client.get("/unknown/project"))

            expect(status) == 404
            expect(data) == {
                'message': "No such project."
            }

    def with_dashes(client):
        status, data = load(client.get(
            "/api/templates/iw/HelloThere_World/How-areYOU"))

        expect(status) == 302
        expect(data).contains(
            '<a href="/api/templates/iw/hello_there_world/how_are_you">')

 def test_midpoint(self):
     expect(Point(52.015, -0.221).midpoint(Point(52.6333, -2.5))) == \
         Point(52.329631405407014, -1.3525368605590993, 'metric', 'degrees',
               0)
     expect(Point(36.1200, -86.6700).midpoint(Point(33.9400, -118.4000))) == \
         Point(36.08239491900365, -102.75217370539663, 'metric', 'degrees',
               0)