python-openapi
diff --git a/openapi_core/deserializing/media_types/deserializers.py b/openapi_core/deserializing/media_types/deserializers.py
@@ -172,7 +172,7 @@ def decode(
             except KeyError:
                 if "default" not in prop_schema:
                     continue
-                properties[prop_name] = prop_schema["default"]
+                properties[prop_name] = (prop_schema / "default").read_value()
 
         if schema_only:
             return properties

diff --git a/openapi_core/schema/servers.py b/openapi_core/schema/servers.py
@@ -15,12 +15,13 @@ def get_server_default_variables(server: SchemaPath) -> Dict[str, Any]:
     defaults = {}
     variables = server / "variables"
     for name, variable in list(variables.str_items()):
-        defaults[name] = variable["default"]
+        defaults[name] = (variable / "default").read_value()
     return defaults
 
 
 def get_server_url(server: SchemaPath, **variables: Any) -> str:
     if not variables:
         variables = get_server_default_variables(server)
-    assert isinstance(server["url"], str)
-    return server["url"].format(**variables)
+    url = (server / "url").read_value()
+    assert isinstance(url, str)
+    return url.format(**variables)
diff --git a/openapi_core/unmarshalling/schemas/unmarshallers.py b/openapi_core/unmarshalling/schemas/unmarshallers.py
@@ -100,7 +100,7 @@ def _unmarshal_properties(
             except KeyError:
                 if "default" not in prop_schema:
                     continue
-                prop_value = prop_schema["default"]
+                prop_value = (prop_schema / "default").read_value()
 
             properties[prop_name] = self.schema_unmarshaller.evolve(
                 prop_schema

diff --git a/openapi_core/validation/validators.py b/openapi_core/validation/validators.py
@@ -232,7 +232,7 @@ def _get_simple_param_or_header(
         except KeyError:
             if "default" not in schema:
                 raise
-            return schema["default"], schema
+            return (schema / "default").read_value(), schema
         if allow_empty_values is not None:
             warnings.warn(
                 "Use of allowEmptyValue property is deprecated",

diff --git a/tests/integration/schema/test_spec.py b/tests/integration/schema/test_spec.py
@@ -3,6 +3,7 @@
 import pytest
 from jsonschema_path import SchemaPath
 
+from openapi_core.schema.servers import get_server_default_variables
 from openapi_core.schema.servers import get_server_url
 from openapi_core.schema.specs import get_spec_url
 
@@ -352,3 +353,18 @@ def test_spec(self, schema_path, spec_dict):
         schemas = components.get("schemas", {})
         for schema_name, schema in schemas.items():
             assert spec_dict["components"]["schemas"][schema_name] is not None
+
+
+def test_get_server_default_variables():
+    server_spec = {
+        "url": "https://{host}.example.com:{port}/v1",
+        "variables": {
+            "host": {"default": "api"},
+            "port": {"default": "8080"},
+        },
+    }
+    server = SchemaPath.from_dict(server_spec)
+
+    defaults = get_server_default_variables(server)
+
+    assert defaults == {"host": "api", "port": "8080"}
diff --git a/tests/integration/unmarshalling/test_request_unmarshaller.py b/tests/integration/unmarshalling/test_request_unmarshaller.py
@@ -423,3 +423,47 @@ def test_get_pet(self, request_unmarshaller):
         assert result.security == {
             "petstore_auth": self.api_key_encoded,
         }
+
+    def test_request_body_with_object_default(self):
+        from openapi_core import OpenAPI
+
+        spec = OpenAPI.from_dict(
+            {
+                "openapi": "3.1.0",
+                "info": {"version": "0", "title": "test"},
+                "paths": {
+                    "/test": {
+                        "post": {
+                            "requestBody": {
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            "properties": {
+                                                "tags": {
+                                                    "type": "array",
+                                                    "default": [],
+                                                }
+                                            },
+                                        }
+                                    }
+                                }
+                            },
+                            "responses": {"200": {"description": ""}},
+                        },
+                    }
+                },
+            }
+        )
+        request = MockRequest(
+            "http://localhost",
+            "post",
+            "/test",
+            content_type="application/json",
+            data=b"{}",
+        )
+
+        result = spec.unmarshal_request(request)
+
+        assert result.errors == []
+        assert result.body == {"tags": []}
diff --git a/tests/integration/validation/test_request_validators.py b/tests/integration/validation/test_request_validators.py
@@ -184,3 +184,60 @@ def test_valid(self, request_validator):
         result = request_validator.validate(request)
 
         assert result is None
+
+    def test_array_parameter_with_empty_default(self):
+        spec = OpenAPI.from_dict(
+            {
+                "openapi": "3.1.0",
+                "info": {"version": "0", "title": "test"},
+                "paths": {
+                    "/test": {
+                        "get": {
+                            "parameters": [
+                                {
+                                    "name": "foo",
+                                    "in": "query",
+                                    "schema": {"type": "array", "default": []},
+                                }
+                            ],
+                            "responses": {"200": {"description": ""}},
+                        },
+                    }
+                },
+            }
+        )
+        request = MockRequest("http://localhost", "get", "/test")
+
+        result = spec.validate_request(request)
+
+        assert result is None
+
+    def test_array_parameter_with_populated_default(self):
+        spec = OpenAPI.from_dict(
+            {
+                "openapi": "3.1.0",
+                "info": {"version": "0", "title": "test"},
+                "paths": {
+                    "/test": {
+                        "get": {
+                            "parameters": [
+                                {
+                                    "name": "foo",
+                                    "in": "query",
+                                    "schema": {
+                                        "type": "array",
+                                        "default": ["a", "b", "c"],
+                                    },
+                                }
+                            ],
+                            "responses": {"200": {"description": ""}},
+                        },
+                    }
+                },
+            }
+        )
+        request = MockRequest("http://localhost", "get", "/test")
+
+        result = spec.validate_request(request)
+
+        assert result is None
diff --git a/tests/unit/deserializing/test_media_types_deserializers.py b/tests/unit/deserializing/test_media_types_deserializers.py
@@ -637,3 +637,22 @@ def test_urlencoded_oneof_boolean_field(self, spec, deserializer_factory):
             "enabled": True,
             "mode": "auto",
         }
+
+    def test_urlencoded_form_with_array_default(self, deserializer_factory):
+        mimetype = "application/x-www-form-urlencoded"
+        schema_dict = {
+            "type": "object",
+            "properties": {
+                "tags": {
+                    "type": "array",
+                    "default": [],
+                },
+            },
+        }
+        schema = SchemaPath.from_dict(schema_dict)
+        deserializer = deserializer_factory(mimetype, schema=schema)
+        value = b""
+
+        result = deserializer.deserialize(value)
+
+        assert result == {"tags": []}